/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-

   This file is part of GNOME Reversi, also known as Iagno.

   Copyright 2019 — Arnaud Bonatti
   File updated by `ninja update-perfs-tests`

   GNOME Reversi is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   GNOME Reversi is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GNOME Reversi.  If not, see <https://www.gnu.org/licenses/>.
*/

namespace GeneratedTests
{
    private static void perfs_tests_reversi ()
    {
        /* crossing start position */
        Test.add_func ("/Reversi/reversi/Complete game 1",
                            test_complete_reversi_game_1);

        Test.add_func ("/Reversi/reversi/Complete game 2",
                            test_complete_reversi_game_2);

        Test.add_func ("/Reversi/reversi/Complete game 3",
                            test_complete_reversi_game_3);

        Test.add_func ("/Reversi/reversi/Complete game 4",
                            test_complete_reversi_game_4);

        Test.add_func ("/Reversi/reversi/Complete game 5",
                            test_complete_reversi_game_5);

        Test.add_func ("/Reversi/reversi/Complete game 6",
                            test_complete_reversi_game_6);

        Test.add_func ("/Reversi/reversi/Complete game 7",
                            test_complete_reversi_game_7);

        Test.add_func ("/Reversi/reversi/Complete game 8",
                            test_complete_reversi_game_8);

        Test.add_func ("/Reversi/reversi/Complete game 9",
                            test_complete_reversi_game_9);

        Test.add_func ("/Reversi/reversi/Complete game 10",
                            test_complete_reversi_game_10);

        Test.add_func ("/Reversi/reversi/Complete game 11",
                            test_complete_reversi_game_11);

        Test.add_func ("/Reversi/reversi/Complete game 12",
                            test_complete_reversi_game_12);

        Test.add_func ("/Reversi/reversi/Complete game 13",
                            test_complete_reversi_game_13);

        Test.add_func ("/Reversi/reversi/Complete game 14",
                            test_complete_reversi_game_14);

        Test.add_func ("/Reversi/reversi/Complete game 15",
                            test_complete_reversi_game_15);

        Test.add_func ("/Reversi/reversi/Complete game 16",
                            test_complete_reversi_game_16);

        Test.add_func ("/Reversi/reversi/Complete game 17",
                            test_complete_reversi_game_17);

        Test.add_func ("/Reversi/reversi/Complete game 18",
                            test_complete_reversi_game_18);

        Test.add_func ("/Reversi/reversi/Complete game 19",
                            test_complete_reversi_game_19);

        Test.add_func ("/Reversi/reversi/Complete game 20",
                            test_complete_reversi_game_20);

        Test.add_func ("/Reversi/reversi/Complete game 21",
                            test_complete_reversi_game_21);

        Test.add_func ("/Reversi/reversi/Complete game 22",
                            test_complete_reversi_game_22);

        Test.add_func ("/Reversi/reversi/Complete game 23",
                            test_complete_reversi_game_23);

        Test.add_func ("/Reversi/reversi/Complete game 24",
                            test_complete_reversi_game_24);

        Test.add_func ("/Reversi/reversi/Complete game 25",
                            test_complete_reversi_game_25);

        Test.add_func ("/Reversi/reversi/Complete game 26",
                            test_complete_reversi_game_26);

        Test.add_func ("/Reversi/reversi/Complete game 27",
                            test_complete_reversi_game_27);

        Test.add_func ("/Reversi/reversi/Complete game 28",
                            test_complete_reversi_game_28);

        Test.add_func ("/Reversi/reversi/Complete game 29",
                            test_complete_reversi_game_29);

        Test.add_func ("/Reversi/reversi/Complete game 30",
                            test_complete_reversi_game_30);

        Test.add_func ("/Reversi/reversi/Complete game 31",
                            test_complete_reversi_game_31);

        Test.add_func ("/Reversi/reversi/Complete game 32",
                            test_complete_reversi_game_32);

        Test.add_func ("/Reversi/reversi/Complete game 33",
                            test_complete_reversi_game_33);

        Test.add_func ("/Reversi/reversi/Complete game 34",
                            test_complete_reversi_game_34);

        Test.add_func ("/Reversi/reversi/Complete game 35",
                            test_complete_reversi_game_35);

        Test.add_func ("/Reversi/reversi/Complete game 36",
                            test_complete_reversi_game_36);

        Test.add_func ("/Reversi/reversi/Complete game 37",
                            test_complete_reversi_game_37);

        Test.add_func ("/Reversi/reversi/Complete game 38",
                            test_complete_reversi_game_38);

        Test.add_func ("/Reversi/reversi/Complete game 39",
                            test_complete_reversi_game_39);

        Test.add_func ("/Reversi/reversi/Complete game 40",
                            test_complete_reversi_game_40);

        Test.add_func ("/Reversi/reversi/Complete game 41",
                            test_complete_reversi_game_41);

        Test.add_func ("/Reversi/reversi/Complete game 42",
                            test_complete_reversi_game_42);

        Test.add_func ("/Reversi/reversi/Complete game 43",
                            test_complete_reversi_game_43);

        Test.add_func ("/Reversi/reversi/Complete game 44",
                            test_complete_reversi_game_44);

        Test.add_func ("/Reversi/reversi/Complete game 45",
                            test_complete_reversi_game_45);

        Test.add_func ("/Reversi/reversi/Complete game 46",
                            test_complete_reversi_game_46);

        Test.add_func ("/Reversi/reversi/Complete game 47",
                            test_complete_reversi_game_47);

        Test.add_func ("/Reversi/reversi/Complete game 48",
                            test_complete_reversi_game_48);

        Test.add_func ("/Reversi/reversi/Complete game 49",
                            test_complete_reversi_game_49);

        Test.add_func ("/Reversi/reversi/Complete game 50",
                            test_complete_reversi_game_50);

        Test.add_func ("/Reversi/reversi/Complete game 51",
                            test_complete_reversi_game_51);

        Test.add_func ("/Reversi/reversi/Complete game 52",
                            test_complete_reversi_game_52);

        Test.add_func ("/Reversi/reversi/Complete game 53",
                            test_complete_reversi_game_53);

        Test.add_func ("/Reversi/reversi/Complete game 54",
                            test_complete_reversi_game_54);

        Test.add_func ("/Reversi/reversi/Complete game 55",
                            test_complete_reversi_game_55);

        Test.add_func ("/Reversi/reversi/Complete game 56",
                            test_complete_reversi_game_56);

        Test.add_func ("/Reversi/reversi/Complete game 57",
                            test_complete_reversi_game_57);

        Test.add_func ("/Reversi/reversi/Complete game 58",
                            test_complete_reversi_game_58);

        Test.add_func ("/Reversi/reversi/Complete game 59",
                            test_complete_reversi_game_59);

        Test.add_func ("/Reversi/reversi/Complete game 60",
                            test_complete_reversi_game_60);

        Test.add_func ("/Reversi/reversi/Complete game 61",
                            test_complete_reversi_game_61);

        Test.add_func ("/Reversi/reversi/Complete game 62",
                            test_complete_reversi_game_62);

        Test.add_func ("/Reversi/reversi/Complete game 63",
                            test_complete_reversi_game_63);

        Test.add_func ("/Reversi/reversi/Complete game 64",
                            test_complete_reversi_game_64);

        Test.add_func ("/Reversi/reversi/Complete game 65",
                            test_complete_reversi_game_65);

        Test.add_func ("/Reversi/reversi/Complete game 66",
                            test_complete_reversi_game_66);

        Test.add_func ("/Reversi/reversi/Complete game 67",
                            test_complete_reversi_game_67);

        Test.add_func ("/Reversi/reversi/Complete game 68",
                            test_complete_reversi_game_68);

        Test.add_func ("/Reversi/reversi/Complete game 69",
                            test_complete_reversi_game_69);

        Test.add_func ("/Reversi/reversi/Complete game 70",
                            test_complete_reversi_game_70);

        Test.add_func ("/Reversi/reversi/Complete game 71",
                            test_complete_reversi_game_71);

        Test.add_func ("/Reversi/reversi/Complete game 72",
                            test_complete_reversi_game_72);

        Test.add_func ("/Reversi/reversi/Complete game 73",
                            test_complete_reversi_game_73);

        Test.add_func ("/Reversi/reversi/Complete game 74",
                            test_complete_reversi_game_74);

        Test.add_func ("/Reversi/reversi/Complete game 75",
                            test_complete_reversi_game_75);

        Test.add_func ("/Reversi/reversi/Complete game 76",
                            test_complete_reversi_game_76);

        Test.add_func ("/Reversi/reversi/Complete game 77",
                            test_complete_reversi_game_77);

        Test.add_func ("/Reversi/reversi/Complete game 78",
                            test_complete_reversi_game_78);

        Test.add_func ("/Reversi/reversi/Complete game 79",
                            test_complete_reversi_game_79);

        Test.add_func ("/Reversi/reversi/Complete game 80",
                            test_complete_reversi_game_80);

        Test.add_func ("/Reversi/reversi/Complete game 81",
                            test_complete_reversi_game_81);

        Test.add_func ("/Reversi/reversi/Complete game 82",
                            test_complete_reversi_game_82);

        Test.add_func ("/Reversi/reversi/Complete game 83",
                            test_complete_reversi_game_83);

        Test.add_func ("/Reversi/reversi/Complete game 84",
                            test_complete_reversi_game_84);

        Test.add_func ("/Reversi/reversi/Complete game 85",
                            test_complete_reversi_game_85);

        Test.add_func ("/Reversi/reversi/Complete game 86",
                            test_complete_reversi_game_86);

        Test.add_func ("/Reversi/reversi/Complete game 87",
                            test_complete_reversi_game_87);

        Test.add_func ("/Reversi/reversi/Complete game 88",
                            test_complete_reversi_game_88);

        Test.add_func ("/Reversi/reversi/Complete game 89",
                            test_complete_reversi_game_89);

        Test.add_func ("/Reversi/reversi/Complete game 90",
                            test_complete_reversi_game_90);

        Test.add_func ("/Reversi/reversi/Complete game 91",
                            test_complete_reversi_game_91);

        Test.add_func ("/Reversi/reversi/Complete game 92",
                            test_complete_reversi_game_92);

        Test.add_func ("/Reversi/reversi/Complete game 93",
                            test_complete_reversi_game_93);

        Test.add_func ("/Reversi/reversi/Complete game 94",
                            test_complete_reversi_game_94);

        Test.add_func ("/Reversi/reversi/Complete game 95",
                            test_complete_reversi_game_95);

        Test.add_func ("/Reversi/reversi/Complete game 96",
                            test_complete_reversi_game_96);

        Test.add_func ("/Reversi/reversi/Complete game 97",
                            test_complete_reversi_game_97);

        Test.add_func ("/Reversi/reversi/Complete game 98",
                            test_complete_reversi_game_98);

        Test.add_func ("/Reversi/reversi/Complete game 99",
                            test_complete_reversi_game_99);

        Test.add_func ("/Reversi/reversi/Complete game 100",
                            test_complete_reversi_game_100);

        Test.add_func ("/Reversi/reversi/Complete game 101",
                            test_complete_reversi_game_101);

        Test.add_func ("/Reversi/reversi/Complete game 102",
                            test_complete_reversi_game_102);

        Test.add_func ("/Reversi/reversi/Complete game 103",
                            test_complete_reversi_game_103);

        Test.add_func ("/Reversi/reversi/Complete game 104",
                            test_complete_reversi_game_104);

        Test.add_func ("/Reversi/reversi/Complete game 105",
                            test_complete_reversi_game_105);

        Test.add_func ("/Reversi/reversi/Complete game 106",
                            test_complete_reversi_game_106);

        Test.add_func ("/Reversi/reversi/Complete game 107",
                            test_complete_reversi_game_107);

        Test.add_func ("/Reversi/reversi/Complete game 108",
                            test_complete_reversi_game_108);

        Test.add_func ("/Reversi/reversi/Complete game 109",
                            test_complete_reversi_game_109);

        Test.add_func ("/Reversi/reversi/Complete game 110",
                            test_complete_reversi_game_110);

        Test.add_func ("/Reversi/reversi/Complete game 111",
                            test_complete_reversi_game_111);

        Test.add_func ("/Reversi/reversi/Complete game 112",
                            test_complete_reversi_game_112);

        Test.add_func ("/Reversi/reversi/Complete game 113",
                            test_complete_reversi_game_113);

        Test.add_func ("/Reversi/reversi/Complete game 114",
                            test_complete_reversi_game_114);

        Test.add_func ("/Reversi/reversi/Complete game 115",
                            test_complete_reversi_game_115);

        Test.add_func ("/Reversi/reversi/Complete game 116",
                            test_complete_reversi_game_116);

        Test.add_func ("/Reversi/reversi/Complete game 117",
                            test_complete_reversi_game_117);

        Test.add_func ("/Reversi/reversi/Complete game 118",
                            test_complete_reversi_game_118);

        Test.add_func ("/Reversi/reversi/Complete game 119",
                            test_complete_reversi_game_119);

        Test.add_func ("/Reversi/reversi/Complete game 120",
                            test_complete_reversi_game_120);

        Test.add_func ("/Reversi/reversi/Complete game 121",
                            test_complete_reversi_game_121);

        Test.add_func ("/Reversi/reversi/Complete game 122",
                            test_complete_reversi_game_122);

        Test.add_func ("/Reversi/reversi/Complete game 123",
                            test_complete_reversi_game_123);

        Test.add_func ("/Reversi/reversi/Complete game 124",
                            test_complete_reversi_game_124);

        Test.add_func ("/Reversi/reversi/Complete game 125",
                            test_complete_reversi_game_125);

        Test.add_func ("/Reversi/reversi/Complete game 126",
                            test_complete_reversi_game_126);

        Test.add_func ("/Reversi/reversi/Complete game 127",
                            test_complete_reversi_game_127);

        Test.add_func ("/Reversi/reversi/Complete game 128",
                            test_complete_reversi_game_128);

        Test.add_func ("/Reversi/reversi/Complete game 129",
                            test_complete_reversi_game_129);

        Test.add_func ("/Reversi/reversi/Complete game 130",
                            test_complete_reversi_game_130);

        Test.add_func ("/Reversi/reversi/Complete game 131",
                            test_complete_reversi_game_131);

        Test.add_func ("/Reversi/reversi/Complete game 132",
                            test_complete_reversi_game_132);

        Test.add_func ("/Reversi/reversi/Complete game 133",
                            test_complete_reversi_game_133);

        Test.add_func ("/Reversi/reversi/Complete game 134",
                            test_complete_reversi_game_134);

        Test.add_func ("/Reversi/reversi/Complete game 135",
                            test_complete_reversi_game_135);

        Test.add_func ("/Reversi/reversi/Complete game 136",
                            test_complete_reversi_game_136);

        Test.add_func ("/Reversi/reversi/Complete game 137",
                            test_complete_reversi_game_137);

        Test.add_func ("/Reversi/reversi/Complete game 138",
                            test_complete_reversi_game_138);

        Test.add_func ("/Reversi/reversi/Complete game 139",
                            test_complete_reversi_game_139);

        Test.add_func ("/Reversi/reversi/Complete game 140",
                            test_complete_reversi_game_140);

        Test.add_func ("/Reversi/reversi/Complete game 141",
                            test_complete_reversi_game_141);

        Test.add_func ("/Reversi/reversi/Complete game 142",
                            test_complete_reversi_game_142);

        Test.add_func ("/Reversi/reversi/Complete game 143",
                            test_complete_reversi_game_143);

        Test.add_func ("/Reversi/reversi/Complete game 144",
                            test_complete_reversi_game_144);

        Test.add_func ("/Reversi/reversi/Complete game 145",
                            test_complete_reversi_game_145);

        Test.add_func ("/Reversi/reversi/Complete game 146",
                            test_complete_reversi_game_146);

        Test.add_func ("/Reversi/reversi/Complete game 147",
                            test_complete_reversi_game_147);

        Test.add_func ("/Reversi/reversi/Complete game 148",
                            test_complete_reversi_game_148);

        Test.add_func ("/Reversi/reversi/Complete game 149",
                            test_complete_reversi_game_149);

        Test.add_func ("/Reversi/reversi/Complete game 150",
                            test_complete_reversi_game_150);

        Test.add_func ("/Reversi/reversi/Complete game 151",
                            test_complete_reversi_game_151);

        Test.add_func ("/Reversi/reversi/Complete game 152",
                            test_complete_reversi_game_152);

        Test.add_func ("/Reversi/reversi/Complete game 153",
                            test_complete_reversi_game_153);

        Test.add_func ("/Reversi/reversi/Complete game 154",
                            test_complete_reversi_game_154);

        Test.add_func ("/Reversi/reversi/Complete game 155",
                            test_complete_reversi_game_155);

        Test.add_func ("/Reversi/reversi/Complete game 156",
                            test_complete_reversi_game_156);

        Test.add_func ("/Reversi/reversi/Complete game 157",
                            test_complete_reversi_game_157);

        Test.add_func ("/Reversi/reversi/Complete game 158",
                            test_complete_reversi_game_158);

        Test.add_func ("/Reversi/reversi/Complete game 159",
                            test_complete_reversi_game_159);

        Test.add_func ("/Reversi/reversi/Complete game 160",
                            test_complete_reversi_game_160);

        Test.add_func ("/Reversi/reversi/Complete game 161",
                            test_complete_reversi_game_161);

        Test.add_func ("/Reversi/reversi/Complete game 162",
                            test_complete_reversi_game_162);

        Test.add_func ("/Reversi/reversi/Complete game 163",
                            test_complete_reversi_game_163);

        Test.add_func ("/Reversi/reversi/Complete game 164",
                            test_complete_reversi_game_164);

        Test.add_func ("/Reversi/reversi/Complete game 165",
                            test_complete_reversi_game_165);

        Test.add_func ("/Reversi/reversi/Complete game 166",
                            test_complete_reversi_game_166);

        Test.add_func ("/Reversi/reversi/Complete game 167",
                            test_complete_reversi_game_167);

        Test.add_func ("/Reversi/reversi/Complete game 168",
                            test_complete_reversi_game_168);

        Test.add_func ("/Reversi/reversi/Complete game 169",
                            test_complete_reversi_game_169);

        Test.add_func ("/Reversi/reversi/Complete game 170",
                            test_complete_reversi_game_170);

        Test.add_func ("/Reversi/reversi/Complete game 171",
                            test_complete_reversi_game_171);

        Test.add_func ("/Reversi/reversi/Complete game 172",
                            test_complete_reversi_game_172);

        Test.add_func ("/Reversi/reversi/Complete game 173",
                            test_complete_reversi_game_173);

        Test.add_func ("/Reversi/reversi/Complete game 174",
                            test_complete_reversi_game_174);

        Test.add_func ("/Reversi/reversi/Complete game 175",
                            test_complete_reversi_game_175);

        Test.add_func ("/Reversi/reversi/Complete game 176",
                            test_complete_reversi_game_176);

        Test.add_func ("/Reversi/reversi/Complete game 177",
                            test_complete_reversi_game_177);

        Test.add_func ("/Reversi/reversi/Complete game 178",
                            test_complete_reversi_game_178);

        Test.add_func ("/Reversi/reversi/Complete game 179",
                            test_complete_reversi_game_179);

        Test.add_func ("/Reversi/reversi/Complete game 180",
                            test_complete_reversi_game_180);

        Test.add_func ("/Reversi/reversi/Complete game 181",
                            test_complete_reversi_game_181);

        Test.add_func ("/Reversi/reversi/Complete game 182",
                            test_complete_reversi_game_182);

        Test.add_func ("/Reversi/reversi/Complete game 183",
                            test_complete_reversi_game_183);

        Test.add_func ("/Reversi/reversi/Complete game 184",
                            test_complete_reversi_game_184);

        Test.add_func ("/Reversi/reversi/Complete game 185",
                            test_complete_reversi_game_185);

        Test.add_func ("/Reversi/reversi/Complete game 186",
                            test_complete_reversi_game_186);

        Test.add_func ("/Reversi/reversi/Complete game 187",
                            test_complete_reversi_game_187);

        Test.add_func ("/Reversi/reversi/Complete game 188",
                            test_complete_reversi_game_188);

        Test.add_func ("/Reversi/reversi/Complete game 189",
                            test_complete_reversi_game_189);

        Test.add_func ("/Reversi/reversi/Complete game 190",
                            test_complete_reversi_game_190);

        Test.add_func ("/Reversi/reversi/Complete game 191",
                            test_complete_reversi_game_191);

        Test.add_func ("/Reversi/reversi/Complete game 192",
                            test_complete_reversi_game_192);

        Test.add_func ("/Reversi/reversi/Complete game 193",
                            test_complete_reversi_game_193);

        Test.add_func ("/Reversi/reversi/Complete game 194",
                            test_complete_reversi_game_194);

        Test.add_func ("/Reversi/reversi/Complete game 195",
                            test_complete_reversi_game_195);

        Test.add_func ("/Reversi/reversi/Complete game 196",
                            test_complete_reversi_game_196);

        Test.add_func ("/Reversi/reversi/Complete game 197",
                            test_complete_reversi_game_197);

        Test.add_func ("/Reversi/reversi/Complete game 198",
                            test_complete_reversi_game_198);

        Test.add_func ("/Reversi/reversi/Complete game 199",
                            test_complete_reversi_game_199);

        Test.add_func ("/Reversi/reversi/Complete game 200",
                            test_complete_reversi_game_200);

        Test.add_func ("/Reversi/reversi/Complete game 201",
                            test_complete_reversi_game_201);

        Test.add_func ("/Reversi/reversi/Complete game 202",
                            test_complete_reversi_game_202);

        Test.add_func ("/Reversi/reversi/Complete game 203",
                            test_complete_reversi_game_203);

        Test.add_func ("/Reversi/reversi/Complete game 204",
                            test_complete_reversi_game_204);

        Test.add_func ("/Reversi/reversi/Complete game 205",
                            test_complete_reversi_game_205);

        Test.add_func ("/Reversi/reversi/Complete game 206",
                            test_complete_reversi_game_206);

        Test.add_func ("/Reversi/reversi/Complete game 207",
                            test_complete_reversi_game_207);

        Test.add_func ("/Reversi/reversi/Complete game 208",
                            test_complete_reversi_game_208);

        Test.add_func ("/Reversi/reversi/Complete game 209",
                            test_complete_reversi_game_209);

        Test.add_func ("/Reversi/reversi/Complete game 210",
                            test_complete_reversi_game_210);

        Test.add_func ("/Reversi/reversi/Complete game 211",
                            test_complete_reversi_game_211);

        Test.add_func ("/Reversi/reversi/Complete game 212",
                            test_complete_reversi_game_212);

        Test.add_func ("/Reversi/reversi/Complete game 213",
                            test_complete_reversi_game_213);

        Test.add_func ("/Reversi/reversi/Complete game 214",
                            test_complete_reversi_game_214);

        Test.add_func ("/Reversi/reversi/Complete game 215",
                            test_complete_reversi_game_215);

        Test.add_func ("/Reversi/reversi/Complete game 216",
                            test_complete_reversi_game_216);

        Test.add_func ("/Reversi/reversi/Complete game 217",
                            test_complete_reversi_game_217);

        Test.add_func ("/Reversi/reversi/Complete game 218",
                            test_complete_reversi_game_218);

        Test.add_func ("/Reversi/reversi/Complete game 219",
                            test_complete_reversi_game_219);

        Test.add_func ("/Reversi/reversi/Complete game 220",
                            test_complete_reversi_game_220);

        Test.add_func ("/Reversi/reversi/Complete game 221",
                            test_complete_reversi_game_221);

        Test.add_func ("/Reversi/reversi/Complete game 222",
                            test_complete_reversi_game_222);

        Test.add_func ("/Reversi/reversi/Complete game 223",
                            test_complete_reversi_game_223);

        Test.add_func ("/Reversi/reversi/Complete game 224",
                            test_complete_reversi_game_224);

        Test.add_func ("/Reversi/reversi/Complete game 225",
                            test_complete_reversi_game_225);

        Test.add_func ("/Reversi/reversi/Complete game 226",
                            test_complete_reversi_game_226);

        Test.add_func ("/Reversi/reversi/Complete game 227",
                            test_complete_reversi_game_227);

        Test.add_func ("/Reversi/reversi/Complete game 228",
                            test_complete_reversi_game_228);

        Test.add_func ("/Reversi/reversi/Complete game 229",
                            test_complete_reversi_game_229);

        Test.add_func ("/Reversi/reversi/Complete game 230",
                            test_complete_reversi_game_230);

        Test.add_func ("/Reversi/reversi/Complete game 231",
                            test_complete_reversi_game_231);

        Test.add_func ("/Reversi/reversi/Complete game 232",
                            test_complete_reversi_game_232);

        /* parallel start position */
        Test.add_func ("/Reversi/reversi/Complete game 233",
                            test_complete_reversi_game_233);

        Test.add_func ("/Reversi/reversi/Complete game 234",
                            test_complete_reversi_game_234);

        Test.add_func ("/Reversi/reversi/Complete game 235",
                            test_complete_reversi_game_235);

        Test.add_func ("/Reversi/reversi/Complete game 236",
                            test_complete_reversi_game_236);

        Test.add_func ("/Reversi/reversi/Complete game 237",
                            test_complete_reversi_game_237);

        Test.add_func ("/Reversi/reversi/Complete game 238",
                            test_complete_reversi_game_238);

        Test.add_func ("/Reversi/reversi/Complete game 239",
                            test_complete_reversi_game_239);

        Test.add_func ("/Reversi/reversi/Complete game 240",
                            test_complete_reversi_game_240);

        Test.add_func ("/Reversi/reversi/Complete game 241",
                            test_complete_reversi_game_241);

        Test.add_func ("/Reversi/reversi/Complete game 242",
                            test_complete_reversi_game_242);

        Test.add_func ("/Reversi/reversi/Complete game 243",
                            test_complete_reversi_game_243);

        Test.add_func ("/Reversi/reversi/Complete game 244",
                            test_complete_reversi_game_244);

        Test.add_func ("/Reversi/reversi/Complete game 245",
                            test_complete_reversi_game_245);

        Test.add_func ("/Reversi/reversi/Complete game 246",
                            test_complete_reversi_game_246);

        Test.add_func ("/Reversi/reversi/Complete game 247",
                            test_complete_reversi_game_247);

        Test.add_func ("/Reversi/reversi/Complete game 248",
                            test_complete_reversi_game_248);

        Test.add_func ("/Reversi/reversi/Complete game 249",
                            test_complete_reversi_game_249);

        Test.add_func ("/Reversi/reversi/Complete game 250",
                            test_complete_reversi_game_250);

        Test.add_func ("/Reversi/reversi/Complete game 251",
                            test_complete_reversi_game_251);

        Test.add_func ("/Reversi/reversi/Complete game 252",
                            test_complete_reversi_game_252);

        Test.add_func ("/Reversi/reversi/Complete game 253",
                            test_complete_reversi_game_253);

        Test.add_func ("/Reversi/reversi/Complete game 254",
                            test_complete_reversi_game_254);

        Test.add_func ("/Reversi/reversi/Complete game 255",
                            test_complete_reversi_game_255);

        Test.add_func ("/Reversi/reversi/Complete game 256",
                            test_complete_reversi_game_256);

        Test.add_func ("/Reversi/reversi/Complete game 257",
                            test_complete_reversi_game_257);

        Test.add_func ("/Reversi/reversi/Complete game 258",
                            test_complete_reversi_game_258);

        Test.add_func ("/Reversi/reversi/Complete game 259",
                            test_complete_reversi_game_259);

        Test.add_func ("/Reversi/reversi/Complete game 260",
                            test_complete_reversi_game_260);

        Test.add_func ("/Reversi/reversi/Complete game 261",
                            test_complete_reversi_game_261);

        Test.add_func ("/Reversi/reversi/Complete game 262",
                            test_complete_reversi_game_262);

        Test.add_func ("/Reversi/reversi/Complete game 263",
                            test_complete_reversi_game_263);

        Test.add_func ("/Reversi/reversi/Complete game 264",
                            test_complete_reversi_game_264);

        Test.add_func ("/Reversi/reversi/Complete game 265",
                            test_complete_reversi_game_265);

        Test.add_func ("/Reversi/reversi/Complete game 266",
                            test_complete_reversi_game_266);

        Test.add_func ("/Reversi/reversi/Complete game 267",
                            test_complete_reversi_game_267);

        Test.add_func ("/Reversi/reversi/Complete game 268",
                            test_complete_reversi_game_268);

        Test.add_func ("/Reversi/reversi/Complete game 269",
                            test_complete_reversi_game_269);

        Test.add_func ("/Reversi/reversi/Complete game 270",
                            test_complete_reversi_game_270);

        Test.add_func ("/Reversi/reversi/Complete game 271",
                            test_complete_reversi_game_271);

        Test.add_func ("/Reversi/reversi/Complete game 272",
                            test_complete_reversi_game_272);

        Test.add_func ("/Reversi/reversi/Complete game 273",
                            test_complete_reversi_game_273);

        Test.add_func ("/Reversi/reversi/Complete game 274",
                            test_complete_reversi_game_274);

        Test.add_func ("/Reversi/reversi/Complete game 275",
                            test_complete_reversi_game_275);

        Test.add_func ("/Reversi/reversi/Complete game 276",
                            test_complete_reversi_game_276);

        Test.add_func ("/Reversi/reversi/Complete game 277",
                            test_complete_reversi_game_277);

        Test.add_func ("/Reversi/reversi/Complete game 278",
                            test_complete_reversi_game_278);

        Test.add_func ("/Reversi/reversi/Complete game 279",
                            test_complete_reversi_game_279);

        Test.add_func ("/Reversi/reversi/Complete game 280",
                            test_complete_reversi_game_280);

        Test.add_func ("/Reversi/reversi/Complete game 281",
                            test_complete_reversi_game_281);

        Test.add_func ("/Reversi/reversi/Complete game 282",
                            test_complete_reversi_game_282);

        Test.add_func ("/Reversi/reversi/Complete game 283",
                            test_complete_reversi_game_283);

        Test.add_func ("/Reversi/reversi/Complete game 284",
                            test_complete_reversi_game_284);

        Test.add_func ("/Reversi/reversi/Complete game 285",
                            test_complete_reversi_game_285);

        Test.add_func ("/Reversi/reversi/Complete game 286",
                            test_complete_reversi_game_286);

        Test.add_func ("/Reversi/reversi/Complete game 287",
                            test_complete_reversi_game_287);

        Test.add_func ("/Reversi/reversi/Complete game 288",
                            test_complete_reversi_game_288);

        Test.add_func ("/Reversi/reversi/Complete game 289",
                            test_complete_reversi_game_289);

        Test.add_func ("/Reversi/reversi/Complete game 290",
                            test_complete_reversi_game_290);

        Test.add_func ("/Reversi/reversi/Complete game 291",
                            test_complete_reversi_game_291);

        Test.add_func ("/Reversi/reversi/Complete game 292",
                            test_complete_reversi_game_292);

        Test.add_func ("/Reversi/reversi/Complete game 293",
                            test_complete_reversi_game_293);

        Test.add_func ("/Reversi/reversi/Complete game 294",
                            test_complete_reversi_game_294);

        Test.add_func ("/Reversi/reversi/Complete game 295",
                            test_complete_reversi_game_295);

        Test.add_func ("/Reversi/reversi/Complete game 296",
                            test_complete_reversi_game_296);

        Test.add_func ("/Reversi/reversi/Complete game 297",
                            test_complete_reversi_game_297);

        Test.add_func ("/Reversi/reversi/Complete game 298",
                            test_complete_reversi_game_298);

        Test.add_func ("/Reversi/reversi/Complete game 299",
                            test_complete_reversi_game_299);

        Test.add_func ("/Reversi/reversi/Complete game 300",
                            test_complete_reversi_game_300);

        Test.add_func ("/Reversi/reversi/Complete game 301",
                            test_complete_reversi_game_301);

        Test.add_func ("/Reversi/reversi/Complete game 302",
                            test_complete_reversi_game_302);

        Test.add_func ("/Reversi/reversi/Complete game 303",
                            test_complete_reversi_game_303);

        Test.add_func ("/Reversi/reversi/Complete game 304",
                            test_complete_reversi_game_304);

        Test.add_func ("/Reversi/reversi/Complete game 305",
                            test_complete_reversi_game_305);

        Test.add_func ("/Reversi/reversi/Complete game 306",
                            test_complete_reversi_game_306);

        Test.add_func ("/Reversi/reversi/Complete game 307",
                            test_complete_reversi_game_307);

        Test.add_func ("/Reversi/reversi/Complete game 308",
                            test_complete_reversi_game_308);

        Test.add_func ("/Reversi/reversi/Complete game 309",
                            test_complete_reversi_game_309);

        Test.add_func ("/Reversi/reversi/Complete game 310",
                            test_complete_reversi_game_310);

        Test.add_func ("/Reversi/reversi/Complete game 311",
                            test_complete_reversi_game_311);

        Test.add_func ("/Reversi/reversi/Complete game 312",
                            test_complete_reversi_game_312);

        Test.add_func ("/Reversi/reversi/Complete game 313",
                            test_complete_reversi_game_313);

        Test.add_func ("/Reversi/reversi/Complete game 314",
                            test_complete_reversi_game_314);

        Test.add_func ("/Reversi/reversi/Complete game 315",
                            test_complete_reversi_game_315);

        Test.add_func ("/Reversi/reversi/Complete game 316",
                            test_complete_reversi_game_316);

        Test.add_func ("/Reversi/reversi/Complete game 317",
                            test_complete_reversi_game_317);

        Test.add_func ("/Reversi/reversi/Complete game 318",
                            test_complete_reversi_game_318);

        Test.add_func ("/Reversi/reversi/Complete game 319",
                            test_complete_reversi_game_319);

        Test.add_func ("/Reversi/reversi/Complete game 320",
                            test_complete_reversi_game_320);

        Test.add_func ("/Reversi/reversi/Complete game 321",
                            test_complete_reversi_game_321);

        Test.add_func ("/Reversi/reversi/Complete game 322",
                            test_complete_reversi_game_322);

        Test.add_func ("/Reversi/reversi/Complete game 323",
                            test_complete_reversi_game_323);

        Test.add_func ("/Reversi/reversi/Complete game 324",
                            test_complete_reversi_game_324);

        Test.add_func ("/Reversi/reversi/Complete game 325",
                            test_complete_reversi_game_325);

        Test.add_func ("/Reversi/reversi/Complete game 326",
                            test_complete_reversi_game_326);

        Test.add_func ("/Reversi/reversi/Complete game 327",
                            test_complete_reversi_game_327);

        Test.add_func ("/Reversi/reversi/Complete game 328",
                            test_complete_reversi_game_328);

        Test.add_func ("/Reversi/reversi/Complete game 329",
                            test_complete_reversi_game_329);

        Test.add_func ("/Reversi/reversi/Complete game 330",
                            test_complete_reversi_game_330);

        Test.add_func ("/Reversi/reversi/Complete game 331",
                            test_complete_reversi_game_331);

        Test.add_func ("/Reversi/reversi/Complete game 332",
                            test_complete_reversi_game_332);

        Test.add_func ("/Reversi/reversi/Complete game 333",
                            test_complete_reversi_game_333);

        Test.add_func ("/Reversi/reversi/Complete game 334",
                            test_complete_reversi_game_334);

        Test.add_func ("/Reversi/reversi/Complete game 335",
                            test_complete_reversi_game_335);

        Test.add_func ("/Reversi/reversi/Complete game 336",
                            test_complete_reversi_game_336);

        Test.add_func ("/Reversi/reversi/Complete game 337",
                            test_complete_reversi_game_337);

        Test.add_func ("/Reversi/reversi/Complete game 338",
                            test_complete_reversi_game_338);

        Test.add_func ("/Reversi/reversi/Complete game 339",
                            test_complete_reversi_game_339);

        Test.add_func ("/Reversi/reversi/Complete game 340",
                            test_complete_reversi_game_340);

        Test.add_func ("/Reversi/reversi/Complete game 341",
                            test_complete_reversi_game_341);

        Test.add_func ("/Reversi/reversi/Complete game 342",
                            test_complete_reversi_game_342);

        Test.add_func ("/Reversi/reversi/Complete game 343",
                            test_complete_reversi_game_343);

        Test.add_func ("/Reversi/reversi/Complete game 344",
                            test_complete_reversi_game_344);

        Test.add_func ("/Reversi/reversi/Complete game 345",
                            test_complete_reversi_game_345);

        Test.add_func ("/Reversi/reversi/Complete game 346",
                            test_complete_reversi_game_346);

        Test.add_func ("/Reversi/reversi/Complete game 347",
                            test_complete_reversi_game_347);

        Test.add_func ("/Reversi/reversi/Complete game 348",
                            test_complete_reversi_game_348);

        Test.add_func ("/Reversi/reversi/Complete game 349",
                            test_complete_reversi_game_349);

        Test.add_func ("/Reversi/reversi/Complete game 350",
                            test_complete_reversi_game_350);

        Test.add_func ("/Reversi/reversi/Complete game 351",
                            test_complete_reversi_game_351);

        Test.add_func ("/Reversi/reversi/Complete game 352",
                            test_complete_reversi_game_352);

        Test.add_func ("/Reversi/reversi/Complete game 353",
                            test_complete_reversi_game_353);

        Test.add_func ("/Reversi/reversi/Complete game 354",
                            test_complete_reversi_game_354);

        Test.add_func ("/Reversi/reversi/Complete game 355",
                            test_complete_reversi_game_355);

        Test.add_func ("/Reversi/reversi/Complete game 356",
                            test_complete_reversi_game_356);

        Test.add_func ("/Reversi/reversi/Complete game 357",
                            test_complete_reversi_game_357);

        Test.add_func ("/Reversi/reversi/Complete game 358",
                            test_complete_reversi_game_358);

        Test.add_func ("/Reversi/reversi/Complete game 359",
                            test_complete_reversi_game_359);

        Test.add_func ("/Reversi/reversi/Complete game 360",
                            test_complete_reversi_game_360);

        Test.add_func ("/Reversi/reversi/Complete game 361",
                            test_complete_reversi_game_361);

        Test.add_func ("/Reversi/reversi/Complete game 362",
                            test_complete_reversi_game_362);

        Test.add_func ("/Reversi/reversi/Complete game 363",
                            test_complete_reversi_game_363);

        Test.add_func ("/Reversi/reversi/Complete game 364",
                            test_complete_reversi_game_364);

        Test.add_func ("/Reversi/reversi/Complete game 365",
                            test_complete_reversi_game_365);

        Test.add_func ("/Reversi/reversi/Complete game 366",
                            test_complete_reversi_game_366);

        Test.add_func ("/Reversi/reversi/Complete game 367",
                            test_complete_reversi_game_367);

        Test.add_func ("/Reversi/reversi/Complete game 368",
                            test_complete_reversi_game_368);

        Test.add_func ("/Reversi/reversi/Complete game 369",
                            test_complete_reversi_game_369);

        Test.add_func ("/Reversi/reversi/Complete game 370",
                            test_complete_reversi_game_370);

        Test.add_func ("/Reversi/reversi/Complete game 371",
                            test_complete_reversi_game_371);

        Test.add_func ("/Reversi/reversi/Complete game 372",
                            test_complete_reversi_game_372);

        Test.add_func ("/Reversi/reversi/Complete game 373",
                            test_complete_reversi_game_373);

        Test.add_func ("/Reversi/reversi/Complete game 374",
                            test_complete_reversi_game_374);

        Test.add_func ("/Reversi/reversi/Complete game 375",
                            test_complete_reversi_game_375);

        Test.add_func ("/Reversi/reversi/Complete game 376",
                            test_complete_reversi_game_376);

        Test.add_func ("/Reversi/reversi/Complete game 377",
                            test_complete_reversi_game_377);

        Test.add_func ("/Reversi/reversi/Complete game 378",
                            test_complete_reversi_game_378);

        Test.add_func ("/Reversi/reversi/Complete game 379",
                            test_complete_reversi_game_379);

        Test.add_func ("/Reversi/reversi/Complete game 380",
                            test_complete_reversi_game_380);

        Test.add_func ("/Reversi/reversi/Complete game 381",
                            test_complete_reversi_game_381);

        Test.add_func ("/Reversi/reversi/Complete game 382",
                            test_complete_reversi_game_382);

        Test.add_func ("/Reversi/reversi/Complete game 383",
                            test_complete_reversi_game_383);

        Test.add_func ("/Reversi/reversi/Complete game 384",
                            test_complete_reversi_game_384);

        Test.add_func ("/Reversi/reversi/Complete game 385",
                            test_complete_reversi_game_385);

        Test.add_func ("/Reversi/reversi/Complete game 386",
                            test_complete_reversi_game_386);

        Test.add_func ("/Reversi/reversi/Complete game 387",
                            test_complete_reversi_game_387);

        Test.add_func ("/Reversi/reversi/Complete game 388",
                            test_complete_reversi_game_388);

        Test.add_func ("/Reversi/reversi/Complete game 389",
                            test_complete_reversi_game_389);

        Test.add_func ("/Reversi/reversi/Complete game 390",
                            test_complete_reversi_game_390);

        Test.add_func ("/Reversi/reversi/Complete game 391",
                            test_complete_reversi_game_391);

        Test.add_func ("/Reversi/reversi/Complete game 392",
                            test_complete_reversi_game_392);

        Test.add_func ("/Reversi/reversi/Complete game 393",
                            test_complete_reversi_game_393);

        Test.add_func ("/Reversi/reversi/Complete game 394",
                            test_complete_reversi_game_394);

        Test.add_func ("/Reversi/reversi/Complete game 395",
                            test_complete_reversi_game_395);

        Test.add_func ("/Reversi/reversi/Complete game 396",
                            test_complete_reversi_game_396);

        Test.add_func ("/Reversi/reversi/Complete game 397",
                            test_complete_reversi_game_397);

        Test.add_func ("/Reversi/reversi/Complete game 398",
                            test_complete_reversi_game_398);

        Test.add_func ("/Reversi/reversi/Complete game 399",
                            test_complete_reversi_game_399);

        Test.add_func ("/Reversi/reversi/Complete game 400",
                            test_complete_reversi_game_400);

        Test.add_func ("/Reversi/reversi/Complete game 401",
                            test_complete_reversi_game_401);

        Test.add_func ("/Reversi/reversi/Complete game 402",
                            test_complete_reversi_game_402);

        Test.add_func ("/Reversi/reversi/Complete game 403",
                            test_complete_reversi_game_403);

        Test.add_func ("/Reversi/reversi/Complete game 404",
                            test_complete_reversi_game_404);

        Test.add_func ("/Reversi/reversi/Complete game 405",
                            test_complete_reversi_game_405);

        Test.add_func ("/Reversi/reversi/Complete game 406",
                            test_complete_reversi_game_406);

        Test.add_func ("/Reversi/reversi/Complete game 407",
                            test_complete_reversi_game_407);

        Test.add_func ("/Reversi/reversi/Complete game 408",
                            test_complete_reversi_game_408);

        Test.add_func ("/Reversi/reversi/Complete game 409",
                            test_complete_reversi_game_409);

        Test.add_func ("/Reversi/reversi/Complete game 410",
                            test_complete_reversi_game_410);

        Test.add_func ("/Reversi/reversi/Complete game 411",
                            test_complete_reversi_game_411);

        Test.add_func ("/Reversi/reversi/Complete game 412",
                            test_complete_reversi_game_412);

        Test.add_func ("/Reversi/reversi/Complete game 413",
                            test_complete_reversi_game_413);

        Test.add_func ("/Reversi/reversi/Complete game 414",
                            test_complete_reversi_game_414);

        Test.add_func ("/Reversi/reversi/Complete game 415",
                            test_complete_reversi_game_415);

        Test.add_func ("/Reversi/reversi/Complete game 416",
                            test_complete_reversi_game_416);

        Test.add_func ("/Reversi/reversi/Complete game 417",
                            test_complete_reversi_game_417);

        Test.add_func ("/Reversi/reversi/Complete game 418",
                            test_complete_reversi_game_418);

        Test.add_func ("/Reversi/reversi/Complete game 419",
                            test_complete_reversi_game_419);

        Test.add_func ("/Reversi/reversi/Complete game 420",
                            test_complete_reversi_game_420);

        Test.add_func ("/Reversi/reversi/Complete game 421",
                            test_complete_reversi_game_421);

        Test.add_func ("/Reversi/reversi/Complete game 422",
                            test_complete_reversi_game_422);

        Test.add_func ("/Reversi/reversi/Complete game 423",
                            test_complete_reversi_game_423);

        Test.add_func ("/Reversi/reversi/Complete game 424",
                            test_complete_reversi_game_424);

        Test.add_func ("/Reversi/reversi/Complete game 425",
                            test_complete_reversi_game_425);

        Test.add_func ("/Reversi/reversi/Complete game 426",
                            test_complete_reversi_game_426);

        Test.add_func ("/Reversi/reversi/Complete game 427",
                            test_complete_reversi_game_427);

        Test.add_func ("/Reversi/reversi/Complete game 428",
                            test_complete_reversi_game_428);

        Test.add_func ("/Reversi/reversi/Complete game 429",
                            test_complete_reversi_game_429);

        Test.add_func ("/Reversi/reversi/Complete game 430",
                            test_complete_reversi_game_430);

        Test.add_func ("/Reversi/reversi/Complete game 431",
                            test_complete_reversi_game_431);

        Test.add_func ("/Reversi/reversi/Complete game 432",
                            test_complete_reversi_game_432);

        Test.add_func ("/Reversi/reversi/Complete game 433",
                            test_complete_reversi_game_433);

        Test.add_func ("/Reversi/reversi/Complete game 434",
                            test_complete_reversi_game_434);

        Test.add_func ("/Reversi/reversi/Complete game 435",
                            test_complete_reversi_game_435);

        Test.add_func ("/Reversi/reversi/Complete game 436",
                            test_complete_reversi_game_436);

        Test.add_func ("/Reversi/reversi/Complete game 437",
                            test_complete_reversi_game_437);

        Test.add_func ("/Reversi/reversi/Complete game 438",
                            test_complete_reversi_game_438);

        Test.add_func ("/Reversi/reversi/Complete game 439",
                            test_complete_reversi_game_439);

        Test.add_func ("/Reversi/reversi/Complete game 440",
                            test_complete_reversi_game_440);

        Test.add_func ("/Reversi/reversi/Complete game 441",
                            test_complete_reversi_game_441);

        Test.add_func ("/Reversi/reversi/Complete game 442",
                            test_complete_reversi_game_442);

        Test.add_func ("/Reversi/reversi/Complete game 443",
                            test_complete_reversi_game_443);

        Test.add_func ("/Reversi/reversi/Complete game 444",
                            test_complete_reversi_game_444);

        Test.add_func ("/Reversi/reversi/Complete game 445",
                            test_complete_reversi_game_445);

        Test.add_func ("/Reversi/reversi/Complete game 446",
                            test_complete_reversi_game_446);

        Test.add_func ("/Reversi/reversi/Complete game 447",
                            test_complete_reversi_game_447);

        Test.add_func ("/Reversi/reversi/Complete game 448",
                            test_complete_reversi_game_448);

        Test.add_func ("/Reversi/reversi/Complete game 449",
                            test_complete_reversi_game_449);

        Test.add_func ("/Reversi/reversi/Complete game 450",
                            test_complete_reversi_game_450);

        Test.add_func ("/Reversi/reversi/Complete game 451",
                            test_complete_reversi_game_451);

        Test.add_func ("/Reversi/reversi/Complete game 452",
                            test_complete_reversi_game_452);

        Test.add_func ("/Reversi/reversi/Complete game 453",
                            test_complete_reversi_game_453);

        Test.add_func ("/Reversi/reversi/Complete game 454",
                            test_complete_reversi_game_454);

        Test.add_func ("/Reversi/reversi/Complete game 455",
                            test_complete_reversi_game_455);

        Test.add_func ("/Reversi/reversi/Complete game 456",
                            test_complete_reversi_game_456);

        Test.add_func ("/Reversi/reversi/Complete game 457",
                            test_complete_reversi_game_457);

        Test.add_func ("/Reversi/reversi/Complete game 458",
                            test_complete_reversi_game_458);

        Test.add_func ("/Reversi/reversi/Complete game 459",
                            test_complete_reversi_game_459);

        Test.add_func ("/Reversi/reversi/Complete game 460",
                            test_complete_reversi_game_460);

        Test.add_func ("/Reversi/reversi/Complete game 461",
                            test_complete_reversi_game_461);

        Test.add_func ("/Reversi/reversi/Complete game 462",
                            test_complete_reversi_game_462);

        Test.add_func ("/Reversi/reversi/Complete game 463",
                            test_complete_reversi_game_463);

        Test.add_func ("/Reversi/reversi/Complete game 464",
                            test_complete_reversi_game_464);

        Test.add_func ("/Reversi/reversi/Complete game 465",
                            test_complete_reversi_game_465);

        Test.add_func ("/Reversi/reversi/Complete game 466",
                            test_complete_reversi_game_466);

        Test.add_func ("/Reversi/reversi/Complete game 467",
                            test_complete_reversi_game_467);

        Test.add_func ("/Reversi/reversi/Complete game 468",
                            test_complete_reversi_game_468);

        Test.add_func ("/Reversi/reversi/Complete game 469",
                            test_complete_reversi_game_469);

        Test.add_func ("/Reversi/reversi/Complete game 470",
                            test_complete_reversi_game_470);

        Test.add_func ("/Reversi/reversi/Complete game 471",
                            test_complete_reversi_game_471);

        Test.add_func ("/Reversi/reversi/Complete game 472",
                            test_complete_reversi_game_472);

        Test.add_func ("/Reversi/reversi/Complete game 473",
                            test_complete_reversi_game_473);

        Test.add_func ("/Reversi/reversi/Complete game 474",
                            test_complete_reversi_game_474);

        Test.add_func ("/Reversi/reversi/Complete game 475",
                            test_complete_reversi_game_475);

        Test.add_func ("/Reversi/reversi/Complete game 476",
                            test_complete_reversi_game_476);

        Test.add_func ("/Reversi/reversi/Complete game 477",
                            test_complete_reversi_game_477);

        Test.add_func ("/Reversi/reversi/Complete game 478",
                            test_complete_reversi_game_478);

        Test.add_func ("/Reversi/reversi/Complete game 479",
                            test_complete_reversi_game_479);

        Test.add_func ("/Reversi/reversi/Complete game 480",
                            test_complete_reversi_game_480);

        Test.add_func ("/Reversi/reversi/Complete game 481",
                            test_complete_reversi_game_481);

        Test.add_func ("/Reversi/reversi/Complete game 482",
                            test_complete_reversi_game_482);

        Test.add_func ("/Reversi/reversi/Complete game 483",
                            test_complete_reversi_game_483);

        Test.add_func ("/Reversi/reversi/Complete game 484",
                            test_complete_reversi_game_484);

        Test.add_func ("/Reversi/reversi/Complete game 485",
                            test_complete_reversi_game_485);

        Test.add_func ("/Reversi/reversi/Complete game 486",
                            test_complete_reversi_game_486);

        Test.add_func ("/Reversi/reversi/Complete game 487",
                            test_complete_reversi_game_487);

        Test.add_func ("/Reversi/reversi/Complete game 488",
                            test_complete_reversi_game_488);

        Test.add_func ("/Reversi/reversi/Complete game 489",
                            test_complete_reversi_game_489);

        Test.add_func ("/Reversi/reversi/Complete game 490",
                            test_complete_reversi_game_490);

        Test.add_func ("/Reversi/reversi/Complete game 491",
                            test_complete_reversi_game_491);

        Test.add_func ("/Reversi/reversi/Complete game 492",
                            test_complete_reversi_game_492);

        Test.add_func ("/Reversi/reversi/Complete game 493",
                            test_complete_reversi_game_493);

        Test.add_func ("/Reversi/reversi/Complete game 494",
                            test_complete_reversi_game_494);

        Test.add_func ("/Reversi/reversi/Complete game 495",
                            test_complete_reversi_game_495);
    }

    /*\
    * * perfs tests
    \*/

    private static inline void test_complete_reversi_game_1 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . D L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_2 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L L L .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . D . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_3 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . D . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_4 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . D . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_5 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . L . D . .",
                           /* 6 */ " . . . . . D . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_6 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L L D . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . D . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_7 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_8 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L L L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_9 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L L .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_10 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_11 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_12 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_13 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_14 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . D L L L .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_15 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D L . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_16 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_17 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . L L L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_18 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_19 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . . . . L .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_20 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L L L .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_21 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_22 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_23 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_24 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . L . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_25 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . D . .",
                           /* 3 */ " . . . L L L L .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_26 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . D . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_27 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . D . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_28 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_29 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . L . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_30 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_31 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . L . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_32 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_33 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_34 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . L L L L . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_35 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . . . . L .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_36 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_37 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_38 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
    }

    private static inline void test_complete_reversi_game_39 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . L . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_40 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . L L L L . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
    }

    private static inline void test_complete_reversi_game_41 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L L L .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . D . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 5));
    }

    private static inline void test_complete_reversi_game_42 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . D . L . .",
                           /* 6 */ " . . D . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_43 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . D . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_44 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . D . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_45 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . D L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_46 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . D L . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_47 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . D L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_48 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . L L L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_49 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D D L D . .",
                           /* 5 */ " . . . L . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_50 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . D D L D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_51 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L D D D . .",
                           /* 5 */ " . L . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_52 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . L . L D . . .",
                           /* 4 */ " . . L D D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_53 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . L L L L .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_54 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D L . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_55 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_56 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
    }

    private static inline void test_complete_reversi_game_57 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . L . . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_58 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L L L .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_59 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_60 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_61 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_62 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L D .",
                           /* 6 */ " . . . . . . L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_63 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_64 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L D D .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_65 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_66 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . . L D D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_67 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . D D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_68 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_69 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L L L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_70 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L L . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_71 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_72 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L L L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_73 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_74 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_75 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L L . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_76 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_77 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L L L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_78 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_79 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_80 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L L L .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_81 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_82 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 5));
    }

    private static inline void test_complete_reversi_game_83 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_84 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . D .",
                           /* 3 */ " . . . L L D . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_85 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . D . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_86 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . L . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_87 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . D . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_88 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_89 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . L . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_90 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_91 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . L . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_92 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_93 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_94 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_95 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . L L L L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
    }

    private static inline void test_complete_reversi_game_96 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . L . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_97 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_98 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_99 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D L L . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_100 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . L L L L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_101 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . D . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_102 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . . D D L . .",
                           /* 6 */ " . . D . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_103 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . D . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_104 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . D . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_105 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . D . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_106 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . D L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_107 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D D D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_108 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . D D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_109 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . D L D . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_110 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . . L L L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_111 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_112 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . L . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_113 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . L . L D . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_114 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . L L L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_115 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_116 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_117 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_118 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L L L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_119 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_120 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_121 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_122 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
    }

    private static inline void test_complete_reversi_game_123 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_124 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_125 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
    }

    private static inline void test_complete_reversi_game_126 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_127 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L L L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_128 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . L . . . . .",
                           /* 2 */ " . . . L L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_129 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_130 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_131 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L L L . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_132 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L . L .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_133 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . L .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_134 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_135 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L L L . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_136 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . L . . .",
                           /* 2 */ " . . . D L D . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_137 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D D D . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_138 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D D D . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_139 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . L D . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_140 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . D D . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . L . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_141 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . D D . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_142 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . D D . . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_143 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . L D D . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_144 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . L . . D . .",
                           /* 2 */ " . . . L D . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_145 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_146 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_147 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_148 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . L . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_149 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_150 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_151 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_152 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_153 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . L . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_154 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_155 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_156 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_157 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_158 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_159 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . L . . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_160 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_161 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_162 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_163 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . L . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 2));
    }

    private static inline void test_complete_reversi_game_164 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_165 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . L L L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_166 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_167 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_168 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L L L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_169 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_170 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . L . . . .",
                           /* 2 */ " . . L L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_171 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_172 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_173 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L L L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_174 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_175 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . L . . . .",
                           /* 2 */ " . . L L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_176 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L L L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_177 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_178 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . D D D . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_179 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . D D D L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_180 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . D D D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_181 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . L . . . .",
                           /* 2 */ " . D D L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_182 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . D D D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_183 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . L . . . . . .",
                           /* 2 */ " . D L D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_184 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_185 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_186 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D L L . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_187 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . L L L L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_188 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . . . . L .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_189 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_190 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . L . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_191 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D L L . . .",
                           /* 4 */ " . . L D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_192 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . L L L L . . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_193 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D D L . .",
                           /* 4 */ " . . . D L . L .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_194 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . L .",
                           /* 3 */ " . . D D D L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_195 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D L D D . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_196 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . L . . .",
                           /* 3 */ " . . D L D D . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_197 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L L L .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_198 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L D . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_199 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . L D . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_200 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . L D . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_201 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . L . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_202 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_203 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . L . D . . .",
                           /* 3 */ " . . D L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_204 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . L L L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 2));
    }

    private static inline void test_complete_reversi_game_205 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_206 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_207 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_208 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_209 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_210 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . L . . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_211 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_212 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_213 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_214 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_215 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D L L . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_216 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_217 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . L L D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_218 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_219 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_220 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . L L L L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_221 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_222 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_223 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_224 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_225 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . L L L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_226 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . L . . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_227 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_228 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L L L . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_229 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_230 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . L L D . . .",
                           /* 4 */ " . . L D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_231 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . L L L D . . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_232 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_233 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . L D .",
                           /* 6 */ " . . . . . . L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_234 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L L L .",
                           /* 5 */ " . . . . . D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_235 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_236 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_237 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_238 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_239 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D D . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_240 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D D . .",
                           /* 4 */ " . . . L L L L .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_241 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . L .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_242 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L D . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_243 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L D . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_244 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_245 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_246 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D L . .",
                           /* 5 */ " . . . . L L . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_247 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D L . .",
                           /* 5 */ " . . . . D D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_248 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D L . .",
                           /* 5 */ " . . . . L D . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_249 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . L D L . .",
                           /* 5 */ " . . . . D D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_250 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D . L . .",
                           /* 6 */ " . . . . . . L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_251 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D . L . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_252 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_253 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_254 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . L . D . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_255 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 1));
    }

    private static inline void test_complete_reversi_game_256 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
    }

    private static inline void test_complete_reversi_game_257 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . . L . .",
                           /* 6 */ " . . . . . . L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 0));
    }

    private static inline void test_complete_reversi_game_258 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . . L . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_259 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_260 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_261 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_262 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_263 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_264 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . L . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_265 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . D L . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_266 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L L L . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_267 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D L D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_268 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_269 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_270 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . . . L D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_271 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D L D . . .",
                           /* 5 */ " . . L . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_272 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . D D D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_273 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . . L . .",
                           /* 6 */ " . . . . . . L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_274 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_275 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_276 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . D L . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_277 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_278 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . D D D L . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_279 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . D D D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_280 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D L D . . .",
                           /* 5 */ " . . . L . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_281 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . L . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_282 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_283 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . L . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_284 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . L . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_285 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . L . L . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_286 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D L . . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_287 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D L . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_288 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . L L L . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_289 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . . . . L . .",
                           /* 6 */ " . . . . . . L .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 5));
    }

    private static inline void test_complete_reversi_game_290 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_291 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_292 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . L . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_293 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D L . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_294 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . D L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_295 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . D L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_296 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . L L L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_297 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . D L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_298 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_299 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . L L L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_300 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_301 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_302 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . D . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_303 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_304 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . D L D . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_305 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L L L .",
                           /* 5 */ " . . . . D . D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_306 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . L . D .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
    }

    private static inline void test_complete_reversi_game_307 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . D . D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_308 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . L . D .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
    }

    private static inline void test_complete_reversi_game_309 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . D . D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
    }

    private static inline void test_complete_reversi_game_310 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . D . D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_311 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . D . D .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_312 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . D .",
                           /* 4 */ " . . . L L L L .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_313 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . D .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_314 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . D .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_315 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . D .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_316 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . D .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_317 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . D .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_318 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . D .",
                           /* 4 */ " . . . L L D . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_319 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D L . .",
                           /* 5 */ " . . . . L L . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_320 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D L . .",
                           /* 5 */ " . . . . D D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_321 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D L . .",
                           /* 5 */ " . . . . L D . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_322 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . L D L . .",
                           /* 5 */ " . . . . D D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_323 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_324 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
    }

    private static inline void test_complete_reversi_game_325 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_326 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_327 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_328 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_329 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_330 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_331 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_332 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . L . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_333 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
    }

    private static inline void test_complete_reversi_game_334 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_335 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_336 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_337 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_338 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_339 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_340 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_341 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . D L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_342 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D D D . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_343 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_344 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . L . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_345 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . D L . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_346 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . D L . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_347 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L L L . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_348 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_349 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_350 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_351 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_352 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D L D . . .",
                           /* 5 */ " . . L . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_353 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . D D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_354 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
    }

    private static inline void test_complete_reversi_game_355 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_356 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . L L L L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
    }

    private static inline void test_complete_reversi_game_357 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_358 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_359 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_360 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . D L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_361 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D D L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_362 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . D D D L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_363 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . D D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_364 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_365 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . L . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_366 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_367 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . D L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_368 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . L . D D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_369 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D L . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_370 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D L . . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_371 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . D L . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_372 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . L L L . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_373 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_374 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . . . D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_375 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L L L . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_376 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_377 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D . . . . .",
                           /* 2 */ " . . . D . L . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_378 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . D L . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_379 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D L D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_380 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
    }

    private static inline void test_complete_reversi_game_381 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_382 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_383 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . . D . . L .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_384 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_385 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . L D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_386 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . L D D D . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_387 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_388 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D D . L .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_389 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L D . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_390 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_391 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L L L .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_392 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L D . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_393 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L D . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_394 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . L D . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_395 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . L D . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_396 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_397 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . L D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_398 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_399 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_400 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . L . D . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_401 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L . D . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_402 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L . D . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_403 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_404 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_405 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . L L L . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_406 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_407 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_408 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . L L L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_409 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . L D . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_410 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . L D . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_411 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . L D . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_412 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 1));
    }

    private static inline void test_complete_reversi_game_413 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_414 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . L . D . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_415 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_416 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . L . D . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_417 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_418 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D D . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_419 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L D . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_420 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D D . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_421 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_422 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D D . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_423 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_424 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_425 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_426 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_427 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_428 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_429 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_430 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_431 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . D L . . . .",
                           /* 6 */ " . . . . L . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_432 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . D D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_433 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . L L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_434 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L D L . . .",
                           /* 5 */ " . . D D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_435 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_436 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_437 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . L . . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_438 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_439 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_440 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . D . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_441 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . L L L L . . .",
                           /* 5 */ " . D . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_442 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . D . D L . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
    }

    private static inline void test_complete_reversi_game_443 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . D . D L . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_444 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . D . D D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_445 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . D . L D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_446 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . D . D D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 2));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_447 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . D . L D . . .",
                           /* 4 */ " . . D L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_448 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . D . D D . . .",
                           /* 4 */ " . L L L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
    }

    private static inline void test_complete_reversi_game_449 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . . D . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_450 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_451 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
    }

    private static inline void test_complete_reversi_game_452 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L L L L .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 7));
    }

    private static inline void test_complete_reversi_game_453 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_454 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
    }

    private static inline void test_complete_reversi_game_455 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D D L . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_456 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L L L . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . . D D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_457 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . . L D . . .",
                           /* 6 */ " . . . L . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_458 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L L L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_459 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_460 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L D . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_461 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . L . . .",
                           /* 3 */ " . . D D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_462 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . D D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . . L . . . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_463 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . . . . .",
                           /* 3 */ " . . L D D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . . D . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_464 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . L D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 1));
    }

    private static inline void test_complete_reversi_game_465 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . L D D . . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_466 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D D . . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 6));
    }

    private static inline void test_complete_reversi_game_467 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D . . .",
                           /* 5 */ " . . L . . D . .",
                           /* 6 */ " . L . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_468 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D D L . .",
                           /* 5 */ " . . D . . . L .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_469 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L D . .",
                           /* 5 */ " . . D . L . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_470 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . L D D D . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_471 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D D D . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_472 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L D D . .",
                           /* 5 */ " . . L . . . . .",
                           /* 6 */ " . L . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_473 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L . L .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_474 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . L .",
                           /* 3 */ " . . . D D L . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_475 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_476 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . L . . .",
                           /* 3 */ " . . . L D D . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
    }

    private static inline void test_complete_reversi_game_477 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L L L .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
    }

    private static inline void test_complete_reversi_game_478 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L D . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 7));
    }

    private static inline void test_complete_reversi_game_479 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . L . L D . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_480 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . L D . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
    }

    private static inline void test_complete_reversi_game_481 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
    }

    private static inline void test_complete_reversi_game_482 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . L L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_483 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . L . D . . .",
                           /* 3 */ " . . . L L . . .",
                           /* 4 */ " . . . D L . . .",
                           /* 5 */ " . . D . . . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 7));
    }

    private static inline void test_complete_reversi_game_484 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . D . .",
                           /* 2 */ " . . . . D . . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . . L L . . .",
                           /* 5 */ " . . L . . . . .",
                           /* 6 */ " . L . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 2, 4));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 3));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 5));
    }

    private static inline void test_complete_reversi_game_485 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_486 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_487 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 0));
    }

    private static inline void test_complete_reversi_game_488 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . D . . D . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_489 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . L . . D . .",
                           /* 6 */ " . . L . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
    }

    private static inline void test_complete_reversi_game_490 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . L . . D . .",
                           /* 6 */ " . L . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 4, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 2, 0));
    }

    private static inline void test_complete_reversi_game_491 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . D . L . . .",
                           /* 6 */ " . . . . . L . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 6, 6));
    }

    private static inline void test_complete_reversi_game_492 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . . . .",
                           /* 3 */ " . . . D D . . .",
                           /* 4 */ " . . L L L L . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_493 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . . L . .",
                           /* 3 */ " . . . D L . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 6, 1));
    }

    private static inline void test_complete_reversi_game_494 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . . L . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 6, 0));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 2));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 0, 1));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 0, 7));
    }

    private static inline void test_complete_reversi_game_495 ()
    {
                                  /* 0 1 2 3 4 5 6 7 */
        string [] board = {/* 0 */ " . . . . . . . .",
                           /* 1 */ " . . . . . . . .",
                           /* 2 */ " . . . L . . . .",
                           /* 3 */ " . . . L D . . .",
                           /* 4 */ " . . L L D . . .",
                           /* 5 */ " . . D . D . . .",
                           /* 6 */ " . . . . . . . .",
                           /* 7 */ " . . . . . . . ."};

        Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
        ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);

        assert_true (ai_move (ai, 2, 1));
        assert_true (ai_move (ai, 2, 6));
        assert_true (ai_move (ai, 2, 2));
        assert_true (ai_move (ai, 5, 6));
        assert_true (ai_move (ai, 4, 6));
        assert_true (ai_move (ai, 5, 2));
        assert_true (ai_move (ai, 5, 4));
        assert_true (ai_move (ai, 4, 2));
        assert_true (ai_move (ai, 6, 2));
        assert_true (ai_move (ai, 3, 1));
        assert_true (ai_move (ai, 2, 0));
        assert_true (ai_move (ai, 1, 2));
        assert_true (ai_move (ai, 1, 3));
        assert_true (ai_move (ai, 1, 4));
        assert_true (ai_move (ai, 0, 2));
        assert_true (ai_move (ai, 4, 0));
        assert_true (ai_move (ai, 2, 3));
        assert_true (ai_move (ai, 5, 1));
        assert_true (ai_move (ai, 5, 3));
        assert_true (ai_move (ai, 7, 2));
        assert_true (ai_move (ai, 5, 0));
        assert_true (ai_move (ai, 3, 0));
        assert_true (ai_move (ai, 4, 1));
        assert_true (ai_move (ai, 6, 3));
        assert_true (ai_move (ai, 6, 4));
        assert_true (ai_move (ai, 0, 3));
        assert_true (ai_move (ai, 2, 7));
        assert_true (ai_move (ai, 0, 1));
        assert_true (ai_move (ai, 0, 5));
        assert_true (ai_move (ai, 1, 5));
        assert_true (ai_move (ai, 7, 3));
        assert_true (ai_move (ai, 3, 5));
        assert_true (ai_move (ai, 7, 1));
        assert_true (ai_move (ai, 5, 7));
        assert_true (ai_move (ai, 4, 7));
        assert_true (ai_move (ai, 5, 5));
        assert_true (ai_move (ai, 6, 5));
        assert_true (ai_move (ai, 3, 7));
        assert_true (ai_move (ai, 6, 7));
        assert_true (ai_move (ai, 3, 6));
        assert_true (ai_move (ai, 6, 1));
        assert_true (ai_move (ai, 7, 4));
        assert_true (ai_move (ai, 7, 5));
        assert_true (ai_move (ai, 1, 1));
        assert_true (ai_move (ai, 0, 4));
        assert_true (ai_move (ai, 0, 6));
        assert_true (ai_move (ai, 1, 6));
        assert_true (ai_move (ai, 1, 0));
        assert_true (ai_move (ai, 0, 0));
        assert_true (ai_move (ai, 0, 7));
        assert_true (ai_move (ai, 1, 7));
        assert_true (ai_move (ai, 7, 7));
        assert_true (game.pass ());
        assert_true (ai_move (ai, 7, 6));
        assert_true (ai_move (ai, 6, 6));
        assert_true (ai_move (ai, 7, 0));
        assert_true (ai_move (ai, 6, 0));
    }
}
