00001 --  COMMENT awit.alw or awit.alg -- version of Awit.1986.alg for AW2C ;
00002 --  
00003 --  @NOCHECK
00004 --  @DEBUG,0
00005 --  COMMENT
00006 --          Copyright 1978, T.A. Marsland (version up to AP9.5 awit.1986.alg)
00007 --          Copyright 2009, T.A. Marsland (version 09-MH1.5 onward)
00008 --          Computing Science, University of Alberta, Edmonton, Canada.
00009 --          This version of the chess program Awit (alias WITA)
00010 --          has been under development since 1971.
00011 --          It is made available for reference purposes only,
00012 --          and is not to be reproduced or redistributed
00013 --          without the permission of the author.
00014 --   ;
00015 --  COMMENT
00016 --  $R *SORT PAR=SORT=CH:A:1:8 INPUT=AWIT.DIR:F:100:100 OUTPUT=*PRINT*
00017 --   ;
00018 --  
00019 --  COMMENT                 MTS dependent interface PROCEDURE MMTTS
00020 --         SUBROUTINE DEPEND(IND, HIST)
00021 --         INTEGER IND, INDEX, HIST(35)
00022 --         INTEGER*2 LENGTH/140/, DUMMY
00023 --         INDEX = IABS(IND*1000)
00024 --         IF (IND .GT. 0) CALL WRITE(HIST, LENGTH, 16386, INDEX, 8)
00025 --         IF (IND .LT. 0) CALL READ (HIST, DUMMY, 16386, INDEX, 8)
00026 --         IF(IND.NE.0 .AND. IND.GT.-9000) RETURN
00027 --         CALL CUINFO('ECHOOFF ', 1)
00028 --         IF(IND .EQ. -9999)
00029 --       * CALL MTSCMD('$RES 9=WITA:GAMES(LAST+10)@TRIM ',32)
00030 --         IF (IND .GT. -10000) GO TO 15
00031 --         INDEX = MOD(IABS(IND),10)
00032 --         CALL CLOSFL(INDEX)
00033 --         CALL UNLK(INDEX)
00034 --  15     IF (IND .NE. 0) GO TO 20
00035 --         CALL MTSCMD('$RES 3=WITA:CHESS.TABLE ', 24)
00036 --         CALL MTSCMD('$RES SCARDS=*SOURCE*@UC ', 24)
00037 --         CALL GUINFO('SIGNONID', HIST(35))
00038 --  C           Check to see if unit 8 is assigned.
00039 --         CALL GDINF(8, HIST(23), &30)
00040 --  C           Yes it is, make sure it exists.
00041 --         CALL WRITE(HIST, 0, 2, -99999999, 8)
00042 --  C           MTS will prompt for valid file name.
00043 --         GO TO 25
00044 --  30     CALL MTSCMD('$RES 8=-CHESS#(LAST) ', 21)
00045 --  25     CALL GDINF(2, HIST(23),&10)
00046 --  C            Unit 2 is already attached.
00047 --         GO TO 20
00048 --  10     CALL MTSCMD('$RES 2=WITA:BOOK@UC ', 20)
00049 --  20     CALL CUINFO('ECHOOFF ', 0)
00050 --         RETURN
00051 --         END
00052 --  C			PROCEDURE TRANSFER
00053 --         SUBROUTINE TRANSF(B, L, M, N, U, RW)
00054 --         INTEGER B(64), L, M, N, U, RW
00055 --         INTEGER LL
00056 --         INTEGER*2 HALF(2)
00057 --         EQUIVALENCE (HALF,LL)
00058 --         LL = L
00059 --         HALF(1) = 0
00060 --         IF (RW .GT. 0) CALL WRITE(B, HALF(2), M, N, U)
00061 --         IF (RW .LT. 0) CALL READ (B, HALF(2), M, N, U, &10)
00062 --  C         MTS version 4 returns a length of zero upon EOF read     C
00063 --         IF (RW .EQ. 0) CALL GETLST(U, N, &15)
00064 --  20     L = LL
00065 --         RETURN
00066 --  15     N = 0
00067 --  10     LL = -1
00068 --         GO TO 20
00069 --         END
00070 --   ;
00071 --  @TITLE, "Awit-WITA CHESS PROGRAM"
00072 --  
00073 1-  BEGIN
00074 --    COMMENT Dummy MTS procedures ;
00075 --    PROCEDURE GET (INTEGER VALUE UNIT) ;
00076 --         FORTRAN "get" ;
00077 --    PROCEDURE PUT (INTEGER VALUE UNIT) ;
00078 --         FORTRAN "put" ;
00079 --  
00080 --    COMMENT a tracing procedure is entered if the first symbol typed
00081 --            is "?".  Different actions are taken depending on the characters
00082 --            which follow.  Explicitly mention squares, e.g., piece/squarefrom
00083 --            * piece/squareto. The command STOP terminates the program ;
00084 --    COMMENT *****************declarations************** ;
00085 --    INTEGER MAXTREE, MAXCHAR, MAXLEV, LIM, BAD, TOTAL, TSIZE, WSIZE,
00086 --            WIDTH, ELIMIT, RLIMIT, ZEROTIME, CONLIM, HOLE, MAXPLY, W_LIM,
00087 --            BRAN, MAX_PLIES, UPPER, T_SIZE, HALFP, GOODCASTLE, WEAKPIN,
00088 --            T_NUMB, TIME_LEFT, MOVES_LEFT, SECONDARY_MOVES, DIR, DISCHECK,
00089 --            M4, PREDICT, DRAW, PAWNVALUE, THRESHOLD, EPSILON, NOSCR, TWOCHECK,
00090 --            NOD, DUP, REC, SAL, BASE, DYN, TOT, ROOK, KNIGHT, BISHOP,
00091 --            QUEEN, KING, PAWN, ENPRIS, RANK, FILE, LDIAG, RDIAG, QSIDE,
00092 --            KSIDE, KLIST, ENDPLAY, PROMOTE, EMPTY, PFTWO, DELTA, NIL, KTEST,
00093 --            CAP, RTMV, P_NUMB, BACKROW, MOVE, CLIST, K, NUM, ONUM, CNUM,
00094 --            SLIST, INDEX, OCON, CCON, NUMB, PROMCAPT, MOVECOUNT, CAPT_T,
00095 --            CHARCOUNT, FILL, KINGVAL, INITIALCNT, N, WITA, CHECKING, NINES,
00096 --            EIGHTS, SEVENS, SIXES, FIVES, TWOROWS, M1, M2, M3, M5, M6,
00097 --            M7, M8, M9, M10, M11, M12, M14, KSQ, MAXPIECE, MINPIECE, LOSSES,
00098 --            E_Depth, SENDTIME, CPU, OLDCPU, ELAPSEDTIME, COMPUTERTIME, USERTIME,
00099 --            USER, S_SIZE, CHECKSQ, DATUM, COUNT, DIFFVAL, REALVAL, ONEVAL,
00100 --            TWOVAL, MOVETIME, AGITATE, SCALE, PVAL, BRDWIDTH, EDGE, WQRSQ,
00101 --            BKRSQ, POINT, SKTEST, CTIME, HASH, BOOK, BOOKMOVE, PONENT,
00102 --            P, REALCHECK, LENGTH, LEVEL, SECONDARY_TIME, MAXNODES, PLEX,
00103 --            REPLY, ORIGIN, LASTORIGIN, MAXL, SAVEL, PATH, OLDSCR, PREVSCR,
00104 --            ASCORE, DSCORE, PP_STATUS, TTYOUT, NEW, LIMBS, PSCORE, BRAN_S,
00105 --            REC_S, DUP_S, TOT_S, MODE, PART, A_SCR, MAX_WID, CAPT_WID,
00106 --            OLD_DIR, OLD_DEST, LSAVE, ESAVE, KNIGHTVALUE, NBP, w_size,
00107 --            DEPTH_LIMIT, WIDTH_LIMIT, packer, new_count, old_count, vars_depth ;
00108 --    LOGICAL REVERSIBLE, PPIN, ENDGAME, OPENING, LOG1, LOG2, MONITOR,
00109 --            MON, FLAGS, CASTLING, KINGUSED, FORCEDREPLY, PRUNE, DUMMY3,
00110 --            ECHO, NEWGAME, EXAMINE, REMEMBER, LEGAL, EARLY, WHO, BOTH,
00111 --            DEBUG, QUICK, TERMINAL, GARDE, TEST, NULLMOVE, DUMPP, CBOTH,
00112 --            WS, LOOKAHEAD, TOURNAMENT, MAKEMV, SCORES, INCHECK, DBLCHECK,
00113 --            PINNED, ENGLISH, COKO, GIVINGCH, MATE, DOUBLECH,
00114 --            STALEM, CAPTURE_TREE, LATE_END, ALTERNATIVE, INERR, IND_ATTA,
00115 --            PAB, THINKING, DUMMY4, default, dummy5, dummy6, warning ;
00116 --  
00117 --  COMMENT   in order to emphasize the three levels of this chess
00118 --            program, the arrays that are associated with each level have been
00119 --            separated.  The three levels are :: - conversational, occuring
00120 --            whenever the user can input data - position generation, whenever
00121 --            a new node of the search tree is created - and move scoring, in
00122 --            which many moves from a fixed position (node) are studied. ;
00123 --  
00124 --  COMMENT *****************conversational*************: ;
00125 --  
00126 --    STRING (12) DATE, SKILL ;
00127 --    STRING (4) USERID ;
00128 --    STRING (3) BLANK ;
00129 --    STRING (1) SPACE ;
00130 --    STRING (5) ARRAY COLOR (-1::1) ;
00131 --    STRING (1) ARRAY CHESSMAN (0::11) ;
00132 --    STRING (1) ARRAY CHESSPIECE (0::8) ;
00133 --    STRING (1) ARRAY U (0::120) ;
00134 --  COMMENT string (1) array u (0::maxchar) ;
00135 --    STRING (140) BUFFER, HISTORY ;
00136 --    STRING (80) INPUT, OUTPUT ;
00137 --    STRING (3) ARRAY MAN (-8::8) ;
00138 --    STRING (1) ARRAY MC (0::23) ;
00139 --    STRING (1) ARRAY DIGIT (0::9) ;
00140 --    STRING (8) ARRAY REASON (-7::5) ;
00141 --    STRING (34) MESSAGE1, PREV_MESSAGE1 ;
00142 --    STRING (9) MESSAGE2, PREV_MESSAGE2 ;
00143 --    INTEGER ARRAY FSQ, TSQ (0::1) ;
00144 --    INTEGER ARRAY REW, FMAN, TMAN (0::2) ;
00145 --    INTEGER ARRAY NUMBER, SPAN, KINGSQ (-1::1) ;
00146 --  
00147 --  COMMENT *****************positional******************** ;
00148 --  
00149 --    INTEGER ARRAY S (0::8) ;
00150 --  COMMENT integer array try (0::wsize) ;
00151 --    COMMENT rlimit >= wsize ;
00152 --    INTEGER ARRAY TRY (0::27) ;
00153 --    INTEGER ARRAY VALUES (0::12) ;
00154 --    INTEGER ARRAY RLIST, TLIST (0::15) ;
00155 --  COMMENT integer array rlist, tlist (0::rlimit) ;
00156 --    INTEGER ARRAY ATTASQRS (0::10) ;
00157 --    INTEGER ARRAY POWER (-1::10) ;
00158 --    INTEGER ARRAY SQR (-5::10) ;
00159 --    INTEGER ARRAY PRIMES (-14::14) ;
00160 --    INTEGER ARRAY RANKS, PAWNVAL (1::8) ;
00161 --    INTEGER ARRAY REPEATS (0::100) ;
00162 --    INTEGER ARRAY TWO, THREE, K_SQRS, FILES, QRSQ, KRSQ (-1::1) ;
00163 --    INTEGER ARRAY CHECKS, PAWNS (11::88) ;
00164 --    INTEGER ARRAY COLS, ROWS (0::99) ;
00165 --    INTEGER ARRAY KSQRS, PIECES (-8::8) ;
00166 --    INTEGER ARRAY CHECKLIST, OLDLIST (0::29) ;
00167 --  COMMENT integer array checklist, oldlist (0::lim) ;
00168 --    INTEGER ARRAY MOVEFROM, MOVETO, SCORE, REWARD (-80::80) ;
00169 --  COMMENT integer array movefrom, moveto, score, reward (-total::total) ;
00170 --  COMMENT integer array merit (-total::total) ;
00171 --    INTEGER ARRAY POSITION (11::88, 0::29) ;
00172 --  COMMENT integer array position (11::88, 0::lim) ;
00173 --    INTEGER ARRAY POS (11::88) ;
00174 --    INTEGER ARRAY CONTROL (-11::109, -8::8) ;
00175 --  COMMENT integer array control (11::88, -conlim::conlim) ;
00176 --    INTEGER ARRAY CON (-1::1, -11::109) ;
00177 --    INTEGER ARRAY BRD (-11::109) ;
00178 --  COMMENT integer array brd (hole::109) ;
00179 --    INTEGER ARRAY SQUARE, LOSS (0::31) ;
00180 --  COMMENT integer array square, loss (0::elimit) ;
00181 --    LOGICAL ARRAY CASTLE (-3::3) ;
00182 --    INTEGER ARRAY NEAR, FAR (0::7, 0::7) ;
00183 --    INTEGER ARRAY CLEARPAWN(-1::1) ;
00184 --    STRING (6) KBUFF ;
00185 --    STRING (2) KEY ;
00186 --    INTEGER ARRAY FLAG(1::1) ;
00187 --    STRING(1) BELL ;
00188 --    STRING(2) ARRAY BOX(-11::109) ;
00189 --    INTEGER ARRAY OFFSET(-10::109) ;
00190 --    INTEGER ARRAY BOTV(1::8, -112::112) ;
00191 --    INTEGER ARRAY MATE_P, MATE_T(-1::1) ;
00192 --    INTEGER ARRAY MEN(-1::1) ;
00193 --    LOGICAL ARRAY OPEN(-1::1) ;
00194 --  COMMENT This first attempt at a chess playing program is very
00195 --          unsophisticated.  Its level of play is that of advanced beginner.
00196 --          It was the aim of this program to play reasonable middle game chess.
00197 --          At any stage in the game the seven best moves are selected on a
00198 --          basis of mobility, modified by material gain and checking threats.
00199 --          For each of these moves the attacking and defensive potential is
00200 --          computed and the overall score modified again. Move with highest
00201 --          score is selected. The basic book of opening moves are the Najdorf,
00202 --          Gruenfeld and Two Knights Defence. Another book (from K. Thompson)
00203 --          was incorporated during the summer of 1974, since the scheme to
00204 --          inhibit early queen moves was no longer adequate.  There is no special
00205 --          section on endgames. Such additions would certainly be advantageous.
00206 --          Until the incorporation of chess features and determination of their
00207 --          relative merit is complete, it is not thought to be wise to construct
00208 --          trees greater than the current default of 100 positions.  It is
00209 --          claimed that by constructing a program which plays as well as possible
00210 --          using a small tree, one can ensure that a minimal number of irrelevant
00211 --          branches will be searched in any larger tree. ;
00212 --  
00213 --    INTEGER ARRAY A_VAL(0::12) ;
00214 --  COMMENT integer array store (-4*(2*total+1)::4*(2*total+1)) ;
00215 --    INTEGER ARRAY STORE (-644::644) ;
00216 --    INTEGER ARRAY M_TIMES(0::10) ;
00217 --    INTEGER ARRAY FKS(11::88) ;
00218 --    INTEGER ARRAY BACK_ROW(-1::1, 1::8) ;
00219 --    INTEGER ARRAY CH_ATTA(-11::109) ;
00220 --    LOGICAL ARRAY CAPTURE_CH(-11::109) ;
00221 --    INTEGER ARRAY CHECK_S(-1::1, -11::109) ;
00222 --    INTEGER ARRAY FORKS(-1::1, 11::88) ;
00223 --    INTEGER ARRAY DOUBLE_KNIGHT(0::49) ;
00224 --  comment
00225 --    INTEGER ARRAY VARS(1::vars_depth, 1::vars_depth) ;
00226 --    INTEGER ARRAY VARS(1::15, 1::15) ;
00227 --  comment    raising VARS limit to 15 on 12 April 2009 ;
00228 --    INTEGER ARRAY USE(0::80) ;
00229 --  COMMENT integer array use(0::total) ;
00230 --    LOGICAL ARRAY CHEC(0::5, 0::11) ;
00231 --    INTEGER ARRAY SECRET(11::88, -8::8) ;
00232 --    INTEGER ARRAY SEC(-1::1, 11::88) ;
00233 --    LOGICAL ARRAY KING_HELD(-1::1) ;
00234 --    INTEGER ARRAY DECOYS (-11::109) ;
00235 --  
00236 --    LOGICAL ARRAY QUIES(-80::80) ;
00237 --    STRING (4) ARRAY NEGA(0::100) ;
00238 --  
00239 --    PROCEDURE INITIALIZE ;
00240 2-    BEGIN
00241 --      MMTTS(0, HISTORY) ;
00242 --      USERID := HISTORY(136|4) ;
00243 --      COLOR(-1) := "BLACK" ;
00244 --      COLOR(0) := "WHOSE" ;
00245 --      COLOR(1) := "WHITE" ;
00246 --      BELL := CODE(47) ;
00247 --                    COMMENT bell char. is EBCDIC hex 2F ;
00248 --      P := 99999971 ;
00249 --      HALFP := (P-1) DIV 2 ;
00250 --      ROOK := 5 ;
00251 --      KNIGHT := 3 ;
00252 --      BISHOP := 4 ;
00253 --      QUEEN := 7 ;
00254 --      KING := 8 ;
00255 --      PAWN := 1 ;
00256 --      ENPRIS := 11 ;
00257 --      RANK := 1 ;
00258 --      FILE := 10 ;
00259 --      LDIAG := 9 ;
00260 --      RDIAG := 11 ;
00261 --      QSIDE := 9 ;
00262 --      KSIDE := 10 ;
00263 --      BRDWIDTH := 10 ;
00264 --      QRSQ(-1) := 81 ;
00265 --      QRSQ(1) := WQRSQ := 11 ;
00266 --      KRSQ(1) := 18 ;
00267 --      KRSQ(-1) := BKRSQ := 88 ;
00268 --      EDGE := 6 ;
00269 --      PFTWO := 12 ;
00270 --      EMPTY := NIL := 0 ;
00271 --      PROMOTE := 10 ;
00272 --      BLANK := "   " ;
00273 --      SPACE := " " ;
00274 --      CHECKING := 20 ;
00275 --      REALCHECK := 2*CHECKING ;
00276 --      DISCHECK := 3*CHECKING ;
00277 --      TWOCHECK := 4*CHECKING ;
00278 --      NINES := 88888 ;
00279 --      EIGHTS := 99999 ;
00280 --      SEVENS := 77777 ;
00281 --      SIXES := 66666 ;
00282 --      FIVES := 55555 ;
00283 --      TWOROWS := 2*FILE ;
00284 --      DATUM := 500 ;
00285 --      SCALE := 150 ;
00286 --      PVAL := 6 ;
00287 --      PAWNVALUE := PVAL*SCALE ;
00288 --      KNIGHTVALUE := 3*PAWNVALUE ;
00289 --      THRESHOLD := PAWNVALUE DIV 3 ;
00290 --      EPSILON := THRESHOLD DIV 3 ;
00291 --      DRAW := + 4*SCALE ;
00292 --                           COMMENT 1/2 PAWN ;
00293 --      FOR I := 0 UNTIL 23
00294 --      DO MC(I) := SPACE ;
00295 --                           COMMENT the values of the pieces are given below ;
00296 --      FOR K := -1,1
00297 3-      DO BEGIN
00298 --        TWO(K) := 2*K ;
00299 --        THREE(K) := 3*K ;
00300 --        K_SQRS(K) := 0 ;
00301 --        FILES(K) := FILE*K ;
00302 -3      END ;
00303 --      FOR FILL := 1 UNTIL 8
00304 --      DO RANKS(FILL) := CASE FILL OF (-1, -1, -1, -1, 1, 1, 1, 1) ;
00305 --      FOR FILL := 1 UNTIL 9
00306 --      DO S(FILL-1) := CASE FILL OF (0, 12, 19, -12, -19, 21, 8, -21, -8) ;
00307 --      FOR FILL := 1 UNTIL 10
00308 --      DO DIGIT (FILL-1) := CASE FILL OF ("0", "1", "2", "3", "4",
00309 --        "5", "6", "7", "8", "9") ;
00310 --      FOR FILL := -KING UNTIL KING
00311 --      DO MAN(FILL) := CASE (FILL + 1 + KING) OF (" Kb", " Qb",
00312 --        "   ", " Rb", " Bb", " Nb", "   ", " Pb", "   ", " Pw",
00313 --        "   ", " Nw", " Bw", " Rw", "###"," QW"," KW") ;
00314 --      FOR FILL := 1 UNTIL 13
00315 --      DO A_VAL(FILL-1) := CASE FILL OF (0, PVAL, 0, 18, 20, 25,
00316 --        0, 30, PVAL, 5, DATUM, 4, SCALE) ;
00317 --      FOR FILL := 1 UNTIL 13
00318 --      DO VALUES(FILL-1) := CASE FILL OF (0, PVAL, 0, 18, 20, 30,
00319 --        0, 57, 60, 5, DATUM, 4, SCALE) ;
00320 --      FOR FILL := 1 UNTIL 12
00321 --      DO CHESSMAN (FILL-1) := CASE FILL OF (" ", "P", "#", "N",
00322 --        "B", "R", "@", "Q", "K", "@", " ", "*") ;
00323 --      FOR FILL := 1 UNTIL 9
00324 --      DO CHESSPIECE(FILL-1) := CASE FILL OF (" ", "R", "N", "B",
00325 --        "Q", "K", "B", "N", "R") ;
00326 --      FOR FILL := 1 UNTIL 13
00327 --      DO REASON(FILL-8) := CASE FILL OF ("NODES   ", "DEPTH   ",
00328 --        "BETTER  ", "ANTICIP ", "NO PROS ", "GREAT   ",
00329 --        "REVERSE ", "LIMIT   ", "RESIGN  ", "STALE M.",
00330 --        " DRAW   ", " MATE   ", "KING CAP") ;
00331 --    COMMENT  King and passed pawn opposition table.
00332 --  
00333 --            FAR  (ENDGAME)            NEAR  (~ENDGAME)
00334 --  
00335 --       7 -  5  4  3  2  1  0  0  0    0 0 0 0 0 0 0 0
00336 --       6 -  7  6  5  4  3  2  1  0    0 0 0 0 0 0 0 0
00337 --       5 -  9  8  7  6  5  4  2  0    0 0 0 0 0 0 0 0
00338 --       4 - 11 10  9  8  7  5  3  1    2 1 0 0 0 0 0 0
00339 --       3 - 13 12 11 10  8  6  4  2    4 3 2 0 0 0 0 0
00340 --       2 - 15 14 13 11  9  7  5  3    6 5 4 2 0 0 0 0
00341 --       1 - 17 16 14 12 10  8  6  4    8 7 5 3 1 0 0 0
00342 --       0 - 19 17 15 13 11  9  7  5   10 8 6 4 2 0 0 0
00343 --  
00344 --            0  1  2  3  4  5  6  7
00345 --    ;
00346 --      FOR FILL := 1 UNTIL 8
00347 3-      DO BEGIN
00348 --        PAWNVAL(FILL) := CASE FILL OF (4, 4, 2, 1, 1, 2, 4, 4) ;
00349 --        BACK_ROW(-1,FILL) := 80 + FILL ;
00350 --        BACK_ROW(1,FILL) := 10 + FILL ;
00351 -3      END ;
00352 --      FOR I := 0 UNTIL 9
00353 --      DO FOR J := 0 UNTIL 9
00354 3-         DO BEGIN
00355 --           FILL := BRDWIDTH * I + J ;
00356 --           ROWS(FILL) := I ;
00357 --           COLS(FILL) := J ;
00358 -3      END ;
00359 --      COMMENT Pawn location and control table
00360 --          especially for pawns on 7th and in centre
00361 --  
00362 --        RANKS    PAWNS                            ROWS PAWNVAL
00363 --  
00364 --         PAWN    0   0   0   0   0   0   0   0     8        8
00365 --         PAWN    1   1   1   1   1   1   1   1     7    4   7
00366 --         PAWN    2   4   6   6   6   6   4   2     6    2   6
00367 --         PAWN    2   4   6   8   8   6   4   2     5    1   5
00368 --        -PAWN    2   4   6   8   8   6   4   2     4    1   5
00369 --        -PAWN    2   4   6   6   6   6   4   2     3    2   6
00370 --        -PAWN   -1  -1  -1  -1  -1  -1  -1  -1     2    4   7
00371 --        -PAWN    0   0   0   0   0   0   0   0     1        8
00372 --  
00373 --         COLS    a   b   c   d   e   f   g   h
00374 --      ;
00375 --      GET(3) ;
00376 --      IOCONTROL(1) ;
00377 --      readcard(BUFFER) ;
00378 --      comment writecard(BUFFER) ;
00379 --      FOR I := -10 UNTIL 109
00380 --      DO READON(OFFSET(I)) ;
00381 --      FOR K := 3 UNTIL 8
00382 3-      DO BEGIN
00383 --        IOCONTROL(1) ;
00384 --      readcard(BUFFER) ;
00385 --      comment writecard(BUFFER) ;
00386 --        FOR I := -112 UNTIL 112
00387 --        DO READON(BOTV(K, I)) ;
00388 -3      END ;
00389 --      IOCONTROL(1) ;
00390 --      readcard(BUFFER) ;
00391 --      comment writecard(BUFFER) ;
00392 --      FOR I := 0 UNTIL 7
00393 --      DO FOR J := 0 UNTIL 7
00394 --      DO READON(FAR(I,J)) ;
00395 --      IOCONTROL(1) ;
00396 --      readcard(BUFFER) ;
00397 --      comment writecard(BUFFER) ;
00398 --      FOR I := 0 UNTIL 7
00399 --      DO FOR J := 0 UNTIL 7
00400 --      DO READON(NEAR(I,J)) ;
00401 --      IOCONTROL(1) ;
00402 --      readcard(BUFFER) ;
00403 --      comment writecard(BUFFER) ;
00404 --      FOR I := 11 UNTIL 88
00405 --      DO READON(PAWNS(I)) ;
00406 --      FOR K := 1,2
00407 3-      DO BEGIN
00408 --        IOCONTROL(1) ;
00409 --      readcard(BUFFER) ;
00410 --      comment writecard(BUFFER) ;
00411 --        FOR I := -112 UNTIL 112
00412 --        DO READON(BOTV(K,I)) ;
00413 -3      END ;
00414 --      for i := 89 until 109 do
00415 --        BOX(i) := BOX(i-100) := "##" ;
00416 --      IOCONTROL(1) ;
00417 --      readcard(BUFFER) ;
00418 --      comment writecard(BUFFER) ;
00419 --      FOR I := 10 UNTIL 88
00420 --      DO READON(BOX(I)) ;
00421 --      IOCONTROL(1) ;
00422 --      readcard(BUFFER) ;
00423 --      comment writecard(BUFFER) ;
00424 --      FOR I := 0 UNTIL 49
00425 --      DO READON(DOUBLE_KNIGHT(I)) ;
00426 --      for i := 1 until 15 do
00427 --        for j := 1 until 15 do
00428 --          vars(i,j) := 1 ;
00429 --      comment 12 April 09 increase to VARS array, endabling 13-ply search depth ;
00430 --      IOCONTROL(1) ;
00431 --      readcard(BUFFER) ;
00432 --      comment writecard(BUFFER) ;
00433 --      FOR I := 1 UNTIL 10
00434 3-      DO BEGIN
00435 --        FOR J := 1 UNTIL 10
00436 --        DO READON(VARS(I,J)) ;
00437 -3      END ;
00438 --      IOCONTROL(1) ;
00439 --      readcard(BUFFER) ;
00440 --      comment writecard(BUFFER) ;
00441 --      FOR I := 0 UNTIL 5
00442 --      DO FOR J := 0 UNTIL 11
00443 --      DO READON(CHEC(I,J)) ;
00444 --      GET(5) ;
00445 --      KINGVAL := VALUES(KING) ;
00446 --      MOVECOUNT := NUM := 0 ;
00447 --      BAD := - 66667 ;
00448 --      NOSCR := BAD + 1 ;
00449 --                         COMMENT DELTA := ABS(VALUES(BISHOP) - VALUES(KNIGHT)) + 1 ;
00450 --      DELTA := 3 ;
00451 --      ECHO := DUMPP := DEBUG := MONITOR := TEST := COKO := THINKING :=
00452 --        ENGLISH := CAPTURE_TREE := LOOKAHEAD := EXAMINE := FALSE ;
00453 --      WS := TRUE ;
00454 --      ORIGIN := -1 ;
00455 --      DATER(5, 0, DATE) ;
00456 --      WRITE(DATE) ;
00457 --      PAB := QUICK := TRUE ;
00458 --      TOURNAMENT := MAX_WID = w_size ;
00459 --      dummy4 := false ;
00460 --      dummy5 := false ;
00461 --      dummy6 := false ;
00462 --      warning := false ;
00463 --      WRITE("Awit, a chess program, ") ;
00464 --      WRITE("Enter ?8 for control options, STOP to terminate.") ;
00465 --      MMTTS(-10003, HISTORY) ;
00466 --      TRANSFER(HISTORY, NUM, 0, COUNT, 8, 0) ;
00467 --      COUNT := COUNT DIV 1000 ;
00468 --               COMMENT normally COUNT is 0, but initialized here
00469 --                       through indexed read on last record of history file ;
00470 --      FOR K := -1, 1
00471 --      DO FOR SQ := 11 UNTIL 88
00472 --      DO CHECK_S(K,SQ) := FORKS(K,SQ) := 0 ;
00473 -2    END OF_INITIALIZE ;
00474 --  
00475 --  PROCEDURE ALGEBRAIC (STRING(1) ARRAY G(*) ; INTEGER VALUE PTR) ;
00476 2-  BEGIN
00477 --    COMMENT Algebraic input routines developed for T.A.M. by E.  Culham,
00478 --            under NRC grant A7902, July 1977 ;
00479 --  
00480 --    INTEGER ROW, COL, TEMPPC, TCOL, OFFSET ;
00481 --    STRING(1) T ;
00482 --    LOGICAL PAWN_CAPT ;
00483 --  
00484 --    LOGICAL PROCEDURE GETOK (LOGICAL VALUE YOU_WANT_THE_ROW) ;
00485 3-    BEGIN
00486 --      LOGICAL RESLT ;
00487 --      RESLT := FALSE ;
00488 --      IF YOU_WANT_THE_ROW
00489 4-      THEN BEGIN
00490 --        IF (T >= "1") AND (T <= "8")
00491 5-        THEN BEGIN
00492 --          ROW := DECODE(T) - 240 ;
00493 --          RESLT := TRUE ;
00494 -5        END ;
00495 -4      END ELSE
00496 4-      BEGIN
00497 --        IF (T >= "A") AND (T <= "H")
00498 5-        THEN BEGIN
00499 --          COL := DECODE(T) - 192 ;
00500 --          RESLT := TRUE ;
00501 -5        END ;
00502 -4      END ;
00503 --      RESLT
00504 -3    END OF_GETOK ;
00505 --  
00506 --    LOGICAL PROCEDURE NEXT (STRING(1) RESULT T) ;
00507 3-    BEGIN
00508 --      LOGICAL RESLT ;
00509 --      PTR := PTR - 1 ;
00510 --      IF PTR < 0
00511 --      THEN RESLT := FALSE
00512 4-      ELSE BEGIN
00513 --        T := G(PTR) ;
00514 --        RESLT := TRUE ;
00515 -4      END ;
00516 --      RESLT
00517 -3    END OF_NEXT ;
00518 --  
00519 --    PROCEDURE GETPC ;
00520 3-    BEGIN
00521 --      FOR I := KNIGHT, BISHOP, ROOK, QUEEN, KING, PAWN
00522 --      DO IF T = CHESSMAN(I)
00523 4-         THEN BEGIN
00524 --           FMAN(2) := I ;
00525 --           IF NEXT(T)
00526 5-           THEN BEGIN
00527 --             MESSAGE1 := "TOO MUCH MOVE TO DECODE" ;
00528 --             GO TO ERROR ;
00529 -5           END ;
00530 --           GO TO EXIT_FROM_FORI ;
00531 -4      END FORI ;
00532 --  EXIT_FROM_FORI:
00533 -3    END OF_GETPC ;
00534 --  
00535 --  @TITLE, "ALGEBRAIC"
00536 --  
00537 --    TSQ(1) := FSQ(1) := -NINES ;
00538 --    IF NEXT(T)
00539 --    THEN IF G(0) ~= "?"
00540 3-         THEN BEGIN
00541 --                        COMMENT  strip off characters from the book ;
00542 --           IF T = "?" OR T = "!"
00543 --           THEN IF ~NEXT(T)
00544 --                THEN GO TO ERROR ;
00545 --  
00546 --                        COMMENT test for draw offer ;
00547 --           IF T = "W"
00548 4-           THEN BEGIN
00549 --             PTR := PTR - 2 ;
00550 --             IF NEXT(T) AND T = "D"
00551 5-             THEN begin
00552 --               IF (SCORE(RTMV) < + PAWNVALUE)
00553 6-               THEN BEGIN
00554 --                 WRITE("DRAW ACCEPTED") ;
00555 --                 comment tracer(2, "?SP") ;
00556 --                 GO TO STARTS ;
00557 -6               END ELSE MESSAGE1 := "DRAW NOT ACCEPTED AT THIS TIME" ;
00558 --               write("Draw was offered") ;
00559 -5             end ;
00560 --             IF ~NEXT(T)
00561 --             THEN GO TO ERROR ;
00562 -4           END ;
00563 --  
00564 --                  COMMENT test for a check ;
00565 --           while (T = "+") or (T = "-") or (T = "*")
00566 4-           do BEGIN
00567 --             REW(0) := REW(0) + CHECKING ;
00568 --             IF ~NEXT(T)
00569 --             THEN GO TO ERROR ;
00570 -4           END ;
00571 --  
00572 --                  COMMENT test for enpassant capture ;
00573 --           IF T = "P"
00574 4-           THEN BEGIN
00575 --             IF ~NEXT(T) OR T ~= "E" OR ~NEXT(T)
00576 --             THEN GO TO ERROR
00577 --             ELSE TMAN(2) := ENPRIS
00578 -4           END ELSE IF PTR >= 3
00579 4-                    THEN BEGIN
00580 --                               COMMENT test if it was a promotion ;
00581 --                      FOR J := KNIGHT, BISHOP, ROOK, QUEEN
00582 --                      DO IF T = CHESSMAN(J)
00583 --                         THEN IF ~NEXT(T) OR T ~= "=" OR ~NEXT(T)
00584 5-                              THEN BEGIN
00585 --                                MESSAGE1 := "ILLEGAL PROMOTION TYPE" ;
00586 --                                GO TO ERROR ;
00587 -5                      END ELSE
00588 5-                      BEGIN
00589 --                        REW(2) := J + PROMOTE ;
00590 --                        GO TO LEAVE_FOR_J ;
00591 -5                      END FORJ ;
00592 --  LEAVE_FOR_J:
00593 -4         END ;
00594 --  
00595 --         IF (T = "0") OR (T = "O")
00596 4-         THEN BEGIN
00597 --           WHILE NEXT(T)
00598 --           DO IF (T = "0") OR (T = "O")
00599 --              THEN REW(1) := REW(1) + 1 ;
00600 --           IF (REW(1) > 0) AND (REW(1) < 3)
00601 --           THEN REW(1) := IF (REW(1) = 2)
00602 --                          THEN QSIDE
00603 --                          ELSE KSIDE
00604 5-           ELSE BEGIN
00605 --             MESSAGE1 := "INVALID CASTLING" ;
00606 --             GO TO ERROR ;
00607 -5           END ;
00608 --           goto quit ;  comment found castling move ;
00609 -4         END ;
00610 --  
00611 --  comment TAM July 2009.  Code generalised to handle abreviated notation.
00612 --                Possible formats remaining for <move> are:
00613 --    <move> :== <to-sq> | <man><to-sq> | <man><from-sq><to-sq> | <man><col><to-sq>
00614 --                       | <man><row><to-sq>
00615 --    <to-sq> :== <oper><col><row>
00616 --    <oper> :== NIL | - | * | : | X
00617 --    <from-sq> :== <col><row>
00618 --    <col> :== 1 .. 8              mapped from A .. H
00619 --    <row> :== 1 .. 8
00620 --    <man> := P | R | N | B | Q | K | NIL
00621 --  ;
00622 --  
00623 --                COMMENT seek moves consistent with above BNF decription ;
00624 --         IF GETOK(TRUE)
00625 4-         THEN BEGIN
00626 --             comment found a <row>, seek consistent move ;
00627 --           IF NEXT(T) AND GETOK(FALSE)
00628 5-           THEN BEGIN
00629 --               comment found <col><row> part ;
00630 --             TSQ(0) := BRDWIDTH * ROW + COL ;
00631 --             TMAN(2) := ABS(BRD(TSQ(0))) ;
00632 --  
00633 --             IF ~NEXT(T)
00634 6-             THEN begin
00635 --                 comment do we have simple pawn move of the form  e4 ;
00636 --               FMAN(2) := PAWN ;
00637 --               fsq(0) := tsq(0) - k * brdwidth ;
00638 --               if k*brd(fsq(0)) ~= pawn
00639 --               then fsq(0) := fsq(0) - k * brdwidth ;
00640 --               if k*brd(fsq(0)) ~= pawn
00641 7-               then begin
00642 --                 message1 := "Not a simple Pawn move" ;
00643 --                 goto error ;
00644 -7               end ;
00645 --               goto quit ;  comment simple pawn move found ;
00646 -6             end
00647 6-             ELSE BEGIN
00648 --                  comment do we have a simple operator to skip over ;
00649 --               IF (T = "X") OR (T = ":") OR (T = "*") or (t = "-")
00650 --               THEN IF ~NEXT(T)
00651 7-                    THEN begin
00652 --                      message1 := "Misplaced operator ':*X-'" ;
00653 --                      GOTO ERROR ;
00654 -7                    end ;
00655 --                 comment now check if move is of form <man><to-sq> ;
00656 --               GETPC ;
00657 --               IF FMAN(2) = 0
00658 7-               THEN BEGIN
00659 --                   comment do we have a <col><to-sq> or <row><to-sq> ;
00660 --                 IF ~GETOK(true)
00661 --                 then if ~GETOK(false)
00662 --                      THEN GOTO ERROR
00663 8-                      else begin
00664 --                          comment looking for <man><col><to-sq> ;
00665 --                        if next(t)
00666 --                        then getpc
00667 --                        else fman(2) := pawn ;
00668 --                        if fman(2) = 0 then goto error ;
00669 --                        row := 0 ;
00670 --                        for r := 1 until 8 do
00671 --                          if fman(2) = k*brd(brdwidth*r + col)
00672 --                          then row := r ;
00673 --                        if row = 0 then goto error ;
00674 --                          comment have found the <row> ;
00675 --                        fsq(0) := brdwidth * row + col ;
00676 --                        goto quit ; comment found <man><row><to-sq> ;
00677 -8                      end ;
00678 --                 if next(t) then
00679 --                 IF GETOK(FALSE)
00680 8-                 THEN BEGIN
00681 --                       comment have found <from-sq> check the man ;
00682 --                     fsq(0) := brdwidth * row + col ;
00683 --                     fman(2) := abs(brd(fsq(0))) ;
00684 --                     if next(t)
00685 --                     then getpc           comment changes fman(2) ;
00686 --                     else fman(2) := abs(brd(fsq(0))) ;
00687 --                     if fman(2) ~= abs(brd(fsq(0)))
00688 9-                     then begin
00689 --                       message1 := "square does not contain that piece" ;
00690 --                       goto error ;
00691 -9                     end ;
00692 --                     goto quit ;    comment have found <from-sq><to-sq> ;
00693 -8                  END
00694 8-                  else begin
00695 --                      comment is move of form <man><col><to-sq> ;
00696 --                    getpc ;               comment sets fman(2) ;
00697 --                    if fman(2) = 0 then goto error ;
00698 --                    col := 0 ;
00699 --                    for c := 1 until 8 do
00700 --                      if fman(2) = k*brd(brdwidth*row+c)
00701 --                      then col := c ;
00702 --                    if col = 0 then goto error ;
00703 --                    fsq(0) := brdwidth * row + col ;
00704 --                    goto quit ;  comment have found <man><col><to-sq> ;
00705 -8                  end ;
00706 -7               end ;
00707 --               goto quit ;  comment found the form <man><to-sq> ;
00708 -6             end ;
00709 -5           end else goto error ;
00710 -4         END ELSE
00711 4-         begin
00712 --           if ~getok(false)
00713 --           then goto error ;
00714 --             COMMENT try for simple pawn capture
00715 --                         of the form <col><col> ;
00716 --            TCOL := COL ;
00717 --            IF NEXT(T) AND GETOK(FALSE)
00718 5-            THEN BEGIN
00719 --              OFFSET := TCOL - COL + 10 * K ;
00720 --              FMAN(2) := PAWN ;
00721 --              FOR I := BRDWIDTH + COL STEP 10 UNTIL BKRSQ
00722 --              DO IF BRD(I) = K*PAWN
00723 --                 THEN IF K*BRD(I+OFFSET) < 0
00724 6-                      THEN BEGIN
00725 --                        TSQ(0) := I + OFFSET ;
00726 --                        TMAN(2) := ABS(BRD(TSQ(0))) ;
00727 --                        FSQ(0) := I ;
00728 -6              END ;
00729 --              IF NEXT(T) AND T ~= "P" OR TSQ(0) = 0
00730 --              THEN GOTO ERROR ;
00731 --              goto quit ;  comment found simple pawn capture ;
00732 -5            END ;
00733 -4         end ;
00734 -3    END ;
00735 --  ERROR:
00736 --    NULLMOVE := TRUE ;
00737 --  QUIT:
00738 -2  END OF_ALGEBRAIC ;
00739 --  
00740 --  PROCEDURE DESCRIBEMOVE (INTEGER VALUE N ; STRING(1) ARRAY MC(*)) ;
00741 --  COMMENT internal move description is converted to chess notation ;
00742 2-  BEGIN
00743 --    INTEGER M, M2, M4, M44, M5, M6, M3, KK, I, J ;
00744 --    STRING(24) OUT ;
00745 --    STRING(4) ARRAY CHK(0::5) ;
00746 --  
00747 --    STRING(3) PROCEDURE CHESSBOARD (INTEGER VALUE SQ) ;
00748 3-    BEGIN
00749 --      INTEGER ROW, COL ;
00750 --      STRING(3) SQUARE ;
00751 --  
00752 --      ROW := ROWS(SQ) ;
00753 --      COL := COLS(SQ) ;
00754 --      SQUARE(0|1) := IF COL < 4
00755 --                     THEN "Q"
00756 --                     ELSE IF COL > 5
00757 --                          THEN "K"
00758 --                          ELSE SPACE ;
00759 --      SQUARE(1|1) := CHESSPIECE(COL) ;
00760 --      SQUARE(2|1) := IF KK > 0
00761 --                     THEN DIGIT(ROW)
00762 --                     ELSE DIGIT(9-ROW) ;
00763 --      SQUARE
00764 -3    END OF_CHESSBOARD ;
00765 --  
00766 --  @TITLE, "DESCRIBEMOVE"
00767 --  
00768 --    M2 := ABS (REWARD(N)) ;
00769 --    M := M2 DIV CHECKING ;
00770 --    M2 := M2 REM CHECKING ;
00771 --    IF (M2 = 2)
00772 --    THEN M2 := 0 ;
00773 --    CHK(0) := "    " ;
00774 --    CHK(5) := "MATE" ;
00775 --    CHK(2) := " CH." ;
00776 --    CHK(4) := " DBL" ;
00777 --    CHK(3) := " DIS" ;
00778 --    CHK(1) := " STA" ;
00779 --    J := 5 ;
00780 --    IF (N = 0)
00781 --    THEN M := 5
00782 --    ELSE IF (ENGLISH OR ~COKO) AND (M2 = KSIDE OR M2 = QSIDE)
00783 --         THEN OUT(0|5) := IF (M2 = QSIDE)
00784 --                          THEN "O-O-O"
00785 --                          ELSE "O-O  "
00786 3-    ELSE BEGIN
00787 --      M3 := MOVEFROM(N) ;
00788 --      M4 := BRD (M3) ;
00789 --      M5 := MOVETO(N) ;
00790 --      M6 := BRD(M5) ;
00791 --      IF (ABS(M6) = ENPRIS)
00792 --      THEN M6 := NIL ;
00793 --      IF M4 = 0
00794 4-      THEN BEGIN
00795 --        M4 := M6 ;
00796 --        M6 := -M2*(IF M4 > 0
00797 --                   THEN 1
00798 --                   ELSE -1) ;
00799 -4      END ;
00800 --      IF ABS(M6) = PFTWO OR M4*M6 > 0
00801 --      THEN M6 := 0 ;
00802 --      KK := IF (M4 > 0)
00803 --            THEN 1
00804 --            ELSE IF M4 < 0
00805 --                 THEN -1
00806 --                 ELSE -K ;
00807 --      M44 := ABS(M4) ;
00808 --      OUT(0|1) := CHESSMAN(M44) ;
00809 --      IF ~ENGLISH
00810 4-      THEN BEGIN
00811 --        J := IF COKO
00812 --             THEN 0
00813 --             ELSE 1 ;
00814 --        IF (PIECES(M4) > 1) AND (M44 ~= BISHOP) AND ((M44 ~= PAWN)
00815 --          OR (M2 = ENPRIS) OR (M6 ~= 0)) OR COKO
00816 5-        THEN BEGIN
00817 --          OUT(J|2) := BOX(M3) ;
00818 --          OUT(J+2|1) := IF (M6 ~= 0) OR ((M2 = ENPRIS) AND (M44 = PAWN))
00819 --                        THEN "x"
00820 --                        ELSE "-" ;
00821 --          J := J + 3 ;
00822 --          IF COKO
00823 --          THEN J := J - 1 ;
00824 -5        END ELSE IF (M6 ~= 0) OR ((M2 = ENPRIS) AND (M44 = PAWN))
00825 5-                 THEN BEGIN
00826 --                   IF J = 0
00827 --                   THEN J := 1 ;
00828 --                   OUT(J|1) := "x" ;
00829 --                   J := J + 1 ;
00830 -5        END ;
00831 --        OUT(J|2) := BOX(M5) ;
00832 --        J := J + 2 ;
00833 -4      END ELSE
00834 4-      BEGIN
00835 --        IF (PIECES(M4) > 1) AND (M44 ~= BISHOP) AND ((M44 ~= PAWN)
00836 --          OR (M2 > 0) AND (M2 < PFTWO)) OR COKO
00837 5-        THEN BEGIN
00838 --          OUT(1|1) := "/" ;
00839 --          OUT(2|3) := CHESSBOARD(M3) ;
00840 -5        END ELSE J := 1 ;
00841 --        IF (M2 = ENPRIS) AND (M44 = PAWN)
00842 5-        THEN BEGIN
00843 --          OUT(J|3) := "xP/" ;
00844 --          OUT(J+3|3) := CHESSBOARD(M5-K*FILE) ;
00845 --          IF COKO
00846 --          THEN J := J + 4 ;
00847 --          OUT(J+2 | 3) := " ep" ;
00848 --          J := J + 5 ;
00849 -5        END ELSE
00850 5-        BEGIN
00851 --          IF (M6 ~= 0)
00852 6-          THEN BEGIN
00853 --            OUT(J|3) := "x /" ;
00854 --            OUT(J+1|1) := CHESSMAN(ABS(M6)) ;
00855 --            J := J + 2 ;
00856 -6          END ELSE OUT(J|1) := "-" ;
00857 --          IF (M6 = 0) OR (PIECES(M6) > 1) OR COKO
00858 6-          THEN BEGIN
00859 --            OUT(J+1|3) := CHESSBOARD(M5) ;
00860 --            J := J + 4 ;
00861 -6          END ;
00862 -5        END ;
00863 -4      END ;
00864 --      IF (M2 > PFTWO)
00865 4-      THEN BEGIN
00866 --        OUT(J|2) := " =" ;
00867 --        OUT(J+2|1) := CHESSMAN(M2-PROMOTE) ;
00868 --        J := J + 3 ;
00869 -4      END ;
00870 -3    END ;
00871 --    OUT(J|4) := CHK(M) ;
00872 --    if ~ENGLISH or COKO
00873 3-    then begin
00874 --      if M > 0 and M < 6 then
00875 --        OUT(j|4) := case M of (" --*", " +  ", " -+*", " +- ", " ++ ") ;
00876 --      if M2 = ENPRIS then
00877 --        OUT(J|4) := " ep " ;
00878 -3    end ;
00879 --    J := J + 4 ;
00880 --    FOR I := 0 UNTIL J
00881 --    DO MC(I) := OUT(I|1) ;
00882 --    FOR I := J UNTIL 23
00883 --    DO MC(I) := SPACE ;
00884 -2  END OF_DESCRIBEMOVE ;
00885 --  
00886 --  PROCEDURE DUMPER (INTEGER VALUE X, Y) ;
00887 2-  BEGIN
00888 --    INTEGER T ;
00889 --    STRING(4) MARK ;
00890 --  
00891 --    MARK := " #  " ;
00892 --    T := X ;
00893 --    IF (T > Y)
00894 --    THEN X := Y ;
00895 --    IF (T > Y)
00896 --    THEN Y := T ;
00897 --    IF (X < 1)
00898 --    THEN X := 1 ;
00899 --    IF (Y > 8)
00900 --    THEN Y := 8 ;
00901 --    I_W := 2 ;
00902 --    FOR L := X*BRDWIDTH UNTIL (Y+1)*BRDWIDTH
00903 --    DO IF (BRD(L) ~= EDGE)
00904 3-       THEN BEGIN
00905 --         WRITE(L) ;
00906 --         FOR J := 1 STEP 1 UNTIL POS(L)
00907 --         DO WRITEON(POSITION(L,J)) ;
00908 --         WRITEON(MARK) ;
00909 --         FOR J := POSITION(L,LIM) UNTIL LIM-1
00910 --         DO WRITEON(POSITION(L,J)) ;
00911 --         WRITEON(MARK) ;
00912 --         FOR J := CON(-1,L) UNTIL CON(1,L)
00913 --         DO WRITEON(CONTROL(L,J)) ;
00914 --         WRITEON(MARK) ;
00915 --         WRITEON(CON(0,L), CON(1,L)) ;
00916 -3    END ;
00917 --    I_W := 5 ;
00918 -2  END OF_DUMPER ;
00919 --  
00920 --  PROCEDURE FORKING (INTEGER VALUE KSQ, SQ, PC, KK) ;
00921 2-  BEGIN
00922 --    INTEGER DIR, SQT, PCT, VAL ;
00923 --  
00924 --    IF PC ~= KNIGHT
00925 3-    THEN BEGIN
00926 --      DIR := BOTV(EDGE, OFFSET(KSQ) -OFFSET(SQ)) ;
00927 --      SQT := SQ ;
00928 --      IF DIR ~= 0
00929 --      THEN WHILE BRD(SQT) = 0
00930 --      DO SQT := SQT + DIR ;
00931 --      PCT := BRD(SQT) ;
00932 --                   COMMENT WRITE("FORK", KSQ, SQ, SQT, PCT, PC, KK, CON(KK,SQT)) ;
00933 --      IF PCT ~= EDGE AND PCT*KK > 0 AND (CON(KK,SQT) = 0 OR ABS(PCT) > PC)
00934 --      THEN FORKS(KK,SQ) := -PC*KK ;
00935 -3    END ELSE FOR J := 1 UNTIL 8
00936 3-             DO BEGIN
00937 --               SQT := SQ + S(J) ;
00938 --               PCT := BRD(SQT) ;
00939 --                   COMMENT WRITE("FORK", KSQ, SQ, SQT, PCT, PC, KK, CON(KK,SQT)) ;
00940 --               IF SQT ~= KSQ AND PCT ~= EDGE AND PCT*KK > 0
00941 --                 AND (CON(KK,SQT) = 0 OR ABS(PCT) > PC)
00942 --               THEN FORKS(KK,SQ) := -PC*KK ;
00943 -3    END ;
00944 -2  END OF_FORKING ;
00945 --  
00946 --  PROCEDURE GETMAN (STRING(1) ARRAY PCDESC(*) ; INTEGER ARRAY MAN(*) ;
00947 --                                                INTEGER VALUE L) ;
00948 --  COMMENT determines internal code for chess man mentioned ;
00949 2-  BEGIN
00950 --    FOR I := 0, 1, 2
00951 3-    DO BEGIN
00952 --      MAN (I) := 0 ;
00953 --      FOR J := PAWN UNTIL KING
00954 --      DO IF (PCDESC (L) = CHESSMAN (J))
00955 4-         THEN BEGIN
00956 --           MAN (I) := J ;
00957 --           GO TO NEXTI
00958 -4      END ;
00959 --  NEXTI:
00960 --      L := L + 1 ;
00961 -3    END FORI ;
00962 --    IF (MAN (1) = 0)
00963 3-    THEN BEGIN
00964 --      MAN (2) := MAN (0) ;
00965 --      MAN (0) := 0 ;
00966 -3    END ELSE IF (MAN (2) = 0)
00967 3-             THEN BEGIN
00968 --               MAN (2) := MAN (1) ;
00969 --               MAN (1) := MAN (0) ;
00970 --               MAN (0) := 0 ;
00971 -3    END ;
00972 --    IF (MAN(2) = 0)
00973 --    THEN MESSAGE1 := "IMPROPER PIECE" ;
00974 -2  END OF_GETMAN ;
00975 --  
00976 --  PROCEDURE GETSQ (STRING(1) ARRAY SQDESC(*) ; INTEGER ARRAY SQ(*) ;
00977 --                                               INTEGER VALUE D) ;
00978 --    COMMENT determines internal number for chess square ;
00979 2-  BEGIN
00980 --    INTEGER FIRST, NEXT, ROW, COL ;
00981 --    STRING(1) SIDE ;
00982 --  
00983 --    FIRST := D + 2 ;
00984 --    NEXT := D + 1 ;
00985 --    SIDE := SQDESC (D) ;
00986 --    SQ(0) := NINES ;
00987 --    SQ(1) := -NINES ;
00988 --    FOR J := 1,2,3
00989 3-    DO BEGIN
00990 --      FOR I := 1 UNTIL 8
00991 --      DO IF (SQDESC (FIRST) = DIGIT (I))
00992 4-         THEN BEGIN
00993 --           ROW := IF (K < 0)
00994 --                  THEN 9 - I
00995 --                  ELSE I ;
00996 --           GO TO AA
00997 -4      END ;
00998 --      FIRST := NEXT ;
00999 --      NEXT := D ;
01000 --      SIDE := "0" ;
01001 -3    END WHILELOOP ;
01002 --    GO TO QUIT ;
01003 --  AA:
01004 --    IF (SIDE = "K")
01005 --    THEN COL := IF SQDESC(NEXT) = "R"
01006 --                THEN 8
01007 --                ELSE IF SQDESC(NEXT) = "B"
01008 --                     THEN 6
01009 --                     ELSE IF SQDESC(NEXT) = "N"
01010 --                          THEN 7
01011 --                          ELSE IF SQDESC(NEXT) = "K"
01012 --                               THEN 5
01013 --                               ELSE NINES
01014 --                               ELSE IF (SIDE = "Q")
01015 --                                    THEN COL := IF SQDESC(NEXT) = "N"
01016 --                         THEN 2
01017 --                         ELSE IF SQDESC(NEXT) = "B"
01018 --                              THEN 3
01019 --                              ELSE IF SQDESC(NEXT) = "R"
01020 --                                   THEN 1
01021 --                                   ELSE IF (SQDESC(NEXT) = "Q")
01022 --                     THEN 4
01023 --                     ELSE NINES
01024 3-    ELSE BEGIN
01025 --      IF (SIDE ~= "0")
01026 --      THEN GO TO QUIT
01027 --      ELSE IF (SQDESC(NEXT) = "K") OR (SQDESC(NEXT) = "Q")
01028 --           THEN SIDE := SQDESC(NEXT)
01029 4-      ELSE BEGIN
01030 --        SQ(1) := NINES ;
01031 --        SIDE := "Q" ;
01032 -4      END ;
01033 --      GO TO AA ;
01034 -3    END ;
01035 --    IF (COL < BRDWIDTH)
01036 3-    THEN BEGIN
01037 --      SQ(0) := BRDWIDTH * ROW + COL ;
01038 --      IF (SQ(1) = NINES)
01039 --      THEN SQ(1) := (ROW + 1) * BRDWIDTH - COL - 1 ;
01040 -3    END ;
01041 --  QUIT:
01042 --    IF (SQ(0) = NINES)
01043 --    THEN MESSAGE1 := "IMPROPER SQ" ;
01044 -2  END OF_GETSQ ;
01045 --  
01046 --  PROCEDURE PRINTLINE (INTEGER VALUE N, PLY) ;
01047 2-  BEGIN
01048 --    INTEGER L, SCR ;
01049 --  
01050 --    DESCRIBEMOVE(N, MC) ;
01051 --    IOCONTROL(2) ;
01052 --    FOR I := 1 UNTIL PLY
01053 --    DO WRITEON("  ") ;
01054 --    L := (8*N -(IF (N > 0)
01055 --                THEN 4
01056 --                ELSE -4)) ;
01057 --     COMMENT 4*(2*N -K) ;
01058 --    SCR := SCORE(N) ;
01059 --    IF DUMPP AND SCR ~= BAD AND SCR ~= NOSCR
01060 3-    THEN BEGIN
01061 --      I_W := 3 ;
01062 --      WRITEON(N) ;
01063 --      FOR I := 0,4,5
01064 --      DO WRITEON(STORE(L+I)) ;
01065 --      FOR I := 6,7
01066 --      DO WRITEON(STORE(L+I)) ;
01067 --      I_W := 5 ;
01068 --      FOR I := 1,2,3
01069 --      DO WRITEON(STORE(I+L)) ;
01070 -3    END ;
01071 --    WRITEON(IF N = TRY(TRY(0))
01072 --            THEN "#"
01073 --            ELSE " ") ;
01074 --    FOR I := 0 UNTIL 10
01075 --    DO WRITEON(MC(I)) ;
01076 --    I_W := 3 ;
01077 --    WRITEON(REWARD(N)) ;
01078 --    I_W := 5 ;
01079 --    WRITEON(SCR) ;
01080 -2  END OF_PRINTLINE ;
01081 --  
01082 --  INTEGER PROCEDURE CONVERTS ( STRING(1) ARRAY U(*) ; LOGICAL RESULT ERR) ;
01083 2-  BEGIN
01084 --    INTEGER CCOUNT, NUM, TEMP ;
01085 --    LOGICAL NEGATIVE ;
01086 --  
01087 --    NEGATIVE := ERR := FALSE ;
01088 --    NUM := CCOUNT := 0 ;
01089 --    WHILE U(CCOUNT) = " "
01090 --    DO IF CCOUNT < CHARCOUNT
01091 --       THEN CCOUNT := CCOUNT + 1
01092 --       ELSE GO TO ERRTERM ;
01093 --    IF U(CCOUNT) = "-"
01094 3-    THEN BEGIN
01095 --      NEGATIVE := TRUE ;
01096 --      CCOUNT := CCOUNT + 1 ;
01097 -3    END ELSE IF U(CCOUNT) = "+"
01098 --             THEN CCOUNT := CCOUNT + 1 ;
01099 --    WHILE U(CCOUNT) >= "0" AND U(CCOUNT) <= "9" AND NUM <= 214748363
01100 3-    DO BEGIN
01101 --      TEMP := DECODE(U(CCOUNT)) - 240 ;
01102 --      NUM := (NUM * 10) + TEMP ;
01103 --      CCOUNT := CCOUNT + 1 ;
01104 -3    END ;
01105 --    IF U(CCOUNT) ~= " " OR U(CCOUNT-1) = "+" OR U(CCOUNT-1) = "-"
01106 --    THEN GO TO ERRTERM
01107 3-    ELSE BEGIN
01108 --      FOR I := 0 UNTIL CCOUNT-1
01109 --      DO U(I) := " " ;
01110 --      GO TO TERM ;
01111 -3    END ;
01112 --  ERRTERM:
01113 --    ERR := TRUE ;
01114 --    NUM := 0 ;
01115 --  TERM:
01116 --    IF NEGATIVE
01117 --    THEN -NUM
01118 --    ELSE NUM
01119 -2  END OF_CONVERTS ;
01120 --  
01121 --  PROCEDURE PRINTSHORTBRD (INTEGER VALUE S) ;
01122 2-  BEGIN
01123 --    INTEGER PC, LEFT, RIGHT ;
01124 --       COMMENT print boarder as well for now ;
01125 --    LEFT := IF (S = 1)
01126 --            THEN 0
01127 --            ELSE 9 ;
01128 --    RIGHT := IF (S = 1)
01129 --             THEN 9
01130 --             ELSE 0 ;
01131 --    FOR I := LEFT STEP S UNTIL RIGHT
01132 3-    DO BEGIN
01133 --      IOCONTROL(2) ;
01134 --      FOR J := RIGHT STEP -S UNTIL LEFT
01135 4-      DO BEGIN
01136 --        PC := BRD(BRDWIDTH*I+J) ;
01137 --        IF PC = EMPTY
01138 --        THEN WRITEON(IF (I+J) REM 2 = 0
01139 --                     THEN " ::"
01140 --                     ELSE "   ")
01141 --                     ELSE IF DEBUG OR (PC ~= EDGE)
01142 --                          THEN IF ABS(PC) = ENPRIS
01143 --                               THEN WRITEON(" EP")
01144 --                               ELSE WRITEON(MAN(PC)) ;
01145 -4      END ;
01146 -3    END ;
01147 --    I_W := 2 ;
01148 --    S_W := 0 ;
01149 --    WRITE(DATE(0|12), "09-MH2.0 ", COLOR(K),"'S MOVE ", MOVECOUNT, ". ") ;
01150 --    I_W := 5 ;
01151 --    S_W := 1 ;
01152 -2  END OF_PRINTSHORTBRD ;
01153 --  
01154 --  PROCEDURE PUNCHBRD (LOGICAL VALUE FLAG ; STRING(140) VALUE RESULT HISTORY) ;
01155 2-  BEGIN
01156 --    INTEGER L, M, T ;
01157 --  
01158 --    M := -1 ;
01159 --    HISTORY(0|78) := " " ;
01160 --    FOR KK := 1, -1
01161 3-    DO BEGIN
01162 --      FOR I := 1 UNTIL 8
01163 4-      DO BEGIN
01164 --        T := 0 ;
01165 --        L := I * BRDWIDTH ;
01166 --        FOR J := 1 UNTIL 8
01167 5-        DO BEGIN
01168 --          L := L + 1 ;
01169 --          IF (KK*BRD(L) <= 0)
01170 --          THEN T := T + 1
01171 6-          ELSE BEGIN
01172 --            M := M + 2 ;
01173 --            IF (T ~= 0)
01174 --            THEN HISTORY(M-1|1) := DIGIT(T)
01175 --            ELSE M := M - 1 ;
01176 --            T := 0 ;
01177 --            HISTORY(M|1) := CHESSMAN(ABS(BRD(L))) ;
01178 -6          END ;
01179 -5        END FORJ ;
01180 --        IF (T ~= 0)
01181 5-        THEN BEGIN
01182 --          M := M + 1 ;
01183 --          HISTORY(M|1) := DIGIT(T) ;
01184 -5        END ;
01185 -4      END FORI ;
01186 --      M := M + 1 ;
01187 --      HISTORY(M|1) := IF K = 1
01188 --                      THEN "+"
01189 --                      ELSE "-" ;
01190 -3    END ;
01191 --    FOR I := -3 UNTIL 3
01192 --    DO HISTORY(I+81|1) := IF CASTLE(I)
01193 --                          THEN "T"
01194 --                          ELSE "F" ;
01195 --    M := MOVECOUNT REM 100 ;
01196 --    HISTORY(111|1) := IF (MOVECOUNT < 10)
01197 --                      THEN " "
01198 --                      ELSE CODE((M DIV 10) + 240) ;
01199 --    HISTORY(112|1) := CODE((M REM 10) + 240) ;
01200 -2  END OF_PUNCHBRD ;
01201 --  
01202 --  LOGICAL PROCEDURE READU ;
01203 --    COMMENT reads teletype ;
01204 2-  BEGIN
01205 --    LOGICAL TRAC ;
01206 --  
01207 --    ENDFILE := EXCEPTION(FALSE, 1, 1, FALSE, "UNEXPECTED EOF") ;
01208 --  STARTS:
01209 --    TRAC := FALSE ;
01210 --    IOCONTROL(2) ;
01211 --              COMMENT read tty buffer and place characters into
01212 --                      array u(s::f). LAST points to the end of the actual input ;
01213 --    CHARCOUNT := -1 ;
01214 --    WHILE (CHARCOUNT < 0)
01215 3-    DO BEGIN
01216 --      CHARCOUNT := MAXCHAR - 1 ;
01217 --      READCARD(BUFFER) ;
01218 --      IF XCPNOTED(ENDFILE)
01219 --      THEN GO TO STARTS ;
01220 --                  comment convert input into uppercase ;
01221 --                  comment Makes input easier on modern keyboards ;
01222 --      for i := 0 until CHARCOUNT do
01223 --          if ((decode(BUFFER(i|1)) > 128) and (decode(BUFFER(i|1)) <= 170))
01224 --          then BUFFER(i|1) := code(decode(BUFFER(i|1)) + 64) ;
01225 --                          COMMENT strip trailing blanks and non-printing ;
01226 --      WHILE (CHARCOUNT >= 0) AND (BUFFER(CHARCOUNT|1) <= BLANK)
01227 --      DO CHARCOUNT := CHARCOUNT - 1 ;
01228 4-      IF ECHO THEN BEGIN
01229 --         FOR I := 0 UNTIL CHARCOUNT
01230 --         DO WRITEON(BUFFER(I|1)) ;
01231 --         IOCONTROL(2) ;
01232 -4      END ;
01233 --      IF (BUFFER(0|1) = ".")
01234 --      THEN CHARCOUNT := -1 ;
01235 --      FOR I := 0 UNTIL CHARCOUNT + 2
01236 --      DO U(I) := BUFFER(I|1) ;
01237 -3    END ;
01238 --    IF (U (0) = "?") OR (U(0) = "*")
01239 --    THEN TRAC := TRUE
01240 --    ELSE IF (U(0) = "S") AND (U(1) = "T")
01241 --         THEN GO TO STOP ;
01242 --                       COMMENT IF COKO THEN GET(5) ;
01243 --                       COMMENT restore input unit ;
01244 --    TRAC
01245 -2  END OF_READU ;
01246 --  
01247 --  PROCEDURE SCORER (STRING(1) VALUE S, S1, S2) ;
01248 2-  BEGIN
01249 --    INTEGER J, F, T ;
01250 --  
01251 --    F := DECODE(S1) - 240 ;
01252 --    T := DECODE(S2) - 240 ;
01253 --    IF (F < 0)
01254 --    THEN F := 0 ;
01255 --    IF (T < 0)
01256 --    THEN T := 0 ;
01257 --    J := IF (S = "-")
01258 --         THEN -1
01259 --         ELSE 1 ;
01260 --    F := J*(F*6)+J ;
01261 --    T := J*(T+1)*6 ;
01262 --    IF ABS(T) = 60 OR (ABS(T) > ABS(NUMBER(J)))
01263 --    THEN T := NUMBER(J) ;
01264 --    FOR N := F STEP J UNTIL T
01265 --    DO PRINTLINE(USE(ABS(N)), 0) ;
01266 -2  END OF_SCORER ;
01267 --  
01268 --  PROCEDURE SETBOARD (STRING(140) VALUE BUFFER) ;
01269 --    COMMENT fills nsq(*) to describe board position read in ;
01270 2-  BEGIN
01271 --    INTEGER I, J, PC, KP, TT, SBK ;
01272 --    STRING(1) T ;
01273 --  
01274 --    BRD(HOLE) := EMPTY ;
01275 --    FOR I := WQRSQ UNTIL BKRSQ
01276 --    DO BRD(I) := EMPTY ;
01277 --    FOR I := 10 STEP BRDWIDTH UNTIL 80
01278 --    DO BRD(I) := BRD(I+9) := EDGE ;
01279 --    FOR I := -10 UNTIL 9
01280 --    DO BRD(I) := BRD(I+100) := EDGE ;
01281 --    I := WQRSQ - RANK ;
01282 --    J := 0 ;
01283 --    SBK := 1 ;
01284 --    WHILE (BUFFER(J|1) = SPACE)
01285 --    DO J := J + 1 ;
01286 --      NEXTSYMBOL:
01287 --    T := BUFFER(J|1) ;
01288 --    J := J + 1 ;
01289 --    IF (COLS(I) = 8)
01290 --    THEN I := I + 2 ;
01291 --    TT := DECODE(T) - 240 ;
01292 --                       COMMENT is TT a digit? ;
01293 --    IF TT > 8 OR TT < 1
01294 3-    THEN BEGIN
01295 --      FOR KP := PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING, ENPRIS
01296 4-      DO BEGIN
01297 --        PC := KP ;
01298 --        IF (T = CHESSMAN (PC))
01299 --        THEN GO TO PIECE ;
01300 -4      END ;
01301 --      SBK := -SBK ;
01302 --      I := WQRSQ - RANK ;
01303 --      IF (T ~= "+" AND T ~= "-" AND T ~= ".")
01304 --      THEN GOTO ERROR ;
01305 --      IF (SBK = -1)
01306 4-      THEN BEGIN
01307 --        K := IF T = "-"
01308 --             THEN -1
01309 --             ELSE 1 ;
01310 --        GO TO NEXTSYMBOL ;
01311 -4      END ELSE GO TO QUIT ;
01312 --  PIECE:
01313 --      I := I + RANK ;
01314 --      IF BRD(I) ~= EMPTY
01315 --      THEN GOTO ERROR ;
01316 --      BRD(I) := SBK*PC ;
01317 -3    END ELSE IF COLS(I) + TT > 8
01318 --             THEN GOTO ERROR
01319 --             ELSE I := I + TT ;
01320 --    GO TO NEXTSYMBOL ;
01321 --  ERROR:
01322 --    WRITE("ERROR: SETBOARD") ;
01323 --    PRINTSHORTBRD(-1) ;
01324 --  QUIT:
01325 --    IF (BUFFER(111|2) ~= "  ")
01326 3-    THEN BEGIN
01327 --      T := BUFFER(111|1) ;
01328 --      MOVECOUNT := IF (T = " ")
01329 --                   THEN 0
01330 --                   ELSE DECODE(T) - 240 ;
01331 --      IF MOVECOUNT = 0 AND T ~= " "
01332 --      THEN MOVECOUNT := 10 ;
01333 --      T := BUFFER(112|1) ;
01334 --      MOVECOUNT := IF (T = " ")
01335 --                   THEN 1
01336 --                   ELSE MOVECOUNT*10 + DECODE(T) - 240 ;
01337 -3    END ;
01338 --    IF (MOVECOUNT <= 0)
01339 --    THEN MOVECOUNT := 1 ;
01340 --    IF (BUFFER(81|1) = " ")
01341 3-    THEN BEGIN
01342 --      FOR SBK := -1, 1
01343 4-      DO BEGIN
01344 --        IF (BRD(50-35*SBK) = KING * SBK)
01345 5-        THEN BEGIN
01346 --          CASTLE(SBK) := IF (BRD(KRSQ(SBK)) = ROOK * SBK)
01347 --                         THEN TRUE
01348 --                         ELSE FALSE ;
01349 --          CASTLE(TWO(SBK)) := IF (BRD(QRSQ(SBK)) = ROOK * SBK)
01350 --                              THEN TRUE
01351 --                              ELSE FALSE ;
01352 -5        END ELSE CASTLE(SBK) := CASTLE(TWO(SBK)) := FALSE ;
01353 --        CASTLE(THREE(SBK)) := ~ (CASTLE(TWO(SBK)) OR CASTLE(SBK)) ;
01354 -4      END ;
01355 --      CASTLE(0) := IF CASTLE(-3) AND CASTLE(3)
01356 --                   THEN FALSE
01357 --                   ELSE IF CASTLE(-3) OR CASTLE(3)
01358 --                        THEN TRUE
01359 --                        ELSE FALSE ;
01360 -3    END ELSE FOR I := -3 UNTIL 3
01361 --    DO CASTLE(I) := IF (BUFFER(I+81|1) = "T")
01362 --                    THEN TRUE
01363 --                    ELSE FALSE ;
01364 -2  END OF_SETBOARD ;
01365 --  
01366 --  LOGICAL PROCEDURE STARTTHISPROBLEM (LOGICAL VALUE SEEK) ;
01367 --  COMMENT sets parameters to start a chess problem ;
01368 2-  BEGIN
01369 --    INTEGER J, PC ;
01370 --    LOGICAL NEEDKING ;
01371 --  
01372 --    MAKEMV := FALSE ;
01373 --    NEEDKING := FALSE ;
01374 --    KINGSQ (1) := KINGSQ (-1) := DIFFVAL := MEN(1) := MEN(-1) := 0 ;
01375 --    FOR I := -8 UNTIL 8
01376 --    DO PIECES (I) := 0 ;
01377 --    for SQ := -11 until 109 do
01378 3-    begin
01379 --      CON(-1,SQ) := CON(0,SQ) := CON(1,SQ) := 0 ;
01380 --      CONTROL(SQ,-1) := CONTROL(SQ,0) := CONTROL(SQ,1) := 0 ;
01381 -3    end ;
01382 --    FOR SQ := WQRSQ UNTIL BKRSQ
01383 3-    DO BEGIN
01384 --      PC := BRD(SQ) ;
01385 --      IF (PC ~= EDGE) AND (PC ~= EMPTY)
01386 --      THEN IF (ABS(PC) <= KING)
01387 4-           THEN BEGIN
01388 --             J := IF (PC > 0)
01389 --                  THEN 1
01390 --                  ELSE -1 ;
01391 --             PIECES(0) := PIECES(0) + 1 ;
01392 --             MEN(J) := MEN(J) + 1 ;
01393 --             DIFFVAL := DIFFVAL + J*VALUES(ABS(PC)) ;
01394 --             PIECES(PC) := PIECES(PC) + 1 ;
01395 --             IF (ABS(PC) = KING)
01396 --             THEN CLEARPAWN(J) := KINGSQ(J) := SQ ;
01397 -4      END ;
01398 --      POS(SQ) := POSITION(SQ,0) := CON(-1,SQ) := CON(0,SQ) := CON(1,SQ)
01399 --              := CONTROL(SQ,0) := 0 ;
01400 --      SEC(-1,SQ) := SEC(0,SQ) := SEC(1,SQ) := SECRET(SQ,0) := 0 ;
01401 --      POSITION(SQ,LIM) := LIM ;
01402 --      CAPTURE_CH(SQ) := FALSE ;
01403 -3    END FORSQ ;
01404 --    IF PIECES(KING) = 1 AND PIECES(-KING) = 1
01405 3-    THEN BEGIN
01406 --      SQUARE(ELIMIT-1) := WQRSQ ;
01407 --      FOR SQ := WQRSQ UNTIL BKRSQ
01408 4-      DO BEGIN
01409 --        PC := BRD(SQ) ;
01410 --        IF (PC ~= EMPTY) AND (PC ~= EDGE)
01411 5-        THEN BEGIN
01412 --          LOSS(ELIMIT) := ELIMIT ;
01413 --          REMAKE(SQ, SQ) ;
01414 --          IF SEEK AND ABS(PC) = PAWN
01415 6-          THEN BEGIN
01416 --            J := IF PC > 0
01417 --                 THEN 1
01418 --                 ELSE -1 ;
01419 --                 COMMENT note most advanced passed pawn ;
01420 --            IF PASSEDPAWN(SQ, J) > 0
01421 --            THEN IF J > 0 OR CLEARPAWN(J) = KINGSQ(J)
01422 --                    OR ROWS(CLEARPAWN(J)) = ROWS(SQ)
01423 --                 THEN CLEARPAWN(J) := SQ ;
01424 -6          END ;
01425 -5        END ;
01426 -4      END ;
01427 --      REMAKE(KINGSQ(1), KINGSQ(1)) ;
01428 --      REMAKE(KINGSQ(-1), KINGSQ(-1)) ;
01429 --      KINGCONTROL(1) ;
01430 --      KINGCONTROL(-1) ;
01431 --      IF LEVEL = 0 AND CON(K,KINGSQ(-K)) ~= 0
01432 --      THEN NEEDKING := TRUE ;
01433 --      ENPRISE(-K) ;
01434 --      J := ELIMIT ;
01435 --      TWOVAL := 0 ;
01436 --      FOR I := SQUARE(0) STEP -1 UNTIL 1
01437 4-      DO BEGIN
01438 --        J := J - 1 ;
01439 --        SQUARE(J) := SQUARE(I) ;
01440 --        LOSS(J) := LOSS(I) ;
01441 --        IF (LOSS(J) > TWOVAL)
01442 --        THEN TWOVAL := LOSS(J) ;
01443 -4      END ;
01444 --      LOSS(ELIMIT) := SQUARE(ELIMIT) := J ;
01445 --      IF SEEK
01446 --      THEN ENPRISE(K) ;
01447 -3    END ELSE NEEDKING := TRUE ;
01448 --    IF NEEDKING
01449 --    THEN WRITE("KING PROBLEMS") ;
01450 --    ~NEEDKING
01451 -2  END OF_STARTTHISPROBLEM ;
01452 --  
01453 --  LOGICAL PROCEDURE CHECK (INTEGER VALUE SQ, KK ; INTEGER RESULT NT) ;
01454 --    COMMENT  how many times (nt) is square sq "attacked" by pieces
01455 --               of colour -kk? ;
01456 2-  BEGIN
01457 --    INTEGER NN, HD, HN, SQU, VAL, PCU, L, SQ3, PC, J, LL, SQP, K_FILE, I ;
01458 --    LOGICAL NOTKING ;
01459 --  
01460 --    NN := HN := 0 ;
01461 --    HD := 10 ;
01462 --    K_FILE := FILES(K) ;
01463 --    KINGUSED := FALSE ;
01464 --    PC := ABS(BRD(SQ)) ;
01465 --    NOTKING := IF (PC = KING)
01466 --               THEN FALSE
01467 --               ELSE TRUE ;
01468 --    LL := CON(-KK,SQ) ;
01469 --    IF (PC = ENPRIS)
01470 3-    THEN BEGIN
01471 --                  COMMENT enpassant pawn may block attack/defence along the file ;
01472 --      SQP := SQ + K_FILE ;
01473 --      FOR L := CON(-KK,SQP) STEP KK UNTIL -KK
01474 4-      DO BEGIN
01475 --        SQU := CONTROL(SQP,L) ;
01476 --        PCU := ABS(BRD(SQU)) ;
01477 --        IF (PCU = ROOK) OR (PCU = QUEEN)
01478 --        THEN IF (BOTV(EDGE,OFFSET(SQP)-OFFSET(SQU)) = K_FILE)
01479 5-             THEN BEGIN
01480 --               LL := LL - KK ;
01481 --               CONTROL(SQ,LL) := SQU ;
01482 -5        END ;
01483 -4      END ;
01484 -3    END ;
01485 --    FOR L := LL STEP KK UNTIL -KK
01486 3-    DO BEGIN
01487 --      SQU := CONTROL(SQ,L) ;
01488 --      PCU := ABS(BRD(SQU)) ;
01489 --      IF (PCU < PAWN) OR (PCU > KING)
01490 4-      THEN BEGIN
01491 --        WRITE("CHECK-piece", SQ, SQU, PCU, L, K, LEVEL) ;
01492 --        GO TO STARTS ;
01493 -4      END ;
01494 --      I := NN ;
01495 --      WHILE I > 0 AND PCU < ABS(BRD(SQR(I)))
01496 4-      DO BEGIN
01497 --        SQR(I+1) := SQR(I) ;
01498 --        I := I - 1 ;
01499 -4      END ;
01500 --      SQR(I+1) := SQU ;
01501 --      NN := NN + 1 ;
01502 --      IF (PCU = KING)
01503 --      THEN KINGUSED := TRUE ;
01504 --      IF (PCU ~= KNIGHT)
01505 --      THEN IF (NOTKING)
01506 --           THEN WHILE HIDDEN(SQ, SQU, SQ3, 0, FALSE)
01507 4-                DO BEGIN
01508 --                                    COMMENT hidden attack or defence ;
01509 --                  IF KK*BRD(SQ3) > 0
01510 --                  THEN J := HD := HD - 1
01511 --                  ELSE IF KINGUSED
01512 --                       THEN J := HN - 1
01513 --                       ELSE J := HN := HN - 1 ;
01514 --                                 COMMENT can have hidden defender "through" King ;
01515 --                  SQU := SQR(J) := SQ3 ;
01516 -4      END ;
01517 -3    END ;
01518 --    NT := NN + ABS(HN) ;
01519 --    SQR(10) := HD ;
01520 --    L := IF KINGUSED
01521 --         THEN NN - 1
01522 --         ELSE NN ;
01523 --    FOR I := -1 STEP -1 UNTIL HN
01524 3-    DO BEGIN
01525 --                   COMMENT include hidden pieces. ;
01526 --      L := L + 1 ;
01527 --      SQR(L) := SQR(I) ;
01528 -3    END ;
01529 --                    COMMENT   place king at end if used. ;
01530 --    IF (KINGUSED)
01531 --    THEN SQR(NT) := KINGSQ(-KK) ;
01532 --    POWER(0) := 0 ;
01533 --    IF DEBUG AND HN ~= 0
01534 --    THEN WRITE("check", NT) ;
01535 --    IF (NN > 0)
01536 3-    THEN BEGIN
01537 --      FOR L := 1 UNTIL NT
01538 4-      DO BEGIN
01539 --        SQU := SQR(L) ;
01540 --        SECRET(SQ,-KK*L) := SQU ;
01541 --        PCU := ABS(BRD(SQU)) ;
01542 --        POWER(L) := POWER(L-1) + VALUES(PCU)
01543 --                               + (IF PCU = PAWN AND RANKS(ROWS(SQU)) = -KK
01544 --                                  THEN PAWNVAL(ROWS(SQU))
01545 --                                  ELSE 0) ;
01546 --        IF DEBUG AND HN ~= 0
01547 --        THEN WRITEON(POWER(L)) ;
01548 -4      END ;
01549 --      MINPIECE := POWER(1) ;
01550 --      XRAY(SQ, -KK, NN, NT) ;
01551 --      MAXPIECE := IF KINGUSED
01552 --                  THEN VALUES(KING)
01553 --                  ELSE POWER(NN) - POWER(NN-1) ;
01554 -3    END ;
01555 --    IF KINGUSED AND NN ~= NT
01556 3-    THEN BEGIN
01557 --      SECRET(SQ, -KK*NN) := SQR(NT) ;
01558 --      SECRET(SQ, -KK*NT) := SQR(NN) ;
01559 -3    END ;
01560 --    SEC(-KK,SQ) := -KK*NT ;
01561 --    POWER(0) := NN ;
01562 --    SQR(0) := NT ;
01563 --    IF (NN > 0)
01564 --    THEN TRUE
01565 --    ELSE FALSE
01566 -2  END OF_CHECK ;
01567 --  
01568 --  LOGICAL PROCEDURE SACRIFICE (INTEGER VALUE SQ ; LOGICAL VALUE PRINT) ;
01569 --    COMMENT  determines whether the piece on square sq is being attacked ;
01570 2-  BEGIN
01571 --    INTEGER MAXATTACK, MINATTACK, IA, ID, LOST, COST, PC, HID, KK, IX,
01572 --            I, L, TMP, SQ3, PC3, HID_DEF, SQA, SQ1, PC1, PCA, DEFN, KSQ ;
01573 --    INTEGER ARRAY ATTACKERS(0::10) ;
01574 --    LOGICAL SACRIFICE, DEFENDED, PROMCAPTURE, CHECKCAPTURE, T, WITHCHECK ;
01575 --  
01576 --    SACRIFICE := FALSE ;
01577 --    COST := -NINES ;
01578 --    IX := ATTACKERS(0) := ATTASQRS(0) := ID := IA := 0 ;
01579 --    SEC(-1,SQ) := CON(-1,SQ) ; SEC(1,SQ) := CON(1,SQ) ;
01580 --    PC := BRD(SQ) ;
01581 --    KK := IF PC > 0
01582 --          THEN 1
01583 --          ELSE -1 ;
01584 --    IX := 0 ;
01585 --    IF CHECK(SQ, KK, IA)
01586 --    THEN
01587 --    IF ~KINGUSED OR IA ~= 1 OR CON(KK,SQ) = 0
01588 3-    THEN BEGIN
01589 --      PC := ABS(PC) ;
01590 --      MAXATTACK := MAXPIECE ;
01591 --      LOST := VALUES(PC) ;
01592 --      IF (PC = PAWN)
01593 4-      THEN BEGIN
01594 --        IF (RANKS(ROWS(SQ)) = KK)
01595 --        THEN LOST := LOST + PAWNVAL(ROWS(SQ)) ;
01596 --        IF ENDGAME OR LOST >= 9
01597 --        THEN LOST := LOST + PASSEDPAWN(SQ,KK) ;
01598 --        TMP := 0 ;
01599 --        IF ABS(BRD(SECRET(SQ,-KK))) = PAWN AND CON(KK,SQ) = 0
01600 --        THEN TMP := PASSEDPAWN(SQ,-KK)
01601 5-        ELSE BEGIN
01602 --          BRD(SQ) := 0 ;  Comment if P on SQ goes, does opponent have a PP? ;
01603 --          FOR L := -1, 0, 1
01604 6-          DO BEGIN
01605 --            I := SQ + FILES(KK) + L ;
01606 --            WHILE (ABS(BRD(I)) ~= PAWN AND BRD(I) ~= EDGE)
01607 --            DO I := I + FILES(KK) ;
01608 --            if (BRD(I) ~= EDGE)
01609 7-            then begin
01610 --              TMP := TMP + (IF BRD(I) = -KK*PAWN
01611 --                            THEN PASSEDPAWN(I,-KK)
01612 --                            ELSE 0) ;
01613 --              IF TMP > 0 AND L ~= 0 AND ABS(ROWS(SQ)-ROWS(I)) = 1
01614 --                         AND KK*SEC(0,I-FILES(KK)) > 0
01615 --              THEN TMP := 0 ;
01616 -7            end ;
01617 -6          END ;
01618 --          BRD(SQ) := KK*PAWN ;
01619 -5        END ;
01620 --        IF TMP > 1 THEN TMP := TMP - 1 ;
01621 --        LOST := LOST + TMP ;
01622 -4      END ;
01623 --      COST := LOST ;
01624 --      PROMCAPTURE := IF (MINPIECE < VALUES(KNIGHT)) AND (PAWNS(SQ) = 0)
01625 --                     THEN TRUE
01626 --                     ELSE FALSE ;
01627 --      IF PROMCAPTURE
01628 --      THEN COST := COST + VALUES(ROOK) ;
01629 --      FOR I := 0 UNTIL IA
01630 4-      DO BEGIN
01631 --        ATTASQRS(I) := SQR(I) ;
01632 --        ATTACKERS(I) := POWER(I) - LOST ;
01633 -4      END ;
01634 --      ATTACKERS(0) := POWER(0) ;
01635 --      MINATTACK := POWER(1) ;
01636 --      HID_DEF := SQR(10) ;
01637 --      FOR I := SQR(10) UNTIL 10
01638 --      DO ATTASQRS(I) := SQR(I) ;
01639 --      CHECKCAPTURE := WEAKPIN < 0 ;
01640 --      HID := MINATTACK - MINPIECE ;
01641 --      DEFENDED := IF (CON(KK,SQ) = 0) AND (ATTASQRS(10) = 10)
01642 --                  THEN FALSE
01643 --                  ELSE TRUE ;
01644 --      IX := 1 ;
01645 --      IF ~DEFENDED OR ~CHECK(SQ, -KK, ID) AND ID > 10-ATTASQRS(10)
01646 --      THEN POWER(0) := SQR(0) := 0
01647 4-      ELSE BEGIN
01648 --                                COMMENT the following is an attempt to estimate
01649 --                                        hidden attacks ;
01650 --        IF DEBUG
01651 --        THEN IF (HID_DEF < 10 OR SQR(10) < 10)
01652 --             THEN WRITE("SACR. PROB.", SQ, KK, IA, ID, SQR(SQR(10)),
01653 --                         SQR(10), ATTASQRS(HID_DEF)) ;
01654 --        IF HID_DEF = 9 AND ID = 0 AND ATTASQRS(0) = 1
01655 --        THEN IF VALUES(ABS(BRD(ATTASQRS(HID_DEF))))
01656 --                   > VALUES(ABS(BRD(ATTASQRS(1)))) + DELTA
01657 --             THEN HID_DEF := 10 ;
01658 --        IF PROMCAPTURE
01659 --        THEN COST := COST - VALUES(ROOK) ;
01660 --        L := 10 -HID_DEF ;
01661 --        IF L > 0
01662 5-        THEN BEGIN
01663 --          L := CON(KK,SQ) ;
01664 --          FOR I := HID_DEF UNTIL 9
01665 6-          DO BEGIN
01666 --            L := L + KK ;
01667 --            CONTROL(SQ,L) := ATTASQRS(I) ;
01668 --            ID := ID + 1 ;
01669 --            SQR(ID) := ATTASQRS(I) ;
01670 --            SECRET(SQ,KK*ID) := SQR(ID) ;
01671 --            POWER(ID) := POWER(ID-1) + VALUES(ABS(BRD(SQR(ID)))) ;
01672 -6          END ;
01673 -5        END ;
01674 --        L := 10 -SQR(10) ;
01675 --        IF L > 0
01676 5-        THEN BEGIN
01677 --          L := CON(-KK,SQ) ;
01678 --          FOR I := SQR(10) UNTIL 9
01679 6-          DO BEGIN
01680 --            L := L - KK ;
01681 --            CONTROL(SQ,L) := SQR(I) ;
01682 --            IA := IA + 1 ;
01683 --            ATTASQRS(IA) := SQR(I) ;
01684 --            SECRET(SQ,-KK*IA) := SQR(I) ;
01685 --            ATTACKERS(IA) := ATTACKERS(IA-1) + VALUES(ABS(BRD(SQR(I)))) ;
01686 -6          END ;
01687 -5        END ;
01688 --        SEC(KK,SQ) := KK*(ID) ;
01689 --        SEC(-KK,SQ) := -KK*(IA) ;
01690 --                                COMMENT assume attacker makes last move ;
01691 --        IF (IA > ID)
01692 --        THEN
01693 5-        BEGIN
01694 --                                COMMENT  e.g., qbn/b/nr, kn/p/b ;
01695 --          IF KINGUSED
01696 --          THEN ID := ID - 1 ;
01697 --          COST := LOST ;
01698 --          IX := 1 ;
01699 --          FOR I := 1 UNTIL ID
01700 6-          DO BEGIN
01701 --            IX := I ;
01702 --                              COMMENT kbn/q/nq, kq/r/k, qbn/n/pq ;
01703 --            TMP := POWER(I) - ATTACKERS(I) ;
01704 --            IF TMP < -DELTA
01705 7-            THEN BEGIN
01706 --                          COMMENT defender makes last move ;
01707 --                          COMMENT e.g., nnp/p/pp, rr/b/p ;
01708 --              IX := 0 ;
01709 --              IF I = 1
01710 --              THEN COST := -ATTACKERS(1)
01711 --              ELSE IF I = 2
01712 --                   THEN COST := COST - POWER(I-1)
01713 --                   ELSE COST := COST - POWER(I-1) + POWER(I-2) ;
01714 --              GOTO SWAP ;
01715 -7            END ELSE IF COST < TMP -DELTA
01716 --                     THEN GOTO SWAP
01717 --                     ELSE COST := TMP ;
01718 -6          END ;
01719 --          IX := ID + 1 ;
01720 --          GO TO SWAP ;
01721 -5        END ELSE
01722 5-        BEGIN
01723 --                           COMMENT assume defender makes last move (no forkloss) ;
01724 --          IX := 0 ;
01725 --          COST := - ATTACKERS(1) ;
01726 --          IF (ID = 1) AND (WEAKPIN > 0)
01727 --          THEN COST := COST +(IF WEAKPIN > MINATTACK
01728 --                              THEN MINATTACK
01729 --                              ELSE WEAKPIN) ;
01730 --          IF (ABS(BRD(ATTASQRS(IA))) = KING)
01731 6-          THEN BEGIN
01732 --            COMMENT K/Q/K, K/R/QK, KB/B/NK ;
01733 --            IA := IA - 1 ;
01734 --            IF IA = 0
01735 --            THEN COST := -NINES ;
01736 -6          END ;
01737 --                      COMMENT 2 <= IA <= ID ;
01738 --          IF IA <= 1
01739 6-          THEN BEGIN
01740 --            COMMENT N/P/R, P/P/N, N/P/PB, P/N/PB ;
01741 --            GOTO SWAP ;
01742 -6          END ;
01743 --          FOR I := 2 UNTIL IA
01744 6-          DO BEGIN
01745 --            COMMENT RB/P/NR, QR/N/PQ ;
01746 --            COMMENT QR/Q/BK ;
01747 --            TMP := POWER(I-1) - ATTACKERS(I) ;
01748 --            IF TMP < -DELTA
01749 --            THEN GOTO SWAP
01750 --            ELSE IF COST <= TMP + DELTA
01751 --                 THEN COST := TMP
01752 7-                 ELSE BEGIN
01753 --                   COMMENT attacker makes last move ;
01754 --                   COMMENT PP/P/RK, QN/N/RK ;
01755 --                   IX := I - 1 ;
01756 --                   IF I = 2
01757 --                   THEN COST := LOST ;
01758 --                   GOTO SWAP ;
01759 -7                 END ;
01760 -6          END ;
01761 --          IF COST > LOST
01762 6-          THEN BEGIN
01763 --            COST := LOST ;
01764 --            IX := 1 ;
01765 -6          END ;
01766 -5        END ;
01767 --  SWAP:
01768 --        ATTASQRS(0) := IA ;
01769 --        SQR(0) := ID ;
01770 --        IF KINGUSED AND IA > ID
01771 --        THEN COST := COST + 1 ;
01772 --                                COMMENT CREDIT for capture in vicinity of King ;
01773 -4      END ;
01774 --      IF ~DEFENDED AND (ATTACKERS(0) = 1)
01775 --      THEN COST := COST -HID ;
01776 --      CAPTURE_CH(SQ) := FALSE ;
01777 --      TMP := CHECK_S(KK,SQ) ;
01778 --      IF TMP ~= 0 AND PC ~= KING
01779 --      THEN FOR I := CON(-KK,SQ) STEP KK UNTIL -KK
01780 4-           DO BEGIN
01781 --             PC := BRD(CONTROL(SQ,I)) ;
01782 --             IF PC*TMP > 0
01783 --             THEN IF CHEC(ABS(TMP), ABS(PC))
01784 5-                  THEN BEGIN
01785 --                    IF DEBUG
01786 --                    THEN WRITE("CH ", SQ, PC, TMP) ;
01787 --                    CAPTURE_CH(SQ) := TRUE ;
01788 -5             END ;
01789 -4      END ;
01790 --                          COMMENT
01791 --                                IF DEBUG AND TMP ~= 0
01792 --                                THEN WRITE("SACRIF", SQ, KK, CHECK_S(KK,SQ)) ;
01793 -3    END ;
01794 --  
01795 --    SEC(0,SQ) := SEC(1,SQ) + SEC(-1,SQ) ;
01796 --    ATTASQRS(10) := IX ;
01797 --    TMP := IF ID = 0
01798 --           THEN ATTACKERS(0)
01799 --           ELSE IF IX > ID
01800 --                THEN IA
01801 --                ELSE IX ;
01802 --    LOSSES := COST ;
01803 --    IF LOSSES > -DELTA AND IX <= IA
01804 3-    THEN BEGIN
01805 --      IF IX = 0 THEN IX := 1 ELSE
01806 --      LOSSES := LOSSES + FORKLOSS(SQ, IX, TMP) ;
01807 --      IF ~ CHECKCAPTURE AND IX = IA THEN
01808 --      FOR I := 1 UNTIL IX
01809 4-      DO BEGIN
01810 --        SQA := ATTASQRS(I) ;
01811 --        PCA := BRD(SQA) ;
01812 --        IF DEBUG THEN WRITE("SAC", SQA, SQ) ;
01813 --        FOR J := K STEP K UNTIL CON(K,SQA)
01814 5-        DO BEGIN
01815 --          SQ1 := CONTROL(SQA,J) ;
01816 --          PC1 := BRD(SQ1) ;
01817 --          IF DEBUG THEN WRITEON(SQ1, PC1, LOSSES) ;
01818 --          IF SQ1 ~= SQ AND BISHOP <= ABS(PC1) AND ABS(PC1) <= QUEEN
01819 6-          THEN BEGIN
01820 --            T := HIDDEN(SQ1, SQA, SQ3, -K, FALSE) ;
01821 --            PC3 := BRD(SQ3) ;
01822 --                COMMENT is SQA pinned against SQ3 by SQ1 ;
01823 7-            IF SQ3 ~= HOLE AND PC1*PC3 < 0 THEN BEGIN
01824 --              KSQ := IF PCA > 0 THEN KINGSQ(-1) ELSE KINGSQ(1) ;
01825 --              WITHCHECK := ABS(PCA) = PAWN AND ABS(KSQ-SQA-FILES(K)) = 1
01826 --                           OR BOTV(ABS(PCA), OFFSET(SQ)-OFFSET(KSQ)) = 1
01827 --                             AND CLEAR(SQ, SQ, KSQ) ;
01828 8-              IF ~WITHCHECK THEN IF PC3*PCA > 0 THEN BEGIN
01829 --                DEFN := ABS(CON(-K,SQ3)) ;
01830 --                PC3 := ABS(PC3) ; PCA := ABS(PCA) ;
01831 --                IF DEFN = 0 OR DEFN = 1
01832 --                   AND BOTV(PCA, OFFSET(SQA)-OFFSET(SQ3)) = 1
01833 --                   AND BOTV(PCA, OFFSET(SQ)-OFFSET(SQ3)) ~= 1
01834 --                THEN LOSSES := LOSSES
01835 --                                 - (IF ID = 0 THEN VALUES(PC3)
01836 --                                    ELSE IF VALUES(PCA) > VALUES(PC3)-DELTA
01837 --                                         THEN 0
01838 --                                         ELSE VALUES(PC3) - VALUES(PCA)) ;
01839 -8              END ELSE
01840 --              IF BOTV(ABS(PC3), OFFSET(SQ3) -OFFSET(SQ1)) = 1
01841 8-              THEN BEGIN
01842 --                PC1 := ABS(PC1) ; PCA := ABS(PCA) ; PC3 := ABS(PC3) ;
01843 --                DEFN := ABS(CON(K,SQ1)) ;
01844 --                IF DEFN = 0
01845 --                THEN LOSSES := LOSSES - VALUES(PC1)
01846 --                               + (IF ID = 0 THEN 0 ELSE VALUES(PCA))
01847 --                ELSE IF VALUES(PC1) > VALUES(PC3) - DELTA
01848 --                     THEN LOSSES := LOSSES - VALUES(PC1) + VALUES(PC3) ;
01849 -8              END ;
01850 -7            END ;
01851 -6          END ;
01852 -5        END ;
01853 -4      END ;
01854 -3    END ;
01855 --    IF PAWNS(SQ) = 0 AND IA <= ID AND MINPIECE < VALUES(KNIGHT)
01856 --    THEN LOSSES := LOSSES - VALUES(BISHOP) ;
01857 --    SACRIFICE := IF (LOSSES > -PVAL)
01858 --                 THEN TRUE
01859 --                 ELSE FALSE ;
01860 --    IF (DEBUG)  AND (PRINT) AND (IA > 0)
01861 3-    THEN BEGIN
01862 --      IF SACRIFICE OR (ID ~= 0)
01863 --      THEN WRITE(COLOR(KK), " SACR", IA, MINATTACK, MAXATTACK, ATTACKERS(0),
01864 --                 SQ, BRD(SQ), IX, HID, WEAKPIN, MAXPIECE, MINPIECE, ID, COST, LOSSES) ;
01865 --      IF (POWER(0) ~= SQR(0)) OR (ATTACKERS(0) ~= ATTASQRS(0))
01866 --               OR LOSSES ~= COST
01867 4-      THEN BEGIN
01868 --        IA := IF (SQR(0) > ATTASQRS(0))
01869 --              THEN SQR(0)
01870 --              ELSE ATTASQRS(0) ;
01871 --        WRITE("HIDDEN A/D ON", SQ, LOST) ;
01872 --        FOR I := 0 UNTIL IA
01873 --        DO WRITE(SQR(I), POWER(I), ATTASQRS(I), ATTACKERS(I)) ;
01874 --        FOR I := SEC(-1,SQ) UNTIL SEC(1,SQ)
01875 --        DO WRITEON(SECRET(SQ,I)) ;
01876 -4      END ;
01877 -3    END ;
01878 --    IF ABS(LOSSES) < DELTA
01879 --    THEN LOSSES := 0 ;
01880 --    SACRIFICE
01881 -2  END OF_SACRIFICE ;
01882 --  
01883 --  PROCEDURE XRAY (INTEGER VALUE SQL, KK ; INTEGER VALUE RESULT NN, NT) ;
01884 --    COMMENT this procedure determines whether the piece (pc) on square
01885 --            sq is pinned against a major piece, and therefore cannot control
01886 --            sql. if it is, a check is made to see if the pinning piece (pca)
01887 --            is attacked by pc.  compromise, really want to know if pca can
01888 --            be captured by any piece. questionable pin if pca attacks sql ;
01889 --    COMMENT SQ colour KK, SQA color -KK, SQH color KK, SQL color JK ;
01890 2-  BEGIN
01891 --    INTEGER SQA, PCA, PC, SQH, PCH, SQ, I, PIN, SQD, PP, SQ3, VAL_PCL,
01892 --            VAL_PCH, VAL_PCA, JK, J, JJ, TMP, PCC, SQH_DEF, SAVEJ, NEWPIN ;
01893 --    LOGICAL T, PINNED ;
01894 --  
01895 --    I := 1 ;
01896 --    WEAKPIN := 0 ;
01897 --    VAL_PCL := VALUES(ABS(BRD(SQL))) ;
01898 --    JK := IF (BRD(SQL) < 0)
01899 --          THEN -1
01900 --          ELSE 1 ;
01901 --    WHILE (I <= NT)
01902 3-    DO BEGIN
01903 --      SQ := SQR(I) ;
01904 --      IF (SQ < 0)
01905 4-      THEN BEGIN
01906 --        SQR(I) := -SQ ;
01907 --        I := I + 1 ;
01908 -4      END ELSE
01909 4-      BEGIN
01910 --        PINNED := FALSE ;
01911 --        PCC := BRD(SQ) ;
01912 --        PC := ABS(PCC) ;
01913 --        SAVEJ := 0 ;
01914 --        PIN := -FIVES ;
01915 --        FOR J := CON(-KK,SQ) STEP KK UNTIL -KK
01916 5-        DO BEGIN
01917 --          SQA := CONTROL(SQ,J) ;
01918 --          PCA := ABS(BRD(SQA)) ;
01919 --                        COMMENT a piece (on SQL) under attack cannot pin another ;
01920 --          IF (PCA >= BISHOP) AND (PCA <= QUEEN) AND (SQL ~= SQA)
01921 6-          THEN BEGIN
01922 --            T := HIDDEN(SQA, SQ, SQH, -KK, FALSE) ;
01923 --            IF SQH ~= HOLE
01924 7-            THEN BEGIN
01925 --              PCH := KK*BRD(SQH) ;
01926 --              SQH_DEF := CON(KK,SQH) ;
01927 --              VAL_PCA := VALUES(PCA) ;
01928 --              VAL_PCH := VALUES(ABS(PCH)) ;
01929 --              IF (PCH > 0) AND (VAL_PCH > VAL_PCA OR SQH_DEF = 0
01930 --                  OR SEC(0,SQH)*KK < 0
01931 --                     AND BOTV(ABS(PCH), OFFSET(SQL)-OFFSET(SQH)) ~= 1)
01932 8-              THEN BEGIN
01933 --                      COMMENT PC is potentially pinned, can it capture PCA ;
01934 --                PINNED := TRUE ;
01935 --                FOR JJ := CON(KK,SQA) STEP -KK UNTIL KK
01936 9-                DO BEGIN
01937 --                      COMMENT can pca be exchanged for a piece of nearly
01938 --                                   equal value? ;
01939 --                      COMMENT are sqa and sql the same, and being attacked by the
01940 --                                   "pinned" piece? ;
01941 --                  SQD := CONTROL(SQA,JJ) ;
01942 --                  IF (SQ ~= SQD) AND PCC*K < 0
01943 --                     AND (ABS(VAL_PCA - VALUES(ABS(BRD(SQD)))) < DELTA)
01944 --                  THEN PINNED := FALSE ;
01945 -9                END ;
01946 --                           COMMENT does pinning piece (pca) attack sql? ;
01947 --                IF PINNED
01948 9-                THEN BEGIN
01949 --                  JJ := CON(-JK,SQL) ;
01950 --                  IF DEBUG
01951 --                  THEN WRITE("PIN ON", SQ, SQA, SQL, SQH, KK, JK, CON(JK,SQL),
01952 --                              JJ, CONTROL(SQL,JJ), SQH_DEF) ;
01953 --                  IF KK = JK
01954 --                  THEN IF (ABS(JJ) = 1) AND (SQA = CONTROL(SQL,JJ))
01955 --                       THEN PINNED := FALSE
01956 --                       ELSE IF ABS(SQH) ~= KING
01957 --                            THEN FOR JJ := JJ STEP JK UNTIL -JK
01958 --                                 DO IF (SQA = CONTROL(SQL,JJ))
01959 --                                    THEN IF VAL_PCL - VALUES(PC)
01960 --                                          +(IF ABS(CON(JK,SQL)) > 1
01961 --                                            THEN VAL_PCA
01962 --                                            ELSE 0) > -VAL_PCH + (IF SQH_DEF ~= 0
01963 --                                                                  THEN VAL_PCA
01964 --                                                                  ELSE 0) + DELTA
01965 --                                         THEN PINNED := FALSE ;
01966 --                  IF DEBUG
01967 --                  THEN WRITEON(PINNED) ;
01968 -9                END ;
01969 -8              END ;
01970 --              IF PCH = KING AND PINNED
01971 --              THEN GO TO QUIT ;
01972 --              NEWPIN := VAL_PCH ;
01973 --              IF SQH_DEF > 1 OR SQH_DEF = 1 AND SQ ~= CONTROL(SQH,KK)
01974 --              THEN NEWPIN := NEWPIN - VAL_PCA ;
01975 --              IF PIN < NEWPIN
01976 8-              THEN BEGIN
01977 --                PIN := NEWPIN ;
01978 --                SAVEJ := J ;
01979 -8              END ;
01980 --              IF DEBUG
01981 --              THEN WRITE("PINS", PIN, NEWPIN, SAVEJ, J, SQA, SQH) ;
01982 -7            END ;
01983 -6          END ;
01984 -5        END ;
01985 --  QUIT:
01986 --        IF ~ PINNED
01987 --        THEN I := I + 1
01988 5-        ELSE BEGIN
01989 --          IF (PCH ~= KING)
01990 --          THEN PINNED := FALSE ;
01991 --          IF ~PINNED
01992 6-          THEN BEGIN
01993 --            SQA := CONTROL(SQ,SAVEJ) ;
01994 --            PCA := ABS(BRD(SQA)) ;
01995 --            PCH := KK*BRD(SQH) ;
01996 --            SQH_DEF := CON(KK,SQH) ;
01997 --            VAL_PCA := VALUES(PCA) ;
01998 --            VAL_PCH := VALUES(ABS(PCH)) ;
01999 -6          END ;
02000 --          PIN := VAL_PCH ;
02001 --          IF ~PINNED
02002 6-          THEN BEGIN
02003 --            IF SQH_DEF > 1 OR SQH_DEF = 1 AND SQ ~= CONTROL(SQH,KK)
02004 --            THEN PIN := PIN - VAL_PCA ;
02005 --            IF (PIN < DELTA)
02006 --            THEN PIN := 0 ;
02007 --                          COMMENT does PC on SQ give direct check on SQL capture.
02008 --                                  What about discovered check? ;
02009 --            TMP := CHECK_S(KK,SQL) ;
02010 --            IF PCC < 0
02011 --            THEN TMP := -TMP ;
02012 --            WEAKPIN := IF TMP > 0 AND CHEC(TMP, PC)
02013 --                       THEN -1
02014 --                       ELSE PIN ;
02015 --            IF WEAKPIN = -1
02016 --            THEN WEAKPIN := IF CON(-KK,SQA) = 0 AND PCH >= BISHOP
02017 --                                  AND BOTV(PCH, OFFSET(SQH)-OFFSET(SQ)) = 1
02018 --                            THEN -VAL_PCA
02019 --                            ELSE 0 ;
02020 -6          END ;
02021 --                                COMMENT is there perhaps a hidden attack on SQH? ;
02022 --          IF (WEAKPIN = 0) AND (ABS(SQH_DEF) <= ABS(CON(-KK,SQH)) + 1)
02023 --                           AND HIDDEN(SQ, SQA, SQ3, -KK, FALSE)
02024 --          THEN WEAKPIN := VAL_PCL + PVAL ;
02025 --          PP := POWER(I) - POWER(I-1) ;
02026 --          IF DEBUG
02027 --          THEN WRITEON(PIN, PP, POWER(I), TMP, WEAKPIN, PCH, I, NN, NT) ;
02028 --          PIN := PIN + PP ;
02029 --          J := I ;
02030 --          IF WEAKPIN >= 0
02031 --          THEN WHILE (PINNED AND J < NT OR J < NN AND PIN > PP)
02032 6-               DO BEGIN
02033 --                 PP := POWER(J+1) - POWER(J) ;
02034 --                 IF DEBUG
02035 --                 THEN WRITEON(POWER(J), PP) ;
02036 --                 IF PINNED OR PIN > PP
02037 7-                 THEN BEGIN
02038 --                   SQR(J) := SQR(J+1) ;
02039 --                   POWER(J) := POWER(J-1) + PP ;
02040 --                   J := J + 1 ;
02041 -7                 END ELSE POWER(J) := POWER(J-1) + VALUES(PC) ;
02042 -6          END ;
02043 --          IF I = 1 AND J > 1
02044 --          THEN MINPIECE := POWER(1) ;
02045 --          SQR(J) := -SQ ;
02046 --          IF KK ~= JK AND (PINNED AND NN > ABS(CON(JK,SQL)) OR WEAKPIN < 0)
02047 --          THEN FOR II := CON(JK,SQL) STEP -JK UNTIL JK
02048 --               DO IF SQA = CONTROL(SQL,II)
02049 6-                  THEN BEGIN
02050 --                    PINNED := FALSE ;
02051 --                    IF WEAKPIN < 0
02052 --                    THEN WEAKPIN := -VAL_PCL + VALUES(PC)
02053 --                                             - (IF ABS(CON(-JK,SQL)) > 1
02054 --                                                THEN VAL_PCA
02055 --                                                ELSE 1) ;
02056 -6               END ;
02057 --          FOR L := J UNTIL NT
02058 --          DO POWER(L) := POWER(L) + WEAKPIN ;
02059 --          IF DEBUG
02060 --          THEN WRITEON(PIN, PP, PINNED, I, J, POWER(J)) ;
02061 --          IF PINNED
02062 6-          THEN BEGIN
02063 --            NT := NT - 1 ;
02064 --            IF (I <= NN)
02065 --            THEN NN := NN - 1 ;
02066 --                        COMMENT does the pinned piece stop a hidden attack ;
02067 --            IF (NT > NN)
02068 --            THEN IF HIDDEN(SQL, SQ, SQH, (IF PCC > 1
02069 --                                          THEN -1
02070 --                                          ELSE 1), FALSE)
02071 --            THEN FOR J := NN+1 UNTIL NT
02072 --                 DO IF (SQH = SQR(J))
02073 7-                    THEN BEGIN
02074 --                      SQR(J) := SQR(NT) ;
02075 --                      NT := NT - 1 ;
02076 -7                 END ;
02077 -6          END ;
02078 -5        END ;
02079 -4      END ;
02080 -3    END ;
02081 --             COMMENT this whole problem should be treated recursively, passing
02082 --                     SQR and POWER as parameters.  Note also that in general the
02083 --                     value of PIN, the incremental cost of moving a pinned piece,
02084 --                     is overestimated ;
02085 -2  END OF_XRAY ;
02086 --  
02087 --  PROCEDURE DELETE (INTEGER VALUE SQF, SQT, KK) ;
02088 2-  BEGIN
02089 --    INTEGER T ;
02090 --  
02091 --    T := CON(KK,SQT) ;
02092 --    FOR L := T STEP -KK UNTIL KK
02093 --    DO IF (SQF = CONTROL(SQT,L))
02094 3-       THEN BEGIN
02095 --         CONTROL(SQT,L) := CONTROL(SQT,T) ;
02096 --         CON(KK,SQT) := T - KK ;
02097 --         SEC(0,SQT) := CON(0,SQT) := CON(0,SQT) -KK ;
02098 --         GO TO NEXT ;
02099 -3    END ;
02100 --  NEXT:
02101 -2  END OF_DELETE ;
02102 --  
02103 --  INTEGER PROCEDURE DOUBLE (INTEGER VALUE SQ, DIR, K) ;
02104 2-  BEGIN
02105 --    INTEGER C, Q, R, S, P ;
02106 --  
02107 --    C := P := 0 ;
02108 --    Q := K*QUEEN ;
02109 --    R := K*ROOK ;
02110 --    FOR I := DIR, -DIR
02111 3-    DO BEGIN
02112 --      S := SQ + I ;
02113 --      WHILE BRD(S) = 0
02114 --      DO S := S + I ;
02115 --      IF BRD(S) = Q OR BRD(S) = R
02116 --      THEN C := C + 1 ;
02117 --      WHILE BRD(S) ~= EDGE
02118 4-      DO BEGIN
02119 --        IF ABS(BRD(S)) = PAWN
02120 --        THEN P := P + 1 ;
02121 --        S := S + I ;
02122 -4      END ;
02123 -3    END ;
02124 --    IF P > 1 THEN C := 0 ;
02125 --    C
02126 -2  END OF_DOUBLE ;
02127 --  
02128 --  LOGICAL PROCEDURE DRAWS (INTEGER VALUE K) ;
02129 2-  BEGIN
02130 --    IF TEST
02131 --    THEN WRITE ("DRAWS ", K, MEN(1), MEN(-1)) ;
02132 --                    COMMENT does K have a mating force? ;
02133 --    MEN(K) = 1 OR MEN(K) = 2 AND PIECES(3*K) + PIECES(4*K) = 1
02134 -2  END OF_DRAWS ;
02135 --  
02136 --  PROCEDURE MATE_THREAT ;
02137 2-  BEGIN
02138 --    INTEGER T, TT, II, SQA, PC, SQ_K ;
02139 --                       COMMENT back rank mate threat ;
02140 --    MATE_T(1) := MATE_T(-1) := BACKROW := 0 ;
02141 --    FOR KK := 1, -1
02142 --    DO IF (PIECES(KK*QUEEN) > 0 OR PIECES(KK*ROOK) > 0)
02143 3-    THEN BEGIN
02144 --      SQ_K := KINGSQ(-KK) ;
02145 --      KING_HELD(-KK) := ROWS(SQ_K) = (IF KK = 1 THEN 8 ELSE 1)
02146 --                              AND (POS(SQ_K) = 0 OR POS(SQ_K) = 1
02147 --                                AND ABS(SQ_K-POSITION(SQ_K,1)) = 1
02148 --                             OR POS(SQ_K) = 2
02149 --                                AND ABS(POSITION(SQ_K,1) - POSITION(SQ_K,2)) = 2) ;
02150 --      IF KING_HELD(-KK)
02151 4-      THEN BEGIN
02152 --                      COMMENT King is held on back rank ;
02153 --                      COMMENT look at every square on the back row, identify
02154 --                              those which are not defended, yet are under attack ;
02155 --        II := IF KK = 1
02156 --              THEN BKRSQ - 7
02157 --              ELSE WQRSQ ;
02158 --        TT := 0 ;
02159 --        FOR SQ := II UNTIL II+7
02160 --        DO IF (SQ ~= SQ_K) AND CON(KK,SQ) ~= 0 AND KK*SEC(0,SQ) > 0
02161 5-           THEN BEGIN
02162 --             T := 0 ;
02163 --                          COMMENT How many major pieces bear on the back rank ;
02164 --             FOR J := CON(KK,SQ) STEP -KK UNTIL KK
02165 6-             DO BEGIN
02166 --               SQA := CONTROL(SQ,J) ;
02167 --               PC := ABS(BRD(SQA)) ;
02168 --               IF (ROWS(SQA) ~= ROWS(SQ) OR SQA ~= SQ AND BRD(SQ) ~= 0)
02169 --               THEN IF PC = ROOK OR PC = QUEEN
02170 7-               THEN BEGIN
02171 --                 T := T + 1 ;
02172 --                              COMMENT either 2(R or Q) bearing on back row, or R/Q
02173 --                                      attacker not comeing from 7th rank ;
02174 --                 IF T > ABS(CON(-KK,SQ))
02175 --                       AND (ABS(CON(KK,SQ)) > 1 AND T > 1
02176 --                               OR ABS(ROWS(SQ_K) - ROWS(SQA)) > 1)
02177 --                 THEN TT := TT + (IF CHECK_S(-KK,SQ) ~= 0
02178 --                                  THEN 6
02179 --                                  ELSE IF KK = K AND M3 = SQA
02180 --                                                 AND (COLS(BASE) ~= COLS(SQ))
02181 --                                       THEN 3
02182 --                                       ELSE T) ;
02183 -7               END ;
02184 -6             END ;
02185 -5        END ;
02186 --                          COMMENT does a back rank mate threat exist,
02187 --                                   or are we moving to the 7th rank? ;
02188 --         IF TT > 0
02189 --         THEN MATE_T(KK) := MATE_T(KK) + (IF KK = K
02190 --                                          THEN 1
02191 --                                          ELSE -1)* (IF TT < 10
02192 --                                                     THEN TT
02193 --                                                     ELSE IF TT < 15
02194 --                                                          THEN TT - 2
02195 --                                                          ELSE TT - 6)
02196 --          ELSE IF (K = KK) AND (M4 = ROOK OR M4 = QUEEN)
02197 --                           AND (ROWS(BASE) ~= ROWS(M3))
02198 --                           AND ABS(ROWS(M3) -ROWS(SQ_K)) = 1
02199 --               THEN MATE_T(K) := MATE_T(K) + 1 ;
02200 -4      END ;
02201 -3    END ;
02202 --                          COMMENT reduce mate conter threat if giving check ;
02203 --    IF GIVINGCH THEN MATE_T(-K) := MATE_T(-K) DIV 2 ;
02204 --    BACKROW := MATE_T(-1) + MATE_T(1) ;
02205 --    IF ~OPENING AND BACKROW < 0 AND LEVEL >= LENGTH
02206 --    THEN BACKROW := BACKROW - 3 ;
02207 --                       COMMENT discourage terminal moves with mate threats ;
02208 -2  END OF_MATE_THREAT ;
02209 --  
02210 --  COMMENT ****************fixit***************** ;
02211 --  
02212 --  PROCEDURE FIXIT (INTEGER VALUE SQF, SQT, KK) ;
02213 2-  BEGIN
02214 --    INTEGER M ;
02215 --    M := CON(KK,SQT) + KK ;
02216 --    CON(KK,SQT) := M ;
02217 --    CONTROL(SQT,M) := SQF ;
02218 --    SEC(0,SQT) := CON(0,SQT) := CON(0,SQT) + KK ;
02219 -2  END OF_FIXIT ;
02220 --  
02221 --  LOGICAL PROCEDURE HIDDEN (INTEGER VALUE SQ1, SQ2 ; INTEGER RESULT SQ3 ;
02222 --                           INTEGER VALUE KK ; LOGICAL VALUE PATH) ;
02223 --    COMMENT hidden true if sq3 contains q, r or b of colour kk. ;
02224 --    COMMENT if no hidden piece then sq3 := hole ;
02225 2-  BEGIN
02226 --    LOGICAL HIDDEN ;
02227 --    INTEGER SQ, PC ;
02228 --  
02229 --    SQ3 := HOLE ;
02230 --    HIDDEN := FALSE ;
02231 --    DIR := BOTV(EDGE, OFFSET(SQ1)-OFFSET(SQ2)) ;
02232 --    IF DIR = 0
02233 3-    THEN BEGIN
02234 --      DIR := SQ2 - SQ1 ;
02235 --      GOTO QUIT ;
02236 -3    END ;
02237 --    IF PATH AND SQ1 + DIR ~= SQ2
02238 --    THEN FOR SQ := SQ1+DIR STEP DIR UNTIL SQ2-DIR
02239 --         DO IF BRD(SQ) ~= 0
02240 --            THEN GO TO QUIT ;
02241 --    SQ := SQ2 + DIR ;
02242 --    WHILE ((BRD(SQ) = EMPTY)  or (abs(BRD(SQ)) = ENPRIS))
02243 --    DO SQ := SQ + DIR ;
02244 --    IF (BRD(SQ) = EDGE)
02245 --    THEN GO TO QUIT ;
02246 --    SQ3 := SQ ;
02247 --    PC := IF (KK = 0)
02248 --          THEN ABS(BRD(SQ))
02249 --          ELSE KK*BRD(SQ) ;
02250 --    IF PC = QUEEN OR (PC = ROOK OR PC = BISHOP)
02251 --                AND BOTV(PC, OFFSET(SQ3)-OFFSET(SQ2)) = 1
02252 --    THEN HIDDEN := TRUE ;
02253 --  QUIT:
02254 --    HIDDEN
02255 -2  END OF_HIDDEN ;
02256 --  
02257 --  PROCEDURE HIDDENATTACK ;
02258 2-  BEGIN
02259 --    INTEGER PC, I, SQ2, SQ3, L2 ;
02260 --    LOGICAL T ;
02261 --  
02262 --    L2 := LOSS(ELIMIT) ;
02263 --    FOR I := POSITION(M3,LIM) UNTIL LIM-1
02264 3-    DO BEGIN
02265 --      SQ2 := POSITION(M3,I) ;
02266 --      T := HIDDEN(M3, SQ2, SQ3, 0, FALSE) ;
02267 --      IF SQ3 ~= HOLE AND (K*BRD(SQ3) < 0)
02268 4-      THEN BEGIN
02269 --                 COMMENT Q-Q, B-B, R-R ;
02270 --                 COMMENT case of Q or B inline with a P is already handled
02271 --                         by existing mechanism in MAKEFINAL, since a non-losing
02272 --                         exchange occurs ;
02273 --        PC := ABS(BRD(SQ2)) ;
02274 --        IF (M4 = PC) OR (((M4 = BISHOP) OR (M4 = ROOK)) AND (PC = QUEEN))
02275 --            OR M4 = QUEEN AND (PC =ROOK OR PC = BISHOP)
02276 --            AND BOTV(PC,OFFSET(SQ2) -OFFSET(M3)) = 1
02277 5-        THEN BEGIN
02278 --          L2 := L2 - 1 ;
02279 --          SQUARE(L2) := SQ3 ;
02280 -5        END ;
02281 -4      END ;
02282 -3    END ;
02283 --    LOSS(ELIMIT) := L2 ;
02284 --      comment search for hidden attack ;
02285 -2  END OF_HIDDENATTACK ;
02286 --  
02287 --  PROCEDURE KINGCONTROL (INTEGER VALUE K) ;
02288 2-  BEGIN
02289 --    INTEGER J, KSQ, SQ ;
02290 --  
02291 --    J := 0 ;
02292 --    KSQ := KINGSQ(K) ;
02293 --    FOR I := -LDIAG, -FILE, -RDIAG, -RANK, LDIAG, FILE, RDIAG, RANK
02294 3-    DO BEGIN
02295 --      SQ := KSQ + I ;
02296 --      IF (BRD(SQ) ~= EDGE)
02297 4-      THEN BEGIN
02298 --        J := J + K ;
02299 --        KSQRS(J) := SQ ;
02300 -4      END ;
02301 -3    END ;
02302 --    K_SQRS(K) := J ;
02303 -2  END OF_KINGCONTROL ;
02304 --  
02305 --  PROCEDURE KINGSMOVE (INTEGER VALUE HOME, K) ;
02306 2-  BEGIN
02307 --    INTEGER ONE, M6, SQ, TWO ;
02308 --  
02309 --    ONE := TWO := 0 ;
02310 --    FOR M := CON(-K,HOME) STEP K UNTIL -K
02311 3-    DO BEGIN
02312 --      SQ := CONTROL(HOME,M) ;
02313 --      IF (ABS(BRD(SQ)) > KNIGHT)
02314 4-      THEN BEGIN
02315 --        DIR := BOTV(EDGE, OFFSET(SQ)-OFFSET(HOME)) ;
02316 --        IF (ONE = 0)
02317 --        THEN ONE := DIR
02318 --        ELSE TWO := DIR ;
02319 -4      END ;
02320 -3    END ;
02321 --    FOR L := LDIAG, FILE, RDIAG, -RANK, RANK, -RDIAG, -FILE, -LDIAG
02322 3-    DO BEGIN
02323 --      SQ := HOME + L ;
02324 --      IF (BRD(SQ) ~= EDGE)
02325 4-      THEN BEGIN
02326 --        M6 := K*BRD(SQ) ;
02327 --        IF (M6 = -ENPRIS)
02328 --        THEN M6 := NIL ;
02329 --        IF (M6 > NIL) OR (CON(-K,SQ) ~= 0) OR (L = ONE) OR (L = TWO)
02330 --        THEN INDEX := SLIST := SLIST - 1
02331 --        ELSE INDEX := CLIST := CLIST + 1 ;
02332 --        CHECKLIST(INDEX) := SQ ;
02333 --            COMMENT Note difficulties with the King:  It can move
02334 --                    to squares it does not control, castling. It can attack
02335 --                    squares to which it cannot move, those defended by opponent.
02336 --                    In the latter case that square is added to the defence list. ;
02337 -4      END ;
02338 -3    END ;
02339 -2  END OF_KINGSMOVE ;
02340 --  
02341 --  PROCEDURE LISTKINGMOVES (INTEGER VALUE SQ, K) ;
02342 2-  BEGIN
02343 --    INTEGER KSQ ;
02344 --  
02345 --    KINGSMOVE(SQ, K) ;
02346 --    KLIST := CLIST ;
02347 --    KSQ := IF (K > 0)
02348 --           THEN 15
02349 --           ELSE 85 ;
02350 --    IF (SQ = KSQ) AND (CON(-K,KSQ) = 0)
02351 3-    THEN BEGIN
02352 --      IF CASTLE(K) AND (BRD(2+KSQ) = EMPTY) AND (BRD(1+KSQ) = EMPTY)
02353 --        AND K*BRD(KSQ+3) = ROOK
02354 --      THEN IF CON(-K,1+KSQ) = 0
02355 --           THEN IF CON(-K,2+KSQ) = 0
02356 4-                THEN BEGIN
02357 --                  CLIST := CLIST + 1 ;
02358 --                  CHECKLIST(CLIST) := 2 + KSQ ;
02359 -4      END ;
02360 --      IF CASTLE(TWO(K)) AND (BRD(KSQ-3) = EMPTY) AND (BRD(KSQ-2) = EMPTY)
02361 --                        AND (BRD(KSQ-1) = EMPTY) AND K*BRD(KSQ-4) = ROOK
02362 --      THEN IF CON(-K,KSQ-1) = 0
02363 --           THEN IF CON(-K,KSQ-2) = 0
02364 4-                THEN BEGIN
02365 --                  CLIST := CLIST + 1 ;
02366 --                  CHECKLIST(CLIST) := KSQ - 2 ;
02367 -4      END ;
02368 -3    END ;
02369 --                       COMMENT   order important ;
02370 -2  END OF_LISTKINGMOVES ;
02371 --  
02372 --  PROCEDURE LISTMOVES ;
02373 --    COMMENT all moves are listed including some which keep own king
02374 --            in check ;
02375 2-  BEGIN
02376 --    INTEGER M, PC, N, SQ, R, II, LL, RR, TMP ;
02377 --  
02378 --    ENPRISE (K) ;
02379 --    N := 0 ;
02380 --    LL := 0 ;
02381 --    RR := TOTAL + 1 ;
02382 --    FOR J := (IF K = 1
02383 --              THEN WQRSQ
02384 --              ELSE BKRSQ - 7) STEP FILES(K) UNTIL (IF K = 1
02385 --                                                   THEN BKRSQ
02386 --                                                   ELSE WQRSQ)
02387 --    DO FOR I := J UNTIL J+7
02388 --    DO IF (K*BRD(I) > 0)
02389 3-       THEN BEGIN
02390 --         M := POS(I) ;
02391 --         PC := ABS(BRD(I)) ;
02392 --         IF (PC ~= ENPRIS)
02393 --         THEN FOR L := 1 UNTIL M
02394 4-              DO BEGIN
02395 --                SQ := POSITION(I,L) ;
02396 --                IF (PC ~= PAWN) OR (PAWNS(SQ) ~= 0)
02397 5-                THEN BEGIN
02398 --                  N := N + K ;
02399 --                  QUIES(N) := FALSE ;
02400 --                  SCORE(N) := NOSCR ;
02401 --                  MOVEFROM(N) := I ;
02402 --                  MOVETO(N) := SQ ;
02403 --                  R := ABS(BRD(SQ)) ;
02404 --                  REWARD(N) := IF (PC = PAWN)
02405 --                               THEN IF (ABS(I - SQ) = TWOROWS)
02406 --                                    THEN PFTWO
02407 --                                    ELSE R
02408 --                                    ELSE IF (R = ENPRIS)
02409 --                     THEN 0
02410 --                     ELSE IF (PC = KING)
02411 --                          THEN IF (ABS(SQ - I) = 2)
02412 --                               THEN IF (I > SQ)
02413 --                                    THEN QSIDE
02414 --                                    ELSE KSIDE
02415 --                               ELSE R
02416 --                          ELSE R ;
02417 --                  IF R ~= 0
02418 --                  THEN II := RR := RR - 1
02419 6-                  ELSE BEGIN
02420 --                    TMP := K*CHECK_S(-K,SQ) ;
02421 --                    IF TMP > 0 AND CHEC(TMP,PC)
02422 --                    THEN II := RR := RR - 1
02423 --                    ELSE II := LL := LL + 1 ;
02424 -6                  END ;
02425 --                  USE(II) := N ;
02426 -5                END ELSE FOR L := 1 UNTIL 4
02427 5-                         DO BEGIN
02428 --                           N := N + K ;
02429 --                           RR := RR - 1 ;
02430 --                           USE(RR) := N ;
02431 --                           REWARD(N) := PROMOTE + (CASE L OF
02432 --                                                   (QUEEN, KNIGHT, ROOK, BISHOP)) ;
02433 --                           MOVEFROM(N) := I ;
02434 --                           MOVETO(N) := SQ ;
02435 --                           SCORE(N) := NOSCR ;
02436 -5                END ;
02437 -4         END ;
02438 -3    END ;
02439 --    NUMBER(K) := N ;
02440 --    NUM := ABS(N) ;
02441 --    LL := LL + 1 ;
02442 --    FOR I := RR UNTIL TOTAL
02443 --    DO USE(LL+I-RR) := USE(I) ;
02444 --    USE(0) := 0 ;
02445 --    IF NUM > 77
02446 3-    THEN BEGIN
02447 --      WRITE("#MOVES =", N, LEVEL) ;
02448 --      PUNCHBRD(TRUE, HISTORY) ;
02449 --      WRITE(HISTORY(0|114)) ;
02450 -3    END ;
02451 -2  END OF_LISTMOVES ;
02452 --  
02453 --  PROCEDURE LISTPAWNMOVES (INTEGER VALUE HOME, K) ;
02454 2-  BEGIN
02455 --    INTEGER INDEX, MOVE, PC, I ;
02456 --  
02457 --    I := HOME ;
02458 --                       COMMENT  enpassant handled by move r. & move l ;
02459 --                       COMMENT right-side capture? ;
02460 --    FOR J := RDIAG, LDIAG
02461 3-    DO BEGIN
02462 --      MOVE := I + J*K ;
02463 --      PC := BRD(MOVE) ;
02464 --      IF (PC ~= EDGE)
02465 4-      THEN BEGIN
02466 --        IF (K*PC < EMPTY)
02467 --        THEN INDEX := CLIST := CLIST + 1
02468 --        ELSE INDEX := SLIST := SLIST - 1 ;
02469 --        CHECKLIST(INDEX) := MOVE ;
02470 -4      END ;
02471 -3    END ;
02472 --                       COMMENT left-side capture? ;
02473 --    KLIST := CLIST ;
02474 --    MOVE := I + FILES(K) ;
02475 --    IF (BRD(MOVE) = EMPTY)
02476 3-    THEN BEGIN
02477 --      IF (ABS(PAWNS(HOME)) = 1)
02478 --                  COMMENT is pawn on second rank? ;
02479 4-      THEN BEGIN
02480 --         I := MOVE + FILES(K) ;
02481 --         IF BRD(I) = EMPTY
02482 5-         THEN BEGIN
02483 --           CLIST := CLIST + 1 ;
02484 --           CHECKLIST(CLIST) := I ;
02485 -5         END ;
02486 -4      END ;
02487 --                    COMMENT increm. move order important ;
02488 --      CLIST := CLIST + 1 ;
02489 --      CHECKLIST(CLIST) := MOVE ;
02490 -3    END PAWNFORWARD ;
02491 -2  END OF_LISTPAWNMOVES ;
02492 --  
02493 --  
02494 --  PROCEDURE LISTQUEENMOVES (INTEGER VALUE HOME, K) ;
02495 2-  BEGIN
02496 --    TRYMINORMOVE(HOME, LDIAG, RDIAG, K) ;
02497 --    TRYMINORMOVE(HOME, FILE, RANK, K) ;
02498 -2  END OF_LISTQUEENMOVES ;
02499 --  
02500 --  PROCEDURE SEEKPAWN (INTEGER VALUE SQ) ;
02501 2-  BEGIN
02502 --    INTEGER SQP, PC ;
02503 --  
02504 --    IF (SQ > 30)
02505 3-    THEN BEGIN
02506 --      SQP := SQ - FILE ;
02507 --      PC := BRD(SQP) ;
02508 --      IF (PC = PAWN)
02509 --      THEN REMAKE(SQP, SQ)
02510 --      ELSE IF (PC = NIL) AND (ROWS(SQ) = 4)
02511 --           THEN IF (BRD(SQP - FILE) = PAWN)
02512 --                THEN REMAKE(SQP-FILE, SQ) ;
02513 -3    END ;
02514 --    IF (SQ < 70)
02515 3-    THEN BEGIN
02516 --      SQP := SQ + FILE ;
02517 --      PC := BRD(SQP) ;
02518 --      IF (PC = -PAWN)
02519 --      THEN REMAKE(SQP, SQ)
02520 --      ELSE IF (PC = NIL) AND (ROWS(SQ) = 5)
02521 --           THEN IF (BRD(SQP+FILE) = -PAWN)
02522 --                THEN REMAKE(SQP+FILE, SQ) ;
02523 -3    END ;
02524 -2  END OF_SEEKPAWN ;
02525 --  
02526 --  PROCEDURE TRYKNIGHTMOVE (INTEGER VALUE HOME, K) ;
02527 2-  BEGIN
02528 --    INTEGER M6 ;
02529 --  
02530 --    FOR I := 1 UNTIL 8
02531 3-    DO BEGIN
02532 --      M6 := BRD(HOME+S(I)) ;
02533 --      IF M6 = EDGE
02534 --      THEN GO TO QUIT ;
02535 --      M6 := K * M6 ;
02536 --      IF (ABS(M6) = ENPRIS)
02537 --      THEN M6 := NIL ;
02538 --      IF (M6 <= NIL)
02539 --      THEN INDEX := CLIST := CLIST + 1
02540 --      ELSE INDEX := SLIST := SLIST - 1 ;
02541 --      CHECKLIST(INDEX) := HOME + S(I) ;
02542 --  QUIT:
02543 -3    END ;
02544 -2  END OF_TRYKNIGHTMOVE ;
02545 --  
02546 --  PROCEDURE TRYMINORMOVE (INTEGER VALUE HOME, LEFT, RIGHT, K) ;
02547 2-  BEGIN
02548 --    INTEGER M6, H ;
02549 --  
02550 --    FOR D := LEFT, RIGHT, -LEFT, -RIGHT
02551 3-    DO BEGIN
02552 --      H := HOME ;
02553 --      M6 := 0 ;
02554 --      WHILE (M6 = 0)
02555 4-      DO BEGIN
02556 --        H := H + D ;
02557 --        M6 := BRD(H) ;
02558 --        IF (M6 ~= EDGE)
02559 5-        THEN BEGIN
02560 --          M6 := K*M6 ;
02561 --          IF (ABS(M6) = ENPRIS)
02562 --          THEN M6 := 0 ;
02563 --          IF (M6 <= 0)
02564 --          THEN INDEX := CLIST := CLIST + 1
02565 --          ELSE INDEX := SLIST := SLIST - 1 ;
02566 --          CHECKLIST(INDEX) := H ;
02567 -5        END ;
02568 -4      END WHILELOOP ;
02569 -3    END ;
02570 -2  END OF_TRYMINORMOVE ;
02571 --  
02572 --  PROCEDURE UNMAKE (INTEGER VALUE SQ) ;
02573 2-  BEGIN
02574 --    INTEGER I, KK, T, J, PC ;
02575 --      COMMENT CAPTURE_CH(SQ) := FALSE ;
02576 --    PC := BRD(SQ) ;
02577 --      COMMENT IF DEBUG THEN WRITE("UNM", SQ, PC) ;
02578 --  if sq < 11 or sq > 88 
02579 --  then write ("unmake error sq/pc", sq, pc) else
02580 --    IF (PC ~= 0)
02581 3-    THEN BEGIN
02582 --      KK := IF (PC > 0)
02583 --            THEN 1
02584 --            ELSE -1 ;
02585 --      FOR J := 1 UNTIL POSITION(SQ,0)
02586 --        DO DELETE(SQ, POSITION(SQ,J), KK) ;
02587 --      FOR J := POSITION(SQ,LIM) UNTIL LIM-1
02588 --        DO DELETE(SQ, POSITION(SQ,J), KK) ;
02589 --      POS(SQ) := POSITION(SQ,0) := 0 ;
02590 --      POSITION(SQ,LIM) := LIM ;
02591 --      BRD(SQ) := EMPTY ;
02592 --      SEEKPAWN(SQ) ;
02593 -3    END ;
02594 -2  END OF_UNMAKE ;
02595 --  
02596 --  INTEGER PROCEDURE OPENFILE (INTEGER VALUE SQ) ;
02597 2-  BEGIN
02598 --    INTEGER L, OPEN, PC, PCD ;
02599 --    LOGICAL FEAR ;
02600 --          COMMENT compute credit for playing Rooks on open or semi- open
02601 --                  files.  Treat semi-open files with advanced pawn as open file ;
02602 --          COMMENT PC is a Rook or a Queen ;
02603 --    OPEN := 2 ;
02604 --    PC := BRD(SQ) ;
02605 --    FEAR := FALSE ;
02606 --    FOR J := FILE, -FILE
02607 3-    DO BEGIN
02608 --      L := IF (J < 0)
02609 --           THEN WQRSQ
02610 --           ELSE BKRSQ ;
02611 --      FOR I := SQ+J STEP J UNTIL L
02612 4-      DO BEGIN
02613 --                    COMMENT do not count half open file with R/Q behind
02614 --                            a back pawn. Note PC*J > 0 when forward direction ;
02615 --        PCD := BRD(I) ;
02616 --        IF ABS(PCD) = PAWN
02617 5-        THEN BEGIN
02618 --          IF PC*PCD < 0 OR PC*J < 0 OR RANKS(ROWS(I))*PCD > 1
02619 --          THEN OPEN := OPEN - 1
02620 --          ELSE OPEN := OPEN - 2 ;
02621 -5        END
02622 --        ELSE IF ABS(PCD) ~= QUEEN AND ABS(PCD) ~= ROOK AND PCD*PC > 0
02623 --                AND PAWNS(I) ~= 0
02624 --             THEN FEAR := TRUE ;
02625 -4      END ;
02626 -3    END ;
02627 --                      COMMENT do not put R/Q on same open file as a minor piece
02628 --                              for fear of a pin ;
02629 --    IF FEAR AND OPEN = 2
02630 --    THEN OPEN := 1 ;
02631 --    IF (OPEN < 0)
02632 --    THEN 0
02633 --    ELSE OPEN
02634 -2  END OF_OPENFILE ;
02635 --  
02636 --  INTEGER PROCEDURE BACKPAWN (INTEGER VALUE SQ, D, PC) ;
02637 2-  BEGIN
02638 --    INTEGER B, L ;
02639 --  
02640 --    B := 1 ;
02641 --    L := IF (D > 0)
02642 --         THEN BKRSQ
02643 --         ELSE WQRSQ ;
02644 --    FOR K := -1, 1
02645 --    DO FOR J := SQ + K STEP D UNTIL L
02646 --    DO IF (BRD(J) = PC)
02647 --       THEN B := B - 1 ;
02648 --    B
02649 -2  END OF_BACKPAWN ;
02650 --  
02651 --  INTEGER PROCEDURE POTENTIAL (INTEGER VALUE SQ1, SQ2 ; LOGICAL VALUE PASS) ;
02652 2-  BEGIN
02653 --    INTEGER I, J, C ;
02654 --  
02655 --    IF PASS AND ENDGAME
02656 --    THEN C := BOTV((IF K < 0
02657 --                    THEN 1
02658 --                    ELSE 2), OFFSET(SQ1)-OFFSET(SQ2))
02659 3-    ELSE BEGIN
02660 --      I := ABS(COLS(SQ1) - COLS(SQ2)) ;
02661 --      J := ABS(ROWS(SQ1) - ROWS(SQ2)) ;
02662 --      C := IF ENDGAME
02663 --           THEN FAR(I,J)
02664 --           ELSE NEAR(I,J)
02665 -3    END ;
02666 --    IF C < 0
02667 --    THEN WRITE("POTEN", K, SQ1, SQ2, C, PASS) ;
02668 --    C
02669 -2  END OF_POTENTIAL ;
02670 --  
02671 --  INTEGER PROCEDURE PP_BLOCK (INTEGER VALUE SQ, INC) ;
02672 2-  BEGIN
02673 --    INTEGER J, L, V, PC ;
02674 --      COMMENT are opponent passed pawns blocked ;
02675 --    V := 0 ;
02676 3-  if SQ < 81 and INC > 0 or SQ > 18 and INC < 0 then begin
02677 --    L := K*SEC(0,SQ+INC) ;
02678 --    IF DEBUG
02679 --    THEN WRITE("PP_BL", SQ, BRD(SQ), L) ;
02680 --    FOR I := INC, -INC
02681 4-    DO BEGIN
02682 --      J := SQ + I ;
02683 --      WHILE BRD(J) = 0
02684 --      DO J := J + I ;
02685 --      PC := K*BRD(J) ;
02686 --                    COMMENT is there a R or Q on the file of the pp ;
02687 --      IF ABS(PC) = ROOK OR ABS(PC) = QUEEN
02688 5-      THEN BEGIN
02689 --                    COMMENT piece is behind, so change control value on
02690 --                            the square in front of the pp ;
02691 --        IF I = -INC
02692 --        THEN L := L + (IF PC > 0
02693 --                       THEN 1
02694 --                       ELSE -1) ;
02695 --                    COMMENT if or R/Q on the file is not attacked
02696 --                            then increment V ;
02697 --        IF PC > 0
02698 --        THEN IF CON(-K,J) = 0
02699 --             THEN V := V + (IF K > 0
02700 --                            THEN ROWS(SQ)
02701 --                            ELSE 9 - ROWS(SQ)) DIV 2
02702 --             ELSE IF K*SEC(0,J) >= 0
02703 --                  THEN V := V + 1 ;
02704 --                          COMMENT else if our R/Q is attacked, but safe,
02705 --                                  increment V by 1 ;
02706 -5      END ;
02707 --      IF DEBUG
02708 --      THEN WRITEON(J, V) ;
02709 -4    END ;
02710 --                    COMMENT is the pawn safely blocked ;
02711 --    IF BRD(SQ+INC) ~= 0
02712 --    THEN V := V + 1
02713 --    ELSE V := V + (IF L > 0
02714 --                   THEN 1
02715 --                   ELSE -(IF K > 0
02716 --                          THEN 9-ROWS(SQ)
02717 --                          ELSE ROWS(SQ))) ;
02718 --    IF DEBUG
02719 --    THEN WRITEON(L, V) ;
02720 --    IF V < 0 THEN V := 0 ;
02721 -3  end ;
02722 --    V
02723 -2  END OF_PP_BLOCK ;
02724 --  
02725 --  PROCEDURE CHECK_SQRS (INTEGER VALUE KK) ;
02726 2-  BEGIN
02727 --    INTEGER PC, KSQ, SQC ;
02728 --  
02729 --    FOR SQ := WQRSQ UNTIL BKRSQ
02730 --    DO IF CHECK_S(KK,SQ) ~= 0
02731 --       THEN CHECK_S(KK,SQ) := FORKS(KK,SQ) := 0 ;
02732 --                      COMMENT only really necessary when King moves ;
02733 --    KSQ := KINGSQ(KK) ;
02734 --    FOR M := KNIGHT, BISHOP, ROOK, PAWN
02735 3-    DO BEGIN
02736 --      BRD(KSQ) := PC := KK*M ;
02737 --      MOVESQUARE(KSQ) ;
02738 --      FOR I := SLIST UNTIL LIM-1
02739 4-      DO BEGIN
02740 --        KLIST := KLIST + 1 ;
02741 --        CHECKLIST(KLIST) := CHECKLIST(I) ;
02742 -4      END ;
02743 --      FOR I := 1 UNTIL KLIST
02744 4-      DO BEGIN
02745 --        SQC := CHECKLIST(I) ;
02746 --                 COMMENT IF DEBUG AND BRD(SQC) = 0 THEN
02747 --                         WRITE("CHE", SQC, KK, PC, PIECES(-PC), M, CON(KK,SQC)) ;
02748 --        CHECK_S(KK,SQC) := -PC ;
02749 --        IF BRD(SQC) = 0 AND (PIECES(-PC) > 0 OR M ~= KNIGHT
02750 --             AND PIECES(-KK*QUEEN) > 0) AND (CON(KK,SQC) = 0 OR M = PAWN)
02751 --        THEN FORKING(KSQ, SQC, M, KK) ;
02752 -4      END ;
02753 -3    END ;
02754 --    BRD(KSQ) := KK*KING ;
02755 -2  END OF_CHECK_SQRS ;
02756 --  
02757 --  LOGICAL PROCEDURE KN_DEFENCE (INTEGER VALUE SQ, SQH, K) ;
02758 2-  BEGIN
02759 --    INTEGER DIST, A, B ;
02760 --    LOGICAL SAFE ;
02761 --  
02762 --    SAFE := FALSE ;
02763 --    IF BOTV(KNIGHT, OFFSET(SQ)-OFFSET(SQH)) = 2
02764 3-    THEN BEGIN
02765 --      DIST := ABS(SQH - SQ) ;
02766 --      A := DOUBLE_KNIGHT(DIST) ;
02767 --  COMMENT
02768 --     .. .. 38 .. 40 .. 42 .. ..      .. .. 19 .. 21 .. 21 .. ..
02769 --     .. 27 .. 29 .. 31 .. 33 ..      .. 19 .. 21 .. 12 .. 21 ..
02770 --     16 .. .. .. 20 .. .. .. 24      08 .. .. .. 12 .. .. .. 12
02771 --     .. 07 .. 09 .. 11 .. 13 ..      .. 19 .. 21 .. 19 .. 21 ..
02772 --     .. .. .. .. ** .. 02 .. 04      .. .. .. .. ** .. 21 .. 12
02773 --                  Corrected 2 April 1986 ;
02774 --      IF A > 0
02775 4-      THEN BEGIN
02776 --        B := DIST - A ;
02777 --        IF SQ > SQH
02778 5-        THEN BEGIN
02779 --          A := -A ;
02780 --          B := -B ;
02781 -5        END ;
02782 --        IF CON(K,SQ+A) = 0 AND K*BRD(SQ+A) >= 0
02783 --        THEN SAFE := TRUE
02784 --        ELSE IF A ~= B AND CON(K, SQ+B) = 0 AND K*BRD(SQ+B) >= 0
02785 --             THEN SAFE := TRUE ;
02786 -4      END ;
02787 -3    END ;
02788 --    SAFE
02789 -2  END OF_KN_DEFENCE ;
02790 --  
02791 --  INTEGER PROCEDURE ISOLATE (INTEGER VALUE COL, PAWN, FILE, K) ;
02792 2-  BEGIN
02793 --    INTEGER I, C, M ;
02794 --  
02795 --    C := 0 ;
02796 --    M := QRSQ(K) - 1 + COL + FILE ;
02797 --    FOR L := 0 STEP FILE UNTIL 5*FILE
02798 --    DO IF BRD(L+M) = PAWN
02799 --       THEN C:= -1 ;
02800 --    IF C < 0
02801 --    THEN FOR L := -1, 1
02802 3-         DO BEGIN
02803 --           I := M + L ;
02804 --           WHILE BRD(I) ~= EDGE AND BRD(I) ~= PAWN
02805 --           DO I := I + FILE ;
02806 --           IF BRD(I) = PAWN
02807 --           THEN C := C + 1 ;
02808 -3    END ;
02809 --    IF C > 0
02810 --    THEN C := 0 ;
02811 --    IF DEBUG
02812 --    THEN WRITE("ISO", COL, PAWN, FILE, K, C, I) ;
02813 --    C
02814 -2  END OF_ISOLATE ;
02815 --  
02816 --  PROCEDURE ENPRISE (INTEGER VALUE K) ;
02817 --    COMMENT   determines which moving pieces are under attack. ;
02818 2-  BEGIN
02819 --    INTEGER PC, M, KSQ, KK, MEN ;
02820 --  
02821 --    MEN := PIECES(0) - PIECES(PAWN) - PIECES(-PAWN) ;
02822 --    LATE_END := PIECES(QUEEN) = 0 AND PIECES(-QUEEN) = 0 ;
02823 --    IF OPEN(K)
02824 3-    THEN BEGIN
02825 --      M := IF (K > 0)
02826 --            THEN 15
02827 --            ELSE 85 ;
02828 --      AGITATE := 0 ;
02829 --      FOR I := -3, -2, 1, 2
02830 4-      DO BEGIN
02831 --        PC := ABS(BRD(I+M)) ;
02832 --        IF (PC ~= EMPTY) AND (PC < ROOK)
02833 --        THEN AGITATE := AGITATE - 1 ;
02834 --           COMMENT agitate backrow minor pieces ;
02835 -4      END ;
02836 --      IF (LEVEL <= 1) AND ~ALTERNATIVE
02837 4-      THEN BEGIN
02838 --        IF EARLY
02839 --        THEN IF MOVECOUNT > 8 OR AGITATE = 0
02840 --             THEN NEWGAME := EARLY := FALSE
02841 --             ELSE IF WHO AND (MOVECOUNT = 2)
02842 --                  THEN LOOKAHEAD := TRUE ;
02843 --        IF (MOVECOUNT > 16 OR MEN <= 8 OR AGITATE = 0 AND PIECES(0) <= 26)
02844 5-        THEN BEGIN
02845 --          WRITE("START MIDDLE GAME ", COLOR(K)) ;
02846 --          OPEN(K) := FALSE ;
02847 --          IF ~OPEN(-K)
02848 --          THEN MMTTS(-10002, HISTORY) ;
02849 -5        END ;
02850 -4      END ;
02851 -3    END ;
02852 --    OPENING := OPEN(K) ;
02853 --    ENDGAME := IF ~OPENING AND (MEN <= 8
02854 --                   OR LATE_END AND PIECES(0) <= 18 OR PIECES(0) <= 12)
02855 --               THEN TRUE
02856 --               ELSE FALSE ;
02857 --    LATE_END := ENDGAME AND LATE_END AND (MEN <= 6 AND PIECES(0) <= 14
02858 --                  OR MEN < 6 AND PIECES(ROOK) = 0 AND PIECES(-ROOK) = 0) ;
02859 --    KK := IF ALTERNATIVE
02860 --          THEN -K
02861 --          ELSE K ;
02862 --    CHECK_SQRS(KK) ;
02863 --    KSQ := KINGSQ(KK) ;
02864 --    M := 0 ;
02865 --    FOR SQ := WQRSQ UNTIL BKRSQ
02866 3-    DO BEGIN
02867 --      DECOYS(SQ) := 0 ;
02868 --      PC := BRD(SQ) ;
02869 --      IF (PC ~= EDGE) AND (K*PC > 0)
02870 --      THEN IF (SQ ~= KSQ)
02871 --           THEN IF (CON(-K,SQ) ~= 0)
02872 --                THEN IF (SACRIFICE(SQ, DEBUG) OR SQR(10) ~= ATTASQRS(10))
02873 4-                     THEN BEGIN
02874 --                       COMMENT   attacked directly ;
02875 --                       M := M + 1 ;
02876 --                       SQUARE(M) := SQ ;
02877 --                       LOSS(M) := LOSSES ;
02878 -4      END ;
02879 -3    END FORSQLOOP ;
02880 --    LOSS(0) := SQUARE(0) := M ;
02881 -2  END OF_ENPRISE ;
02882 --  
02883 --  INTEGER PROCEDURE FORKLOSS (INTEGER VALUE SQ, FROM, UNTO) ;
02884 2-  BEGIN
02885 --    INTEGER LOSS, HI, HIGH, PCD, SQD, PC, PCA, APC, LOST, K_PAWN,
02886 --      ASQ, KK, START ;
02887 --  
02888 --    PROCEDURE FKLOSS (INTEGER VALUE RESULT LOST) ;
02889 3-    BEGIN
02890 --      MOVESQUARE(SQ) ;
02891 --      HIGH := LOSS := 0 ;
02892 --      PCA := VALUES(ABS(APC)) ;
02893 --      FOR L := 1 UNTIL KLIST
02894 4-      DO BEGIN
02895 --        SQD := CHECKLIST(L) ;
02896 --        PCD := ABS(BRD(SQD)) ;
02897 --        IF (PCD > NIL)
02898 5-        THEN BEGIN
02899 --          HI := PCD := VALUES(PCD) ;
02900 --                        COMMENT can a defender recapture on SQ ;
02901 --          FOR J := 1 UNTIL SQR(0)
02902 --          DO IF SQD = SQR(J)
02903 --             THEN IF PCD < PCA + DELTA OR ABS(CON(KK,SQ)) = 1
02904 --                  THEN GO TO SKIP
02905 --                  ELSE HI := HI - PCA ;
02906 --          IF PCD ~= KINGVAL AND HI = PCD
02907 --          THEN IF (CON(-KK,SQD) ~= 0) OR ABS(APC) ~= KNIGHT
02908 --                    AND HIDDEN(SQ, ASQ, SQD, -KK, FALSE)
02909 --               THEN IF (PCA < PCD + DELTA)
02910 --                    THEN HI := HI - PCA
02911 --                    ELSE GO TO NEXT ;
02912 --          IF (HI > HIGH)
02913 6-          THEN BEGIN
02914 --            LOSS := HIGH ;
02915 --            HIGH := HI ;
02916 -6          END ELSE IF (HI > LOSS)
02917 --                   THEN LOSS := HI ;
02918 -5        END ;
02919 --  NEXT:
02920 -4      END ;
02921 --  SKIP:
02922 --                  COMMENT   must re-org. in order to call sacrifice ;
02923 --      IF DEBUG
02924 --      THEN IF (LOSS ~= 0)
02925 --           THEN WRITE("FORK", SQ, PCA, LOSS, LOST, HI, HIGH, APC, ASQ, FROM, UNTO) ;
02926 --      IF (LOSS > LOST)
02927 --      THEN LOST := LOSS ;
02928 -3    END OF_FKLOSS ;
02929 --  
02930 --  @TITLE, "FORKLOSS"
02931 --  
02932 --    PC := BRD(SQ) ;
02933 --    LOST := 0 ;
02934 --    KK := IF PC > 0
02935 --          THEN -1
02936 --          ELSE 1 ;
02937 --    K_PAWN := KK*PAWN ;
02938 --                 COMMENT RANK_7 := 30 + 50*K ;
02939 --    FOR I := FROM UNTIL UNTO
02940 3-    DO BEGIN
02941 --      ASQ := ATTASQRS(I) ;
02942 --      APC := BRD(SQ) := BRD(ASQ) ;
02943 --      BRD(ASQ) := 0 ;
02944 --      IF (APC ~= K_PAWN) OR (PAWNS(SQ) ~= 0)
02945 --      THEN FKLOSS(LOST)
02946 --      ELSE FOR PPC := KNIGHT, BISHOP, ROOK, QUEEN
02947 4-      DO BEGIN
02948 --                    COMMENT pawn about to promote ;
02949 --        APC := BRD(SQ) := PPC*KK ;
02950 --        FKLOSS(LOST) ;
02951 --        APC := K_PAWN ;
02952 -4      END ;
02953 --      BRD(ASQ) := APC ;
02954 -3    END ;
02955 --    BRD(SQ) := PC ;
02956 --    LOST
02957 -2  END OF_FORKLOSS ;
02958 --  
02959 --  PROCEDURE GAMERECORD (LOGICAL VALUE FINIS) ;
02960 2-  BEGIN
02961 --    INTEGER F ;
02962 --    STRING(20) NAME ;
02963 --    STRING(20) SPACES ;
02964 --  
02965 --    NAME := "    Amdahl 5860/2" ;
02966 --    I_W := 5 ;
02967 --    IF FINIS
02968 3-    THEN BEGIN
02969 --                  COMMENT send score to WITA:GAMES ;
02970 --      MMTTS(-9999, HISTORY) ;
02971 --      PUT(9) ;
02972 -3    END ;
02973 --    SPACES := " " ;
02974 --    F := COUNT - (MOVECOUNT-INITIALCNT)*2 ;
02975 --    IF (F < 0)
02976 --    THEN F := 0 ;
02977 --    HISTORY(120|1) := "." ;
02978 --    WHILE HISTORY(120|1) = "." AND F < COUNT
02979 3-    DO BEGIN
02980 --      F := F + 1 ;
02981 --      MMTTS(-F, HISTORY) ;
02982 -3    END ;
02983 --    DATER(4, 0, DATE) ;
02984 --    IOCONTROL(2) ;                    comment was eject page  IOCONTROL(3) ;
02985 --    WRITEON(DATE(0|8)) ;
02986 --    DATER(5, 0, DATE) ;
02987 --    WRITEON("    ", DATE) ;
02988 --    IF (K = -1) AND ~WHO OR (K = 1) AND WHO
02989 3-    THEN BEGIN
02990 --      WRITE(SPACES(0|12), "Awit", "  ", SPACES, USERID) ;
02991 --      WRITE("REAL mins: ", COMPUTERTIME DIV 3600, SPACES, USERTIME DIV 3600) ;
02992 --      WRITE("CPU  secs: ", WITA DIV 60, SPACES, USER DIV 60) ;
02993 --      WRITE(NAME, SKILL) ;
02994 -3    END ELSE
02995 3-    BEGIN
02996 --      WRITE(SPACES(0|12), USERID, "  ", SPACES, "Awit") ;
02997 --      WRITE("REAL mins: ", USERTIME DIV 3600, SPACES, COMPUTERTIME DIV 3600) ;
02998 --      WRITE("CPU  secs: ", USER DIV 60, SPACES, WITA DIV 60) ;
02999 --      WRITE(SPACES, SKILL, NAME) ;
03000 -3    END ;
03001 --    WRITE(" ") ;
03002 --    FOR I := F STEP 2 UNTIL COUNT
03003 3-    DO BEGIN
03004 --      F := I ;
03005 --      MMTTS(-I, HISTORY) ;
03006 --      WRITE(HISTORY(85|54)) ;
03007 -3    END ;
03008 --    IF COUNT > 0
03009 --    THEN MMTTS(-COUNT,HISTORY) ;
03010 --    IF (F < COUNT)
03011 --    THEN WRITE(HISTORY(85|30)) ;
03012 --    IF FINIS
03013 --    THEN PRINTSHORTBRD(-1) ;
03014 --    WRITE("NODES ", NOD, "TERMINAL ", TOT, "DYNAMIC ", DYN, "CAPTURE ", CAP)
03015 --     ;
03016 --    WRITE("SALVAGE ", SAL, "DUPLIC ", DUP, "RECLAIM ", REC, "BRANCH ", BRAN)
03017 --     ;
03018 --    WRITE("DUP_TREE ", DUP_S, "REC_TREE ", REC_S, "BRAN_SCORED ", BRAN_S)
03019 --     ;
03020 --    write("maxtree = ", maxtree, " maxlevel = ", maxlev, " maxwidth  = ", width) ;
03021 --    IOCONTROL(2) ;
03022 --    IF FINIS
03023 --    THEN PUT(TTYOUT) ;
03024 --    IF FINIS
03025 --    THEN MMTTS(-10009, HISTORY) ;
03026 -2  END OF_GAMERECORD ;
03027 --  
03028 --  PROCEDURE HIDDENLOSS (INTEGER VALUE N ; INTEGER VALUE RESULT LSAVE, ESAVE) ;
03029 2-  BEGIN
03030 --    INTEGER SQF, SQT, SQA, SQD, SQ3, I, K, L, PCA, PCD, SAVEB, PC3,
03031 --            PCF, E, KA, K3, REWARDN, KK ;
03032 --    LOGICAL T ;
03033 --  
03034 --    L := LSAVE ;
03035 --    E := ESAVE ;
03036 --    SQF := MOVEFROM(N) ;
03037 --    SQT := MOVETO(N) ;
03038 --    PCF := BRD(SQF) ;
03039 --    BRD(SQF) := EMPTY ;
03040 --    K := IF (PCF > 0)
03041 --         THEN 1
03042 --         ELSE -1 ;
03043 --    IF ~ REMEMBER AND ~ PPIN
03044 --    THEN IF (BRD(SQT) ~= NIL)
03045 --         THEN GO TO OMIT
03046 --         ELSE GO TO QUIT ;
03047 --    PINNED := TRUE ;
03048 --                 COMMENT        direct pin and discovered attack ;
03049 --  
03050 --    FOR J := CON(-1,SQF) UNTIL CON(1,SQF)
03051 --    DO IF J ~= 0
03052 3-       THEN BEGIN
03053 --         KK := IF J < 0
03054 --               THEN -1
03055 --               ELSE 1 ;
03056 --         SQA := CONTROL(SQF,J) ;
03057 --         PCA := BRD(SQA) ;
03058 --         KA := IF (PCA > 0)
03059 --               THEN 1
03060 --               ELSE -1 ;
03061 --         PCA := ABS(PCA) ;
03062 --         IF PCA >= BISHOP AND PCA <= QUEEN
03063 4-         THEN BEGIN
03064 --           T := HIDDEN(SQA, SQF, SQ3, KK, FALSE) ;
03065 --           PC3 := BRD(SQ3) ;
03066 --           K3 := IF (PC3 > 0)
03067 --                 THEN 1
03068 --                 ELSE -1 ;
03069 --           IF (PC3 = KING*K) AND (KA ~= K3)
03070 5-           THEN BEGIN
03071 --             IF ABS(DIR) = ABS(BOTV(EDGE, OFFSET(SQF)-OFFSET(SQT)))
03072 --             THEN PPIN := TRUE
03073 --             ELSE GO TO EXIT ;
03074 --                     COMMENT incremental move problem, use of ppin ensures
03075 --                             that potential pin is detected even if incremental
03076 --                             move is initially along the attack direction ;
03077 -5           END ELSE IF (SQ3 ~= HOLE)
03078 --                    THEN IF (K3 ~= KA)
03079 5-                         THEN BEGIN
03080 --                           COMMENT either sq3 contains a pinned piece,
03081 --                                          or there is a discovered attack on sq3 ;
03082 --                           IF (K3 = K)
03083 --                           THEN I := L := L + 1
03084 --                           ELSE I := E := E - 1 ;
03085 --                           SQUARE(I) := SQ3 ;
03086 --                               COMMENT IF DEBUG
03087 --                               THEN WRITE("HIDD", SQF, SQT, SQ3, KA, K3) ;
03088 -5           END ;
03089 -4         END ;
03090 -3    END ;
03091 --  OMIT:
03092 --    PINNED := FALSE ;
03093 --                       COMMENT     indirect pin and captured piece loss ;
03094 --    REWARDN := ABS(REWARD(N)) REM CHECKING ;
03095 --    FOR KK := -K,K
03096 3-    DO BEGIN
03097 --      SQ3 := IF (K=KK)
03098 --             THEN SQF
03099 --             ELSE IF (REWARDN = ENPRIS)
03100 --                  THEN SQT - K*FILE
03101 --                  ELSE SQT ;
03102 --  if sq3 < 11 or sq3 > 88
03103 --  then write ("hiddenloss sq3/k/kk/sqt", sq3, k, kk, sqt) else
03104 --      IF (SQ3 ~= SQF) OR TERMINAL OR REMEMBER
03105 --      THEN WHILE (SQ3 ~= 0)
03106 4-           DO BEGIN
03107 --             FOR J := POSITION(SQ3,LIM) UNTIL LIM-1
03108 5-             DO BEGIN
03109 --               SQD := POSITION(SQ3,J) ;
03110 --               IF (KK*BRD(SQD) > 0) AND (CON(-KK,SQD) ~= 0)
03111 --               THEN IF (K=KK)
03112 6-                    THEN BEGIN
03113 --                      L := L + 1 ;
03114 --                      SQUARE(L) := SQD ;
03115 -6               END ELSE
03116 6-               BEGIN
03117 --                 E := E - 1 ;
03118 --                 SQUARE(E) := SQD ;
03119 -6               END ;
03120 -5             END ;
03121 --             SQ3 := IF (K=KK) AND (ABS(SQT - SQF) = 2)
03122 --                        AND (ABS(PCF) = KING) AND (SQ3 = SQF)
03123 --                    THEN IF (REWARDN = QSIDE)
03124 --                         THEN QRSQ(K)
03125 --                         ELSE IF (REWARDN = KSIDE)
03126 --                              THEN KRSQ(K)
03127 --                              ELSE 0
03128 --                    ELSE 0 ;
03129 -4      END ;
03130 -3    END ;
03131 --    IF ~TERMINAL AND ~REMEMBER
03132 --    THEN GO TO QUIT ;
03133 --                       COMMENT       unpinning piece ;
03134 --  if sqf < 11 or sqf > 88
03135 --  then write("hidden_loss error sqf/pcf=", sqf, pcf) else
03136 --    IF (ABS(PCF) > KNIGHT) AND (ABS(PCF) < KING)
03137 --    THEN FOR I := 1 UNTIL POS(SQF)
03138 3-         DO BEGIN
03139 --           SQA := POSITION(SQF,I) ;
03140 --           IF (K*BRD(SQA) < 0)
03141 4-           THEN BEGIN
03142 --             T := HIDDEN(SQF, SQA, SQ3, K, FALSE) ;
03143 --             PC3 := BRD(SQ3) ;
03144 --             IF (K*PC3 < 0) AND (SQT ~= SQA)
03145 --             THEN IF (ABS(PCF) < ABS(PC3))
03146 --                  THEN
03147 --                  COMMENT  possible unpin ;
03148 --                  IF DIR ~= BOTV(EDGE, OFFSET(SQT)-OFFSET(SQA))
03149 --                  THEN
03150 --                  COMMENT   definite unpin ;
03151 --                  FOR J := POS(SQA) STEP -1 UNTIL 1
03152 5-                  DO BEGIN
03153 --                    SQD := POSITION(SQA,J) ;
03154 --                    IF (K*BRD(SQD) > 0)
03155 6-                    THEN BEGIN
03156 --                      L := L + 1 ;
03157 --                      SQUARE(L) := SQD ;
03158 -6                    END ;
03159 -5                         END ;
03160 -4           END ;
03161 -3    END ;
03162 --  QUIT:
03163 --    LSAVE := L ;
03164 --    ESAVE := E ;
03165 --                       COMMENT       blocking a defence ;
03166 --    FOR KK := -K,K
03167 3-    DO BEGIN
03168 --      I := CON(KK,SQT) ;
03169 --      IF (ABS(PCF) = KNIGHT)
03170 --      THEN IF (ABS(I) < CONLIM)
03171 4-           THEN BEGIN
03172 --             PC3 := HOLE ;
03173 --             DIR := BOTV(EDGE, OFFSET(SQT)-OFFSET(SQF)) ;
03174 --             IF DIR = 0
03175 --             THEN PC3 := NIL
03176 --             ELSE FOR J := SQT+DIR STEP DIR UNTIL SQF-DIR
03177 --                  DO IF (BRD(J) ~= EMPTY)
03178 --                     THEN PC3 := NIL ;
03179 --             IF (PC3 ~= NIL)
03180 --             THEN IF HIDDEN(SQT, SQF, SQ3, -KK, FALSE)
03181 5-                  THEN BEGIN
03182 --                    I := I + KK ;
03183 --                    CONTROL(SQT,I) := SQ3 ;
03184 -5             END ;
03185 --                      COMMENT special order of incremental knight
03186 --                              moves is used to minimize problem associated
03187 --                              with the blocking of a mutual defence between
03188 --                              bishop and queen ;
03189 -4      END ELSE WRITE("HIDDEN CONLIM ERROR") ;
03190 --      FOR I := I STEP -KK UNTIL KK
03191 4-      DO BEGIN
03192 --        SQD := CONTROL(SQT,I) ;
03193 --        PCD := ABS(BRD(SQD)) ;
03194 --        IF (PCD = QUEEN) OR (PCD = ROOK) OR (PCD = BISHOP)
03195 --        THEN IF (PCF ~= BRD(SQD))
03196 5-             THEN BEGIN
03197 --               T := HIDDEN(SQD, SQT, SQ3, -KK, FALSE) ;
03198 --               IF (KK*BRD(SQ3) > 0)
03199 --               THEN IF (K = KK)
03200 6-                    THEN BEGIN
03201 --                      L := L + 1 ;
03202 --                      SQUARE(L) := SQ3 ;
03203 -6               END ELSE
03204 6-               BEGIN
03205 --                 E := E - 1 ;
03206 --                 SQUARE(E) := SQ3 ;
03207 -6               END ;
03208 -5        END ;
03209 -4      END ;
03210 -3    END ;
03211 --    FOR I := SQUARE(0)+1 UNTIL L
03212 --    DO LOSS(I) := 0 ;
03213 --    LOSS(0) := L ;
03214 --    LOSS(ELIMIT) := E ;
03215 --  EXIT:
03216 --    BRD(SQF) := PCF ;
03217 -2  END OF_HIDDENLOSS ;
03218 --  
03219 --  PROCEDURE MOVESQUARE (INTEGER VALUE SQ) ;
03220 --    COMMENT   lists the moves for the piece on square i ;
03221 2-  BEGIN
03222 --    INTEGER K, M1 ;
03223 --                       COMMENT   movesquare is called by many procedures ;
03224 --    M1 := BRD(SQ) ;
03225 --    K := IF (M1 < 0)
03226 --         THEN -1
03227 --         ELSE 1 ;
03228 --    M1 := ABS(M1) ;
03229 --    SLIST := LIM ;
03230 --    CLIST := 0 ;
03231 --                       COMMENT for King and Pawn moves, KLIST set in LISTK...
03232 --                               and LISTP... ;
03233 --    IF (M1 = KING)
03234 --    THEN LISTKINGMOVES(SQ, K)
03235 --    ELSE IF M1 = PAWN
03236 --         THEN LISTPAWNMOVES(SQ, K)
03237 3-    ELSE BEGIN
03238 --      IF M1 = KNIGHT
03239 --      THEN TRYKNIGHTMOVE(SQ, K)
03240 --      ELSE IF (M1 = QUEEN)
03241 --           THEN LISTQUEENMOVES(SQ, K)
03242 --           ELSE IF (M1 = BISHOP)
03243 --                THEN TRYMINORMOVE(SQ, LDIAG, RDIAG, K)
03244 --                ELSE IF M1 = ROOK
03245 --                     THEN TRYMINORMOVE(SQ, FILE, RANK, K) ;
03246 --      KLIST := CLIST ;
03247 -3    END ;
03248 --    CHECKLIST(0) := CLIST ;
03249 --    CHECKLIST(LIM) := SLIST ;
03250 -2  END OF_MOVESQUARE ;
03251 --  
03252 --  INTEGER PROCEDURE PASSEDPAWN (INTEGER VALUE SQ, KK) ;
03253 2-  BEGIN
03254 --    INTEGER VAL, LIMIT, INC, SQ3, A, PC, C, SQ2, DP, DK ;
03255 --    LOGICAL FREE, STOPPED ;
03256 --  
03257 --    VAL := 0 ;
03258 --    IF ~OPENING AND PAWNS(SQ) = -KK
03259 --    THEN GO TO QUIT ;
03260 --    INC := FILES(KK) ;
03261 --    LIMIT := IF (KK > 0)
03262 --             THEN BKRSQ
03263 --             ELSE WQRSQ ;
03264 --                             COMMENT increase VAL if passed pawn, and ENDGAME ;
03265 --    FOR L := -1 UNTIL 1
03266 --    DO FOR I := SQ + INC + L STEP INC UNTIL LIMIT
03267 --    DO IF (BRD(I) = -KK)
03268 --       THEN GO TO QUIT ;
03269 --    VAL := 8 ;
03270 --    FREE := TRUE ;
03271 --    SQ2 := SQ -INC ;
03272 --    IF BRD(SQ) ~= 0
03273 --    THEN SQ2 := SQ
03274 --    ELSE IF ABS(BRD(SQ2)) ~= PAWN
03275 --         THEN SQ2 := LIMIT ;
03276 --    A := 0 ;
03277 --    IF SQ2 = LIMIT
03278 --    THEN SQ2 := SQ
03279 --    ELSE IF HIDDEN(SQ+INC, SQ2, SQ3, 0, FALSE)
03280 --         THEN A := IF KK*BRD(SQ3) > 0
03281 --                   THEN 1
03282 --                   ELSE -1 ;
03283 --    IF SQ2 ~= SQ AND KK*SEC(0,SQ) + A < 0
03284 --    THEN FREE := FALSE ;
03285 --    FOR I := SQ+INC STEP INC UNTIL LIMIT
03286 3-    DO BEGIN
03287 --      IF FREE
03288 4-      THEN BEGIN
03289 --        PC := KK*BRD(I) ;
03290 --        C := KK*CON(0,I) ;
03291 --        IF C + A < 0 OR PC < 0 AND C <= 0
03292 --        THEN FREE := FALSE ;
03293 --        IF PC < ROOK OR C <= 0
03294 --        THEN IF PC > 0
03295 --             THEN VAL := VAL - 1 ;
03296 -4      END ;
03297 --      VAL := VAL - 1 ;
03298 -3    END ;
03299 --    IF ~FREE
03300 --    THEN VAL := VAL - 1 ;
03301 --    IF VAL < 4
03302 --    THEN VAL := VAL - 1 ;
03303 --    SQ2 := SQ2 + INC ;
03304 --    STOPPED := BRD(SQ2) ~= EDGE AND (BRD(SQ2)*KK < 0 OR CON(KK,SQ2) = 0
03305 --                                AND CON(-KK,SQ2) ~= 0) ;
03306 --    IF DEBUG
03307 --    THEN WRITE("PASSED", SQ, FREE, A, C, VAL, KK, SQ2, STOPPED) ;
03308 3-    IF ~ STOPPED THEN BEGIN
03309 --                       COMMENT  can King stop pawn? ;
03310 --      DP := BOTV(KING, OFFSET(SQ)-OFFSET(BACK_ROW(-KK,COLS(SQ)))) ;
03311 --      DK := BOTV(KING,OFFSET(KINGSQ(-KK))-OFFSET(BACK_ROW(-KK,COLS(SQ)))) ;
03312 --      STOPPED := DP + (IF K = KK
03313 --                       THEN 1
03314 --                       ELSE 0) >= DK ;
03315 -3    END ELSE IF VAL > 2 THEN VAL := VAL - 2 ;
03316 --    IF STOPPED
03317 3-    THEN BEGIN
03318 --      IF VAL > 3
03319 --      THEN IF CON(KK,SQ) ~= 0 OR CON(KK,SQ+INC) ~= 0
03320 --           THEN VAL := 1 + (VAL DIV 2)
03321 --           ELSE VAL := 3 ;
03322 -3    END ELSE IF FREE
03323 --             THEN VAL := VAL + 3 ;
03324 --    IF FREE
03325 3-    THEN BEGIN
03326 --      IF A = 1
03327 --      THEN VAL := VAL + 1
03328 --      ELSE IF BRD(SQ) ~= 0
03329 --           THEN VAL := VAL + 1 ;
03330 -3    END ELSE IF BRD(SQ) ~= 0 AND VAL >= 6 AND ABS(CON(-KK,SQ+INC)) <= 1
03331 --             THEN IF A = 1
03332 --                  THEN VAL := VAL + 3 ;
03333 --    IF ~STOPPED AND VAL >= 10
03334 --    THEN VAL := VAL + 2 ;
03335 --    IF DEBUG
03336 --    THEN WRITEON(STOPPED, DP, DK, K, VAL, CON(-KK,SQ+INC)) ;
03337 --  QUIT:
03338 --    VAL
03339 -2  END OF_PASSEDPAWN ;
03340 --  
03341 --  PROCEDURE REMAKE (INTEGER VALUE SQF, SQT) ;
03342 2-  BEGIN
03343 --    INTEGER PC, SQ1, SQ2, L1, L2, I1, KK ;
03344 --    LOGICAL FLAG ;
03345 --  
03346 --    PC := BRD(SQF) ;
03347 --    IF MAKEMV
03348 3-    THEN BEGIN
03349 --      FOR L := 2 UNTIL NUMB
03350 --      DO IF (SQF = RLIST(L))
03351 --         THEN IF (ABS(PC) = PAWN)
03352 --              THEN GO TO SET
03353 --              ELSE IF L > T_NUMB
03354 --                   THEN GO TO QUIT ;
03355 --      NUMB := NUMB + 1 ;
03356 --      RLIST(NUMB) := SQF ;
03357 --      TLIST(NUMB) := SQT ;
03358 -3    END ;
03359 --  SET:
03360 --    KK := IF (PC > 0)
03361 --          THEN 1
03362 --          ELSE -1 ;
03363 --    L1 := POSITION(SQF,0) ;
03364 --    FOR L := 1 UNTIL L1
03365 --    DO OLDLIST(L) := POSITION(SQF,L) ;
03366 --                 COMMENT pawns do not control all the squares to which they can
03367 --                         move ;
03368 --                 COMMENT kings cannot move to all the squares that they control,
03369 --                         nor do they control the castling square ;
03370 --    FOR L := POSITION(SQF,LIM) UNTIL LIM-1
03371 3-    DO BEGIN
03372 --      L1 := L1 + 1 ;
03373 --      OLDLIST(L1) := POSITION(SQF,L) ;
03374 -3    END ;
03375 --    MOVESQUARE(SQF) ;
03376 --                 COMMENT note use of KLIST, and not POS(SQF) ;
03377 --    FOR L := 1 UNTIL CLIST
03378 --      DO POSITION(SQF,L) := CHECKLIST(L) ;
03379 --    FOR L := SLIST UNTIL LIM
03380 --      DO POSITION(SQF,L) := CHECKLIST(L) ;
03381 --    POS(SQF) := CLIST ;
03382 --    POSITION(SQF,0) := I1 := KLIST ;
03383 --    FOR I := SLIST UNTIL LIM-1
03384 3-    DO BEGIN
03385 --      I1 := I1 + 1 ;
03386 --      CHECKLIST(I1) := CHECKLIST(I) ;
03387 -3    END ;
03388 --                       COMMENT delete unique entries in OLDLIST, fix in CHECKLIST ;
03389 --    FOR L := 1 UNTIL L1
03390 3-    DO BEGIN
03391 --      SQ1 := OLDLIST(L) ;
03392 --      FOR I := 1 UNTIL I1
03393 --      DO IF (CHECKLIST(I) = SQ1)
03394 4-         THEN BEGIN
03395 --           CHECKLIST(I) := CHECKLIST(I1) ;
03396 --           I1 := I1 - 1 ;
03397 --           GO TO NEXTL ;
03398 -4      END ;
03399 --      DELETE(SQF, SQ1, KK) ;
03400 --  NEXTL:
03401 -3    END ;
03402 --                       COMMENT does not handle correctly, pawns which are about to
03403 --                               promote with a capture.  not serious? ;
03404 --    L2 := LOSS(ELIMIT) ;
03405 --    FOR I := 1 UNTIL I1
03406 3-    DO BEGIN
03407 --      SQ2 := CHECKLIST(I) ;
03408 --      FIXIT(SQF, SQ2, KK) ;
03409 --      IF REMEMBER
03410 --      THEN IF (K*BRD(SQ2) < 0)
03411 4-           THEN BEGIN
03412 --             L2 := L2 - 1 ;
03413 --             SQUARE(L2) := SQ2 ;
03414 -4      END ;
03415 -3    END ;
03416 --    LOSS(ELIMIT) := L2 ;
03417 --  QUIT:
03418 -2  END OF_REMAKE ;
03419 --  
03420 --  PROCEDURE CAPT_ORDER (INTEGER RESULT BEST ; LOGICAL VALUE LOSING) ;
03421 2-  BEGIN
03422 --    LOGICAL LEGAL ;
03423 --    INTEGER NOSC, DEFN, PC_VAL, ATTA_VAL, ATTA ;
03424 --    INTEGER R, PC, CH, TO, SQF, SQA, SAVE_D, KSQ, FROM, DIS, TMP, VAL ;
03425 --  
03426 --    NOSC := IF LOSING
03427 --            THEN -99
03428 --            ELSE NOSCR ;
03429 --    KSQ := KINGSQ(K) ;
03430 --    BEST := QUEEN ;
03431 --    SAVE_D := IF INCHECK AND ~DBLCHECK AND CHECKSQ ~= HOLE
03432 --              THEN BOTV(EDGE, OFFSET(KSQ)-OFFSET(CHECKSQ))
03433 --              ELSE 0 ;
03434 --    IF ABS(BRD(CHECKSQ)) = KNIGHT
03435 --    THEN SAVE_D := CHECKSQ - KSQ ;
03436 --    FOR N := NUMBER(K) STEP -K UNTIL K
03437 3-    DO BEGIN
03438 --      R := REWARD(N) ;
03439 --      FROM := MOVEFROM(N) ;
03440 --      TO := MOVETO(N) ;
03441 --      PC := ABS(BRD(FROM)) ;
03442 --      IF (PC = PAWN) AND (PAWNS(TO) = 0)
03443 --      THEN PC := ABS(R) REM PROMOTE ;
03444 --      TMP := K*CHECK_S(-K,TO) ;
03445 --      CH := IF TMP > 0 AND CHEC(TMP, PC)
03446 --            THEN REALCHECK
03447 --            ELSE 0 ;
03448 --      IF HIDDEN(KINGSQ(-K), FROM, SQA, K, TRUE)
03449 4-      THEN BEGIN
03450 --        DIS := DISCHECK ;
03451 --        IF DIR = BOTV(EDGE, OFFSET(KINGSQ(-K))-OFFSET(TO))
03452 --        THEN DIS := 0
03453 --        ELSE FOR I := KINGSQ(-K) + DIR STEP DIR UNTIL FROM -DIR
03454 --        DO IF BRD(I) ~= NIL
03455 --           THEN DIS := 0 ;
03456 --        CH := IF CH = 0
03457 --              THEN DIS
03458 --              ELSE IF DIS = 0
03459 --                   THEN CH
03460 --                   ELSE TWOCHECK ;
03461 --           COMMENT IF TEST THEN WRITE("DIS_CAP", KINGSQ(-K), FROM, TO, DIR, CH)
03462 --            ;
03463 -4      END ;
03464 --      IF (CH ~= 0)
03465 --      THEN REWARD(N) := R + CH ;
03466 --      LEGAL := FALSE ;
03467 --      IF PC = KING AND CON(-K,TO) ~= 0
03468 4-        THEN BEGIN
03469 --                PRINTSHORTBRD(-1) ;
03470 --                PRINTLINE(N, 0) ;
03471 -4        END ELSE
03472 --      IF (PC = KING AND R ~= KSIDE AND R ~= QSIDE)
03473 --      THEN LEGAL := TRUE
03474 --      ELSE IF ~DBLCHECK
03475 4-           THEN BEGIN
03476 --             IF ~HIDDEN(KSQ, FROM, SQA, -K, TRUE)
03477 --             THEN LEGAL := TRUE
03478 5-             ELSE BEGIN
03479 --               IF ABS(DIR) = ABS(BOTV(EDGE, OFFSET(FROM)-OFFSET(TO)))
03480 --               THEN LEGAL := TRUE ;
03481 -5             END ;
03482 --             IF INCHECK AND LEGAL
03483 5-             THEN BEGIN
03484 --               LEGAL := FALSE ;
03485 --               FOR SQ := KSQ+SAVE_D STEP SAVE_D UNTIL CHECKSQ
03486 --               DO IF SQ = TO
03487 --                  THEN LEGAL := TRUE ;
03488 -5             END ;
03489 -4      END ;
03490 --      IF ~LEGAL
03491 --      THEN IF (R = ENPRIS) AND (CHECKSQ = TO -K*FILE)
03492 --           THEN LEGAL := TRUE
03493 4-      ELSE BEGIN
03494 --        R := BAD ;
03495 --        NUM := NUM - 1 ;
03496 -4      END ;
03497 --      DEFN := K*SEC(0,TO) ;
03498 --                    COMMENT only legal replies generated ;
03499 4-      IF LEGAL THEN BEGIN
03500 --        ATTA := CON(-K,TO) ;
03501 --        PC_VAL := VALUES(PC) ;
03502 --        COMMENT IF TEST
03503 --                  THEN WRITE("CAPT", PC, R, DEFN, ATTA, PC_VAL, TO, K) ;
03504 --        IF ATTA ~= 0
03505 --        THEN ATTA_VAL := VALUES(ABS(BRD(CONTROL(TO,-K)))) ;
03506 --                          COMMENT IF TEST THEN WRITEON(ATTA_VAL) ;
03507 --        ATTA := ABS(ATTA) ;
03508 --                          COMMENT question next stmt "promote + queen + queen"? ;
03509 --        IF R = 0 OR R > ENPRIS AND R < PROMOTE + QUEEN + QUEEN
03510 --        THEN R := IF (CH ~= 0)
03511 --                  THEN IF DEFN <= 0
03512 --                       THEN -PC_VAL
03513 --                       ELSE -PC
03514 --                  ELSE IF INCHECK
03515 --                       THEN -8 + PC
03516 --                       ELSE IF ATTA = 1
03517 --                            THEN IF DEFN < 0 OR DEFN = 0 AND PC ~= PAWN
03518 --                                 THEN -PC_VAL
03519 --                                 ELSE IF ATTA_VAL < PC_VAL - DELTA
03520 --                                      THEN -PC_VAL + ATTA_VAL
03521 --                                      ELSE NOSC
03522 --                            ELSE NOSC
03523 --        ELSE IF R ~= 0 AND R < KING
03524 5-             THEN BEGIN
03525 --               VAL := IF DEFN <= 0 OR ATTA > 1
03526 --                      THEN 0
03527 --                      ELSE IF ATTA = 1
03528 --                           THEN ATTA_VAL
03529 --                           ELSE PC_VAL ;
03530 --               R := VALUES(R) - PC_VAL + VAL ;
03531 -5             END ;
03532 --        COMMENT IF TEST AND R ~= NOSC
03533 --                      THEN WRITEON(R) ;
03534 -4      END ;
03535 --      IF PC = PAWN AND R = NOSC
03536 --      THEN DEFN := DEFN + 1 ;
03537 --      IF LOSING AND R ~= BAD AND DEFN <= 0
03538 --      THEN R := R + NOSC ;
03539 --      SCORE(N) := R ;
03540 -3    END ;
03541 -2  END OF_CAPT_ORDER ;
03542 --  
03543 --  PROCEDURE MAIN ;
03544 2-  BEGIN
03545 --    INTEGER ARRAY LASTSQ, DEBIT, CREDIT(-1::E_Depth) ;
03546 --    INTEGER ARRAY STACK_HASH(0::E_Depth) ;
03547 --    INTEGER ARRAY NODETO(0::MAXTREE, 0::MAX_WID) ;
03548 --    INTEGER ARRAY GETNODE, PARENT, DUPSCR(0::MAXTREE+1) ;
03549 --    INTEGER ARRAY ROOTNODE(0::E_Depth) ;
03550 --    INTEGER ARRAY BACK(0::E_Depth, 0::TSIZE) ;
03551 --    INTEGER ARRAY STATES(-1::MAXTREE, 1::2*MAX_WID+T_SIZE+2) ;
03552 --    INTEGER ARRAY REFUT, REFCNT (1::E_Depth, 0::10) ;
03553 --    INTEGER ARRAY LASTDIR (-1::E_Depth) ;
03554 --    comment INTEGER ARRAY REFTAB(1::MAX_WID+MAX_PLIES, 1::MAX_PLIES) ;
03555 --    INTEGER ARRAY REFTAB(0::MAX_WID+E_Depth, 1::E_Depth) ;
03556 --    logical exiting ;
03557 --    integer array holding(1::maxtree) ;
03558 --  
03559 --  PROCEDURE COMPUTER ;
03560 --    COMMENT makes move which has largest score ;
03561 3-  BEGIN
03562 --    SCORES := TRUE ;
03563 --    IF (BOOK = -1)
03564 --    THEN USEBOOK ;
03565 --    IF (BOOK = 0)
03566 --    THEN IF (LOOKAHEAD) AND (MOVECOUNT > 1)
03567 --         THEN SEARCH
03568 --         ELSE LISTLEGALMOVES (FALSE) ;
03569 --    IF (SKTEST = 3)
03570 --    THEN IF (SCORE(RTMV) > PAWNVALUE)
03571 --         THEN WRITE("CANNOT ACCEPT DRAW YET")
03572 --         ELSE KTEST := 3 ;
03573 --    IF (NUM = 0)
03574 --    THEN KTEST := IF (CON(-K,KINGSQ(K)) ~= 0)
03575 --                  THEN 4
03576 --                  ELSE 2 ;
03577 --                       COMMENT if stalemate, REPLY = 0, do not generate response ;
03578 --    IF ~EARLY AND REPLY = 0 AND BOOK = 0 AND KTEST = 0
03579 --    THEN NULLMOVE := TRUE
03580 --    ELSE IF (KTEST ~= 3) THEN
03581 4-    BEGIN
03582 --      write("Awit's move is:") ;
03583 --      S_W := 0 ;
03584 --      WRITE(MOVECOUNT, ". ") ;
03585 --      S_W := 1 ;
03586 --      DESCRIBEMOVE(RTMV, MC) ;
03587 --      IF K ~= 1
03588 --      THEN WRITEON("  ... ") ;
03589 --      FOR I := 0 UNTIL 23
03590 --      DO WRITEON(MC(I)) ;
03591 --      IF COKO AND FALSE
03592 5-      THEN BEGIN
03593 --                        COMMENT switch i-o units ;
03594 --        PUT(3) ;
03595 --                        COMMENT switch o-p to unit 3 ;
03596 --        WRITE(" ") ;
03597 --        FOR I := 0 UNTIL 23
03598 --        DO WRITEON(MC(I)) ;
03599 --        IOCONTROL(2) ;
03600 --        PUT(6) ;
03601 --                        COMMENT restore o-p to unit 6 ;
03602 -5      END ;
03603 --      IF (SCORE(RTMV) > VALUES(QUEEN)*SCALE) and NUM > 1
03604 --      THEN WRITE("I WILL ACCEPT YOUR RESIGNATION") ;
03605 --      if exiting then TRACER(4, "?GSPK") ;
03606 -4    END ELSE WRITE("ERROR.  NUM =", NUM, REASON(KTEST)) ;
03607 -3  END OF_COMPUTER ;
03608 --  
03609 --  PROCEDURE FINALIZE ;
03610 3-  BEGIN
03611 --    INTEGER I, NODE, D, CT ;
03612 --  
03613 --    PUNCHBRD(TRUE, HISTORY) ;
03614 --    I := IF (K = 1)
03615 --         THEN 85
03616 --         ELSE 115 ;
03617 --    FOR J := 0 UNTIL 23
03618 --    DO HISTORY(I+J | 1) := MC(J) ;
03619 --    I := 110 - 15*K ;
03620 --    D := SCORE(RTMV) + (IF WHO THEN -200 ELSE + 200) ;
03621 --    IF RTMV ~= 0 AND PREDICT > 0
03622 --    THEN IF ENDGAME AND ABS(D) <= THRESHOLD
03623 4-         THEN BEGIN
03624 --           HISTORY(I+2|4) := REASON(3)(1|4) ;
03625 --           IF WHO AND (MOVECOUNT > 50)
03626 --           THEN WRITEON("DRAW?") ; 
03627 --                comment use ".DRAW?" for advice only draw offer ;
03628 -4    END ELSE IF (SCORE(RTMV) < -9876)
03629 4-             THEN BEGIN
03630 --               HISTORY(I|6) := REASON(1)(0|6) ;
03631 --               IF WHO AND (QUICK OR ~TOURNAMENT)
03632 --               THEN KTEST := 1 ;
03633 -4    END ;
03634 --    NODE := IF WHO
03635 --            THEN LASTORIGIN
03636 --            ELSE ORIGIN ;
03637 --    I := I + 8 ;
03638 --    HISTORY(I|1) := IF TRY(WSIZE) = 1
03639 --                    THEN "F"
03640 --                    ELSE IF BOOK ~= 0
03641 --                         THEN "B"
03642 --                         ELSE IF NODETO(NODE,0) <= 0
03643 --                              THEN "R"
03644 --                              ELSE CODE((NODETO(NODE,0) REM 10) + 240) ;
03645 --    IF HISTORY(I|1) ~= "R"
03646 4-    THEN BEGIN
03647 --      HISTORY(I-2|1) := IF BOOK = 0 AND ~FORCEDREPLY AND PREDICT <= 0
03648 --                        THEN "#"
03649 --                        ELSE IF PREDICT >= 10
03650 --                             THEN "1"
03651 --                             ELSE IF NODETO(NODE,0) > 9
03652 --                                  THEN "."
03653 --                                  ELSE " " ;
03654 --      PREDICT := PREDICT REM 10 ;
03655 --      HISTORY(I-1|1) := IF ~FORCEDREPLY
03656 --                        THEN CODE((ABS(PREDICT) REM 10)+240)
03657 --                        ELSE " " ;
03658 --      IF ~FORCEDREPLY
03659 --      THEN IF WHO OR HISTORY(I-2|1) ~= "#"
03660 --           THEN HISTORY(I+1|1) := IF ABS(D) > 3600
03661 --                                  THEN IF D > 0
03662 --                    THEN "$"
03663 --                    ELSE "*"
03664 --                    ELSE IF ABS(D) > 2100
03665 --                         THEN IF D > 0
03666 --                              THEN ">"
03667 --                              ELSE "<"
03668 --                              ELSE IF D > 600
03669 --                                   THEN "+"
03670 --                                   ELSE IF D < -300
03671 --                     THEN "-"
03672 --                     ELSE "=" ;
03673 -4    END ;
03674 --    HISTORY(I+2|1) := IF EARLY OR ENDGAME AND ~LATE_END
03675 --                      THEN "E"
03676 --                      ELSE IF OPENING
03677 --                           THEN "O"
03678 --                           ELSE IF LATE_END
03679 --                                THEN "L"
03680 --                                ELSE "M" ;
03681 --    FORCEDREPLY := WHO AND TRY(WSIZE) = 1 ;
03682 --    CPU := TIME(1) - OLDCPU ;
03683 --    ELAPSEDTIME := TIME(-1) - SENDTIME ;
03684 --    IF (ELAPSEDTIME < 0)
03685 --    THEN ELAPSEDTIME := ELAPSEDTIME + 5184000 ;
03686 --                          COMMENT midnight correction ;
03687 --    CTIME := IF WHO
03688 --             THEN CPU
03689 --             ELSE ELAPSEDTIME ;
03690 --    CT := CTIME := (CTIME + 30) DIV 60 ;
03691 --                          COMMENT in secs. ;
03692 --    I := I + 5 ;
03693 --    WHILE (CTIME > 0)
03694 4-    DO BEGIN
03695 --      HISTORY(I|1) := CODE((CTIME REM 10) + 240) ;
03696 --      I := I - 1 ;
03697 --      CTIME := CTIME DIV 10 ;
03698 -4    END ;
03699 --    IF ~WHO AND (BOOK = 0) AND (MOVECOUNT < 16 OR ~ LOOKAHEAD)
03700 --    THEN BOOK := -1 ;
03701 --    IF ~WHO AND (KTEST = 3)
03702 --    THEN KTEST := 0 ;
03703 --    IF (KTEST <= 1 OR KTEST = 2 OR KTEST = 4) AND (RTMV ~= 0)
03704 4-    THEN BEGIN
03705 --      IF (K = -1)
03706 5-      THEN BEGIN
03707 --        MOVECOUNT := MOVECOUNT + 1 ;
03708 --        MOVES_LEFT := MOVES_LEFT - 1 ;
03709 -5      END ;
03710 --      COUNT := COUNT + 1 ;
03711 --      MMTTS(COUNT, HISTORY) ;
03712 --      MMTTS(-10008, HISTORY) ;
03713 --                        COMMENT free the history file ;
03714 --      MAKEMOVE(RTMV, TRUE) ;
03715 --      IF ENDGAME
03716 --      THEN FOR I := WQRSQ UNTIL BKRSQ
03717 --           DO IF K*BRD(I) = PAWN
03718 --              THEN IF PASSEDPAWN(I, K) > 0
03719 5-                   THEN BEGIN
03720 --                     CLEARPAWN(K) := I ;
03721 --                     IF K < 0
03722 --                     THEN GO TO DONE ;
03723 --                            COMMENT find location of most advanced passed pawn ;
03724 -5           END ;
03725 --  DONE:
03726 --      K := -K ;
03727 --                                COMMENT  switchsides. ;
03728 --      IF (CON(K,KINGSQ(-K)) ~= 0)
03729 5-      THEN BEGIN
03730 --        WRITE("KING IN CHECK, ILLEGAL") ;
03731 --        LEGAL := WHO := FALSE ;
03732 --        TRACER(9, "?DPWPBPX18") ;
03733 --        REINITIALIZE("0") ;
03734 -5      END ELSE
03735 5-      BEGIN
03736 --        ENDPLAY := IF ~REVERSIBLE
03737 --                   THEN 1
03738 --                   ELSE ENDPLAY + 1 ;
03739 --        IF ENDPLAY > 100
03740 6-        THEN BEGIN
03741 --          IF REPEATS(0) ~= -12345
03742 --          THEN REPEATS(0) := -12345
03743 --          ELSE KTEST := 3 ;
03744 --          ENDPLAY := 1 ;
03745 -6        END ;
03746 --        REPEATS(ENDPLAY) := HASH ;
03747 --        NEGA(ENDPLAY) := HISTORY(IF K = 1 THEN 115 ELSE 85 | 4) ;
03748 --        D := 0 ;
03749 --        FOR J := 1 UNTIL ENDPLAY
03750 --        DO IF (HASH = REPEATS(J))
03751 --           THEN D := D + 1 ;
03752 --        IF (D > 2)
03753 --        THEN KTEST := 3 ;
03754 --        IF CASTLING
03755 --        THEN CASTLE(0) := ~ CASTLE(0) ;
03756 --        SENDTIME := SENDTIME + ELAPSEDTIME ;
03757 --        OLDCPU := OLDCPU + CPU ;
03758 --        IF WHO
03759 6-        THEN BEGIN
03760 --          WITA := WITA + CPU ;
03761 --          if MONITOR then
03762 --          WRITEON(" Time=", CPU DIV 60, "Total=", WITA DIV 60) ;
03763 --          COMPUTERTIME := COMPUTERTIME + ELAPSEDTIME ;
03764 --          CTIME := COMPUTERTIME DIV (MOVECOUNT*60) ;
03765 --          TIME_LEFT := TIME_LEFT - ELAPSEDTIME ;
03766 --          IF CPU = 0
03767 --          THEN CPU := 1 ;
03768 --          IF BOOK <= 0 AND SKILL > "  BEGIN" OR MONITOR
03769 7-          THEN BEGIN
03770 --            I_W := 3 ;
03771 --            WRITE("CPU=", CT, " ELAPSE=", ELAPSEDTIME DIV 60, " ELA/MOVE=",
03772 --                   CTIME, " LEFT(time=", TIME_LEFT DIV 3600, " moves=",
03773 --                   MOVES_LEFT+1, ") LIMBS/SEC=", (LIMBS*60) DIV CPU) ;
03774 --            I_W := 5 ;
03775 -7          END ;
03776 -6        END ELSE
03777 6-        BEGIN
03778 --          USER := USER + CPU ;
03779 --          USERTIME := USERTIME + ELAPSEDTIME ;
03780 -6        END ;
03781 --        IOCONTROL(2) ;
03782 --        WHO := IF CBOTH
03783 --               THEN TRUE
03784 --               ELSE IF BOTH
03785 --                    THEN FALSE
03786 --                    ELSE ~ WHO ;
03787 --        IF (K = 1) AND (BOOK ~= 1) AND ((MOVECOUNT-1) REM 10 = 0)
03788 --            AND (SKILL > "  BEGINNER")
03789 --        THEN GAMERECORD(TRUE) ;
03790 --        IF (K = 1) AND MOVES_LEFT < 0
03791 --        THEN MOVES_LEFT := MOVES_LEFT + 20 ;
03792 -5      END ;
03793 -4    END ELSE WRITE("INVALID MOVE ", REASON(KTEST), RTMV, PREDICT) ;
03794 -3  END OF_FINALIZE ;
03795 --  
03796 --  PROCEDURE FINDRTMV ;
03797 --    COMMENT finds which move on the list corresponds to the input move ;
03798 3-  BEGIN
03799 --    INTEGER FROMSQ, TOSQ, FROMPC, TOPC ;
03800 --    STRING(140) BUFFER ;
03801 --  
03802 --    LOGICAL PROCEDURE MODOK (INTEGER ARRAY CM(*) ; INTEGER VALUE TM) ;
03803 --            COMMENT checks modifier of chess notation, eg., distinguishes
03804 --                    B from BP from KBP from QBP, from KN etc. ;
03805 4-    BEGIN
03806 --      INTEGER J, COL ;
03807 --      LOGICAL B, NOTKQ ;
03808 --  
03809 --      COL := COLS(TM) ;
03810 --      B := TRUE ;
03811 --      IF (CM(1) = 0)
03812 --      THEN GO TO QUIT ;
03813 --      J := 1 ;
03814 --      NOTKQ := FALSE ;
03815 --                                         COMMENT q?p ;
03816 --      IF (CM(0) ~= QUEEN)
03817 --      THEN IF (CM(0) = KING)
03818 --           THEN J := -8
03819 --                                   COMMENT k?p ;
03820 --           ELSE IF (CM(1) = KING)
03821 5-                THEN BEGIN
03822 --                  B := FALSE ;
03823 --                  IF (CM(2) = PAWN)
03824 --                  THEN B := IF (COL = 5)
03825 --                            THEN TRUE
03826 --                            ELSE FALSE
03827 --                  ELSE FOR J := +8, +7, +6, 5
03828 --                  DO IF (COL = J)
03829 --                     THEN B := TRUE ;
03830 --                  GO TO QUIT ;
03831 -5      END ELSE IF (CM(1) = QUEEN)
03832 5-               THEN BEGIN
03833 --                 B := FALSE ;
03834 --                 IF (CM(2) = PAWN)
03835 --                 THEN B := IF (COL = 4)
03836 --                           THEN TRUE
03837 --                           ELSE FALSE
03838 --                 ELSE FOR J := 4, 3, 2, 1
03839 --                 DO
03840 --                 COMMENT which q? ;
03841 --                 IF (COL = J)
03842 --                 THEN B := TRUE ;
03843 --                 GO TO QUIT ;
03844 -5      END ELSE NOTKQ := TRUE ;
03845 --                              COMMENT ?p ;
03846 --      J := ABS(J + (IF CM(1) = ROOK
03847 --                    THEN 0
03848 --                    ELSE IF CM(1) = KNIGHT
03849 --                         THEN 1
03850 --                         ELSE IF CM(1) = BISHOP
03851 --                              THEN 2
03852 --                              ELSE -J)) ;
03853 --      IF (COL = J)
03854 --      THEN GO TO QUIT
03855 --      ELSE IF NOTKQ AND (COL = 9-J)
03856 --           THEN GO TO QUIT
03857 --           ELSE B := FALSE ;
03858 --  QUIT:
03859 --      B
03860 -4    END OF_MODOK ;
03861 --  
03862 --  @TITLE, "FINDRTMV"
03863 --  
03864 --    RTMV := 0 ;
03865 --    FOR N := NUMBER(K) STEP -K UNTIL K
03866 4-    DO BEGIN
03867 --      FROMSQ := MOVEFROM(N) ;
03868 --      TOSQ := MOVETO(N) ;
03869 --      FROMPC := ABS(BRD(FROMSQ)) ;
03870 --      TOPC := ABS(BRD(TOSQ)) ;
03871 --      IF (FROMSQ ~= EMPTY)
03872 5-      THEN BEGIN
03873 --        IF (FMAN(2) = 0)
03874 --        THEN IF (ABS(REWARD(N)) REM CHECKING = REW(1))
03875 --             THEN IF (REW(1) ~= 0)
03876 6-                  THEN BEGIN
03877 --                    RTMV := N ;
03878 --                                 COMMENT castling move ;
03879 --                    GO TO QUIT ;
03880 -6        END ELSE GO TO NEXTN ;
03881 --        IF (FMAN(2) ~= FROMPC)
03882 --        THEN GO TO NEXTN ;
03883 --                   COMMENT a minor modification would allow this procedure to take
03884 --                           advantage of the fact that the moves corresponding to a
03885 --                           single piece are in a block ;
03886 --        IF (FSQ(0) ~= 0)
03887 --        THEN IF (FROMSQ ~= FSQ(0)) AND (FROMSQ ~= FSQ(1))
03888 --             THEN GO TO NEXTN ;
03889 --        IF (TMAN(2) ~= TOPC)
03890 --                          COMMENT for enpassant capture must write p*p ep. ;
03891 --        THEN GO TO NEXTN
03892 --        ELSE IF (TOPC = ENPRIS)
03893 6-             THEN BEGIN
03894 --               IF (RTMV ~= 0)
03895 --               THEN GO TO AMBIG ;
03896 --               RTMV := N ;
03897 --               GO TO NEXTN ;
03898 -6        END ;
03899 --        IF (TSQ(0) ~= 0)
03900 --        THEN IF (TOSQ ~= TSQ(0)) AND (TOSQ ~= TSQ(1))
03901 --             THEN GO TO NEXTN ;
03902 --        IF (REW(2) ~= 0)
03903 --        THEN IF (REW(2) ~= ABS (REWARD(N)) REM CHECKING)
03904 --             THEN GO TO NEXTN ;
03905 --        IF (MODOK(TMAN, TOSQ))
03906 --        THEN IF (MODOK(FMAN, FROMSQ))
03907 6-             THEN BEGIN
03908 --                                 COMMENT check specified? ;
03909 --               PUNCHBRD(TRUE, BUFFER) ;
03910 --               BASE := MOVEFROM(N) ;
03911 --               REMEMBER := TRUE ;
03912 --               MAKEMOVE(N, FALSE) ;
03913 --               IF CON(-K,KINGSQ(K)) ~= 0
03914 --               THEN NULLMOVE := TRUE
03915 --               ELSE IF (REW(0) < CHECKING OR (REW(0) >= CHECKING
03916 --                 AND CON(K,KINGSQ(-K)) ~= 0))
03917 --                    THEN IF (RTMV = 0)
03918 --                         THEN RTMV := N
03919 --                         ELSE NULLMOVE := TRUE ;
03920 --               SETBOARD(BUFFER) ;
03921 --               IF ~STARTTHISPROBLEM(TRUE)
03922 --               THEN GOTO STARTS ;
03923 --               IF NULLMOVE
03924 --               THEN REMAKE(KINGSQ(K), KINGSQ(K)) ;
03925 --               IF NULLMOVE
03926 --               THEN GO TO AMBIG ;
03927 -6        END ;
03928 -5      END ;
03929 --  NEXTN:
03930 -4    END ;
03931 --    IF (RTMV ~= 0)
03932 --    THEN GO TO QUIT ;
03933 --  AMBIG:
03934 --    MESSAGE2 := IF RTMV = 0
03935 --                THEN "NOT LEGAL"
03936 --                ELSE "AMBIGUOUS" ;
03937 --    RTMV := 0 ;
03938 --    NULLMOVE := TRUE ;
03939 --  QUIT:
03940 -3  END OF_FINDRTMV ;
03941 --  
03942 --  LOGICAL PROCEDURE GETMOVE (STRING(1) ARRAY G(*)) ;
03943 --    COMMENT converts description of chess move to internal notation ;
03944 3-  BEGIN
03945 --    INTEGER PTR, I ;
03946 --    STRING(1) T ;
03947 --    LOGICAL LEFT, SLASH, CAPT, PTRSET, PREV_ENGLISH ;
03948 --  
03949 --    MESSAGE1 := MESSAGE2 := SPACE ;
03950 --    PREV_ENGLISH := ENGLISH ;
03951 --    I := PTR := 0 ;
03952 --    WHILE (I <= CHARCOUNT)
03953 4-    DO BEGIN
03954 --      WHILE (G(I) = " ")
03955 --      DO I := I + 1 ;
03956 --      IF (G(I) = ".")
03957 --      THEN CHARCOUNT := PTR
03958 5-      ELSE BEGIN
03959 --        G(PTR) := G(I) ;
03960 --        PTR := PTR + 1 ;
03961 -5      END ;
03962 --      I := I + 1 ;
03963 -4    END ;
03964 --    CHARCOUNT := PTR - 1 ;
03965 --    FOR NOTUSED := 1,2       comment is it English or Algebraic notation? ;
03966 4-    DO BEGIN
03967 --      FOR I := 0, 1
03968 --      DO REW(I) := FMAN(I) := TMAN(I) := TSQ(I) := FSQ(I) := 0 ;
03969 --      REW(2) := FMAN(2) := TMAN(2) := 0 ;
03970 --      NULLMOVE := FALSE ;
03971 --      PREV_MESSAGE1 := MESSAGE1 ;
03972 --      PREV_MESSAGE2 := MESSAGE2 ;
03973 --      IF ~ENGLISH
03974 --      THEN ALGEBRAIC(G, CHARCOUNT+1)
03975 5-      ELSE BEGIN
03976 --        CAPT := FALSE ;
03977 --        LEFT := TRUE ;
03978 --        I := -1 ;
03979 --        PTR := 0 ;
03980 --  NOSLASH:
03981 --        SLASH := FALSE ;
03982 --  UNSET:
03983 --        PTRSET := FALSE ;
03984 --  BUMP:
03985 --        I := I + 1 ;
03986 --        T := G (I) ;
03987 --        IF (I > CHARCOUNT) OR (T = "!") OR (T = "?")
03988 --        THEN GO TO ENDRIGHT ;
03989 --        IF (T = "-")
03990 --        THEN GO TO ENDLEFT ;
03991 --        IF (T = "X") OR (T = "*")
03992 6-        THEN BEGIN
03993 --          CAPT := TRUE ;
03994 --          GO TO ENDLEFT ;
03995 -6        END ;
03996 --        IF (T = "/")
03997 6-        THEN BEGIN
03998 --          SLASH := TRUE ;
03999 --          IF (LEFT)
04000 --          THEN GETMAN (G, FMAN, PTR)
04001 --          ELSE GETMAN (G, TMAN, PTR) ;
04002 --          GO TO UNSET ;
04003 -6        END ;
04004 --        IF (T = "C") OR (T = "+") OR (T = "M")
04005 6-        THEN BEGIN
04006 --          REW(0) := REW(0) + CHECKING ;
04007 --          GO TO ENDRIGHT ;
04008 -6        END ;
04009 --        IF (T = "O") OR (T = "0")
04010 6-        THEN BEGIN
04011 --          FOR I := I+1 UNTIL CHARCOUNT
04012 --          DO IF (G(I) = "0") OR (G(I) = "O")
04013 --             THEN REW(1) := REW(1) + 1 ;
04014 --          IF (REW(1) > 0)
04015 --          THEN REW(1) := IF (REW(1) > 1)
04016 --                         THEN QSIDE
04017 --                         ELSE KSIDE ;
04018 --          GO TO QUIT ;
04019 -6        END ;
04020 --        IF (T = "=") OR (T = "(")
04021 6-        THEN BEGIN
04022 --          FOR J := KNIGHT, BISHOP, ROOK, QUEEN
04023 --          DO IF (G(I+1) = CHESSMAN(J))
04024 --             THEN REW(2) := J + PROMOTE ;
04025 --          GO TO ENDRIGHT ;
04026 -6        END ;
04027 --        IF (T = "E")
04028 --        THEN
04029 --                          COMMENT enpassant capture ;
04030 6-        BEGIN
04031 --          TMAN(2) := ENPRIS ;
04032 --          GO TO QUIT ;
04033 -6        END ;
04034 --        IF (T = "D") AND (G (I + 1) = "R")
04035 --        THEN KTEST := 3
04036 --        ELSE IF (T = "R") AND (G (I + 3) = "I")
04037 --             THEN KTEST := 1 ;
04038 --        IF (KTEST ~= 0)
04039 6-        THEN BEGIN
04040 --          IF (KTEST = 1)
04041 --          THEN MESSAGE1 := "RESIGNATION ACCEPTED"
04042 --          ELSE IF (KTEST = 3)
04043 --               THEN IF (SCORE(RTMV) < PAWNVALUE)
04044 --                    THEN MESSAGE1 := "DRAW ACCEPTED."
04045 --                    ELSE NULLMOVE := TRUE ;
04046 --          IF ~NULLMOVE AND (LEFT OR (KTEST ~= 1))
04047 --          THEN GO TO STARTS ;
04048 --          IF LEFT
04049 --          THEN GO TO QUIT ;
04050 --          NULLMOVE := FALSE ;
04051 --          GO TO ENDRIGHT ;
04052 -6        END ;
04053 --        IF (~ PTRSET)
04054 6-        THEN BEGIN
04055 --          PTR := I ;
04056 --          PTRSET := TRUE ;
04057 -6        END ;
04058 --        GO TO BUMP ;
04059 --  ENDLEFT:
04060 --        LEFT := FALSE ;
04061 --        IF SLASH
04062 --        THEN GETSQ(G, FSQ ,PTR)
04063 --        ELSE GETMAN(G, FMAN, PTR) ;
04064 --        GO TO NOSLASH ;
04065 --  ENDRIGHT:
04066 --        IF CAPT AND ~ SLASH
04067 --        THEN GETMAN(G, TMAN, PTR)
04068 --        ELSE GETSQ(G, TSQ, PTR) ;
04069 --  QUIT:
04070 -5      END ;
04071 --      IF ~NULLMOVE
04072 --      THEN FINDRTMV ;
04073 --      IF ~NULLMOVE
04074 --      THEN GO TO EXIT_THIS_LOOP ;
04075 --      ENGLISH := ~ENGLISH ;
04076 -4    END FORLOOP ;
04077 --    WRITE(PREV_MESSAGE1) ;
04078 --    WRITE(PREV_MESSAGE2) ;
04079 --  EXIT_THIS_LOOP:
04080 --                      COMMENT do not reset the notation just because of the book ;
04081 --    IF WHO
04082 --    THEN ENGLISH := PREV_ENGLISH ;
04083 --    ~NULLMOVE
04084 -3  END OF_GETMOVE ;
04085 --  
04086 --  PROCEDURE HUB ;
04087 --    COMMENT   central hub of chess program. ;
04088 3-  BEGIN
04089 --    SETUP ;
04090 --    WHILE (KTEST = 0)
04091 4-    DO BEGIN
04092 --      IF K = 1 AND (EXAMINE OR (MOVECOUNT REM 5) = 1)
04093 5-      THEN BEGIN
04094 --        WRITE(" ") ;
04095 --        WRITE("Awit = ", COMPUTERTIME DIV 3600, " MIN.  ",
04096 --          "USER = ", USERTIME DIV 3600, " MIN.") ;
04097 --        IF TEST
04098 --        THEN WRITE("(CPU:  Awit = ", WITA DIV 60, " SECS.",
04099 --          " USER = ", USER DIV 60, " SECS.)") ;
04100 --        WRITE(" ") ;
04101 --        IF CBOTH
04102 6-        THEN BEGIN
04103 --          if new_count > 0
04104 --          then write("Lost space for ", new_count, "node(s) ") ;
04105 --  loop:
04106 --          WRITE("SHALL I CONTINUE (Yes or No)?") ;
04107 --          WHILE READU
04108 --          DO TRACER(CHARCOUNT, BUFFER(0|20)) ;
04109 --          if Valid_Command
04110 --          then goto loop
04111 --          else
04112 --          IF (U(0) = "N")
04113 --          THEN BOTH := WHO := CBOTH := FALSE
04114 --          else if U(0) ~= "Y" then goto loop ;
04115 -6        END ;
04116 -5      END ;
04117 --      if STARTTHISPROBLEM(TRUE) then ;
04118 --         comment the above is a safety precaution and an attempt
04119 --                 to make self-play mode consistent with manual play mode ;
04120 --      VALUES(BISHOP) := VALUES(KNIGHT)
04121 --                           + (IF ENDGAME OR PIECES(-BISHOP) < 2
04122 --                                  AND PIECES(BISHOP) < 2
04123 --                              THEN 0
04124 --                              ELSE 2) ;
04125 --      PREDICT := DEBIT(0) := DEBIT(-1) := CREDIT(0) := CREDIT(-1) := 0 ;
04126 --      LASTSQ(-1) := LASTSQ(0) ;
04127 --      LASTDIR(-1) := LASTDIR(0) ;
04128 --      LASTSQ(0) := LASTSQ(1) ;
04129 --      LASTDIR(0) := LASTDIR(1) ;
04130 --      UPPER := EIGHTS ;
04131 --      LEVEL := 1 ;
04132 --      IF (WHO)
04133 --      THEN COMPUTER
04134 --      ELSE OPPONENT ;
04135 --      IF ~WHO
04136 --      THEN SKTEST := KTEST ;
04137 --      IF NULLMOVE
04138 5-      THEN BEGIN
04139 --        NULLMOVE := FALSE ;
04140 --        WHO := TRUE ;
04141 --        REPLY := WSIZE ;
04142 -5      END ELSE FINALIZE ;
04143 5-      if new_count < 0 then begin
04144 --        TRACER(1, "?G") ;
04145 --        writeon("new_count= ", new_count) ;
04146 --        new_count := abs(new_count) ;
04147 -5      end ;
04148 -4    END ;
04149 --  QUITting:  comment KTEST ~= 0 ;
04150 --    WRITE(REASON(KTEST)) ;
04151 --    PRINTSHORTBRD(1) ;
04152 --    TRACER(5, "?SPDGD") ;
04153 -3  END OF_HUB ;
04154 --  
04155 --  COMMENT **************opponent***************** ;
04156 --  
04157 --  PROCEDURE OPPONENT ;
04158 --    COMMENT makes moves read from teletype ;
04159 3-  BEGIN
04160 --    INTEGER NUMS, N, MF, MT, RE ;
04161 --    LOGICAL PREDICTOR ;
04162 --  
04163 --    IF LEGAL
04164 4-    THEN BEGIN
04165 --      SCORES := IF (BOOK <= 0) AND (REPLY < 1
04166 --                    OR (REPLY > NODETO(ORIGIN,0)))
04167 --                THEN TRUE
04168 --                ELSE FALSE ;
04169 --      WRITE(COLOR(K), "'S MOVE ", MOVECOUNT, BELL) ;
04170 --      FOR I := 1 UNTIL 1 DO WRITEON(BELL) ;
04171 --      IOCONTROL(2) ;
04172 --      LISTLEGALMOVES (FALSE) ;
04173 -4    END ELSE LEGAL := TRUE ;
04174 --    IF (NUM ~= 0)
04175 4-    THEN BEGIN
04176 --      IF COKO AND FALSE
04177 --      THEN GET(7) ;
04178 --                          COMMENT take input from unit 7 ;
04179 --      IF (BOOK = 1)
04180 --      THEN CREATEBOOK ;
04181 --                          COMMENT coko input restored in readu ;
04182 --      IF MOVES_LEFT < 20
04183 --      THEN WRITE("Use ?Y to update internal clock and move count") ;
04184 --  THINK:
04185 --      IF THINKING AND ORIGIN > 0 AND NODETO(ORIGIN,0) > 0 AND KTEST = 0
04186 5-      THEN BEGIN
04187 --        FLAG(1) := 0 ;
04188 --        RESTORESTATE(ORIGIN) ;
04189 --        RTMV := TRY(1) ;
04190 --        REPLY := 1 ;
04191 --        WRITE("Assuming ") ;
04192 --        PRINTLINE(RTMV, 2) ;
04193 --        FOR I := 2 UNTIL 5 DO
04194 --          IF I <= TRY(WSIZE)
04195 --          THEN PRINTLINE(TRY(I), 4) ;
04196 --        FINALIZE ;
04197 --        WHO := FALSE ;
04198 --        COMPUTER ;
04199 --        FINALIZE ;
04200 --        WHO := FALSE ;
04201 --        SCORES := TRUE ;
04202 --        IF FLAG(1) = 0
04203 --        THEN WRITE("If bad prediction, enter '?R1'")
04204 6-        ELSE BEGIN
04205 --          TRACER(2, "?R1") ;
04206 --          ORIGIN := -1 ;
04207 --          GO TO THINK ;
04208 -6        END ;
04209 --        WRITE("Type OK to accept assumed move") ;
04210 --        WRITE("Hit BREAK key to regain control") ;
04211 -5      END ;
04212 --  LOOP:
04213 --      IF (BOOK < 1)
04214 --      THEN WHILE READU
04215 --      DO TRACER(CHARCOUNT, BUFFER(0|20)) ;
04216 --      IF THINKING AND BUFFER(0|2) = "OK"
04217 --      THEN GOTO THINK
04218 --      ELSE if Valid_Command
04219 --           then goto loop ;
04220 --      IF BUFFER(0|4) = "PLAY"
04221 5-      THEN begin
04222 --        NULLMOVE := TRUE
04223 -5      end
04224 5-      ELSE BEGIN
04225 --        IF ~GETMOVE(U)
04226 6-        THEN BEGIN
04227 --          BOOK := 0 ;
04228 --          WRITE(" TRY AGAIN ") ;
04229 --          FOR I := 0 UNTIL CHARCOUNT
04230 --          DO WRITEON(U(I)) ;
04231 --          GO TO LOOP ;
04232 -6        END ;
04233 --        IF LOOKAHEAD AND BOOK = 0 OR EXAMINE OR SCORES
04234 6-        THEN BEGIN
04235 --          MF := MOVEFROM(RTMV) ;
04236 --          MT := MOVETO(RTMV) ;
04237 --          RE := ABS(REWARD(RTMV)) REM CHECKING ;
04238 --          N := IF EXAMINE AND ~ SCORES
04239 --               THEN NODETO(ORIGIN, REPLY)
04240 --               ELSE -1 ;
04241 --          IF EXAMINE AND N > 0
04242 --          THEN RESTORE(N)
04243 7-          ELSE begin
04244 --            IF LOOKAHEAD AND ORIGIN ~= GETNODE(1) AND ~SCORES
04245 --                   AND (((REPLY > 0) AND (REPLY <= WIDTH)) AND (ORIGIN > 0))
04246 --            THEN RESTORE(ORIGIN) ;
04247 -7          end ;
04248 --          IF EXAMINE
04249 --          THEN TRACER(2, "?DP") ;
04250 --          N := (MAX_WID+1) ;
04251 --          FOR I := 1 UNTIL TRY(WSIZE)
04252 --          DO IF (MF = MOVEFROM(TRY(I)))
04253 --             THEN IF (MT = MOVETO(TRY(I)))
04254 --                  THEN IF (RE <= PFTWO) OR RE = ABS(REWARD(TRY(I))) REM CHECKING
04255 --                       THEN N := I ;
04256 --          PREDICT := IF N > MAX_WID AND TRY(WSIZE) > 1
04257 --                        OR LOOKAHEAD AND (N > NODETO(ORIGIN,0))
04258 --                     THEN -N
04259 --                     ELSE N ;
04260 --                              COMMENT do not build tree if reply is not in
04261 --                                          window ;
04262 --          IF EXAMINE AND (N <= MAX_WID)
04263 7-          THEN BEGIN
04264 --            FLAG(1) := 0 ;
04265 --            SEARCH ;
04266 --            TRACER(1, "?D") ;
04267 --            FLAG(1) := 1 ;
04268 --            REPLY := MAX_WID + 1 ;
04269 --            FOR I := 1 UNTIL TRY(WSIZE)
04270 --            DO IF (MF = MOVEFROM(TRY(I))) AND (MT = MOVETO(TRY(I)))
04271 --               THEN IF (RE <= PFTWO)
04272 --                    THEN REPLY := I
04273 --                    ELSE IF RE = ABS(REWARD(TRY(I))) REM CHECKING
04274 --                         THEN REPLY := I ;
04275 -7          END ELSE REPLY := N ;
04276 --          IF ~ WS OR ~ BOTH
04277 --          THEN IF (REPLY <= WIDTH)
04278 --               THEN RTMV := TRY(REPLY)
04279 7-               ELSE BEGIN
04280 --                 LISTMOVES ;
04281 --                 FINDRTMV ;
04282 -7               END ;
04283 --          IF EXAMINE
04284 7-          THEN BEGIN
04285 --               COMMENT have experienced severe problems with use of ?g. Need
04286 --                       to restore the window array, try. As a result parts
04287 --                       of the movelist are overlayed, but cannot guarantee
04288 --                       that the moves in the window overlay themselves ;
04289 --  
04290 --            MF := 0 ;
04291 --            NUMS := NODETO(ORIGIN,0) ;
04292 --            IF (REPLY > NUMS)
04293 --            THEN MF := IF (REPLY > WIDTH)
04294 --                       THEN 0
04295 --                       ELSE -REPLY
04296 --            ELSE FOR I := 1 UNTIL NUMS
04297 --            DO IF SCORE(TRY(I)) >= SCORE(RTMV)
04298 --               THEN MF := MF + 1 ;
04299 --            WRITE(RTMV, "WAS SELECTED, IT WAS", MF,
04300 --              "IN MY LIST, ORIGINALLY", REPLY, TRY(0)) ;
04301 --            DESCRIBEMOVE(RTMV, MC) ;
04302 --            IOCONTROL(2) ;
04303 --            FOR I := 0 UNTIL 23
04304 --            DO WRITEON(MC(I)) ;
04305 --            IF (MF <= 0)
04306 --            THEN REPLY := 0 ;
04307 -7          END ;
04308 --          if BOTH and ~CBOTH and ORIGIN > 0 then
04309 7-          if REPLY <= NODETO(ORIGIN,0) and NODETO(ORIGIN,REPLY) > 0 then begin
04310 --            for i := 1 until NODETO(ORIGIN,0)
04311 --            do if i ~= REPLY
04312 --               then Reclaim_Node(NODETO(ORIGIN,i), "OPPON-1") ;
04313 --            LASTORIGIN := ORIGIN ;
04314 --            ORIGIN := NODETO(LASTORIGIN,REPLY) ;
04315 --            NODETO(LASTORIGIN,0) := -1 ;
04316 --            Reclaim_Node(LASTORIGIN, "OPPON-2") ;
04317 --            NODETO(LASTORIGIN,0) := REPLY ;
04318 -7          end else INIT_TREE ;
04319 -6        END ELSE REPLY := 0 ;
04320 -5      END ;
04321 --      FOR I := 0 UNTIL 23
04322 --      DO MC(I) := U(I) ;
04323 --      FOR I := CHARCOUNT+1 UNTIL 23
04324 --      DO MC(I) := " " ;
04325 -4    END ELSE
04326 4-    begin
04327 --       write("Mate (or perhaps StaleMate) -- No moves") ;
04328 --       tracer(2, "?SP") ;
04329 --       GO TO STARTS ;
04330 -4    end ;
04331 -3  END OF_OPPONENT ;
04332 --  
04333 --  LOGICAL PROCEDURE Valid_Command ;
04334 3-  begin
04335 --      IF BUFFER(0|5) = "BLITZ"
04336 4-      THEN BEGIN
04337 --        BLITZ ;
04338 --        true
04339 -4      END ELSE IF BUFFER(0|5) = "INTER"
04340 4-               THEN BEGIN
04341 --                 INTERMEDIATE ;
04342 --                 true
04343 -4      END ELSE IF BUFFER(0|5) = "EXPER"
04344 4-               THEN BEGIN
04345 --                 EXPERIMENTAL ;
04346 --                 true
04347 -4      END ELSE IF BUFFER(0|5) = "TOURN"
04348 4-               THEN BEGIN
04349 --                 TOURNAMENTS ;
04350 --                 true
04351 -4      END ELSE IF BUFFER(0|4) = "SWAP"
04352 4-               THEN BEGIN
04353 --                 K := -K ;
04354 --                 WRITE("SIDES SWAPPED. CONTINUE.") ;
04355 --                 IOCONTROL(2) ;
04356 --                 true
04357 -4      end ELSE IF BUFFER(0|3) = "PAB"
04358 4-               THEN BEGIN
04359 --                 PAB := ~PAB ;
04360 --                 WRITE("Palphabeta", PAB) ;
04361 --                 true
04362 -4      END ELSE if buffer(0|4) = "FLIP"
04363 4-               then begin
04364 --                 Flipper ;
04365 --                 TRACER(2, "?ZK") ;
04366 --                 true
04367 -4      end ELSE IF BUFFER(0|6) = "DUMMY4"
04368 4-               THEN BEGIN
04369 --                 dummy4 := ~dummy4 ;
04370 --                 WRITE("DUMMY4", dummy4) ;
04371 --                 true
04372 -4      end ELSE IF BUFFER(0|6) = "DUMMY5"
04373 4-               THEN BEGIN
04374 --                 dummy5 := ~dummy5 ;
04375 --                 WRITE("DUMMY5", dummy5) ;
04376 --                 true
04377 -4      end ELSE IF BUFFER(0|6) = "DUMMY6"
04378 4-               THEN BEGIN
04379 --                 dummy6 := ~dummy6 ;
04380 --                 WRITE("DUMMY6", dummy6) ;
04381 --                 true
04382 -4      end ELSE IF BUFFER(0|4) = "WARN"
04383 4-               THEN BEGIN
04384 --                 warning := ~warning ;
04385 --                 WRITE("WARNING", warning) ;
04386 --                 true
04387 -4      end else false
04388 -3  END OF_Valid_Command ;
04389 --  
04390 --  PROCEDURE REINITIALIZE (STRING(1) VALUE CHAR) ;
04391 3-  BEGIN
04392 --    INTEGER M, MM ;
04393 --  
04394 --    M := DECODE(CHAR) - 240 ;
04395 --    IF (M < 0) OR (M > 9)
04396 --    THEN GO TO QUIT ;
04397 --    COUNT := COUNT - M ;
04398 --    IF (COUNT < 0)
04399 --    THEN COUNT := 1 ;
04400 --                       COMMENT newgame := false ;
04401 --    MM := ((M + (IF (K = 1)
04402 --                  THEN 2
04403 --                  ELSE 1)) DIV 2) ;
04404 --    MOVECOUNT := MOVECOUNT - MM ;
04405 --    MOVES_LEFT := MOVES_LEFT + MM ;
04406 --    IF ((M REM 2) = 0)
04407 --    THEN K := -K ;
04408 --    MMTTS(-COUNT, HISTORY) ;
04409 --    SETBOARD(HISTORY) ;
04410 --    COUNT := COUNT - 1 ;
04411 --    WRITE(COLOR(K), "'S MOVE ", MOVECOUNT, BELL) ;
04412 --    IF STARTTHISPROBLEM(TRUE)
04413 --    THEN LISTLEGALMOVES(FALSE)
04414 --    ELSE GO TO STARTS ;
04415 --    INIT_TREE ;
04416 --    HASH := NEWHASH(BRD, K, KEY) ;
04417 --    ENDPLAY := IF (ENDPLAY > M)
04418 --               THEN ENDPLAY - M - 1
04419 --               ELSE 0 ;
04420 --               COMMENT if retracting over an irreversible move it is necessary
04421 --                       to reconstruct earlier history--for proper draw detection ;
04422 --  QUIT:
04423 -3  END OF_REINITIALIZE ;
04424 --  
04425 --  PROCEDURE SELECTRTMV (LOGICAL VALUE LOSING) ;
04426 --    COMMENT  choose the move with the highest score ;
04427 3-  BEGIN
04428 --    INTEGER NN, J, I, JJ, SQ, BESTSCORE, TEMP, MINSCR, SCR, SUFFICE, X,
04429 --            Y, PAST, PRES, WID ;
04430 --                       COMMENT   score all the moves ;
04431 --    WID := IF ALTERNATIVE
04432 --           THEN CAPT_WID
04433 --           ELSE MAX_WID ;
04434 --    IF ALTERNATIVE
04435 --    THEN CAPT_ORDER(BESTSCORE, LOSING)
04436 --    ELSE MOBILITYSCORE(BESTSCORE) ;
04437 --    SPAN(K) := SPAN(0) := NUM ;
04438 --                       COMMENT   put the "width" best moves into array try. ;
04439 --    i := NN := 0 ;
04440 --    FOR N := K STEP K UNTIL NUMBER(K)
04441 4-    DO BEGIN
04442 --      SCR := SCORE(N) ;
04443 --                   COMMENT  mate, dbl ch., and forcing moves ;
04444 --      IF ~ALTERNATIVE
04445 --      THEN IF (ABS(SCR) > SEVENS) OR (ABS(REWARD(N)) >= TWOCHECK)
04446 --           THEN IF (BESTSCORE < SEVENS) AND SCR > -NINES
04447 --                THEN SCORE(N) := SCR :=
04448 --                              BESTSCORE - (BESTSCORE -SCR) DIV 100 ;
04449 --      IF (SCR ~= BAD)
04450 5-      THEN BEGIN
04451 --        FOR IX := 1 UNTIL NN
04452 --        DO IF (SCR > SCORE(TRY(IX)))
04453 6-           THEN BEGIN
04454 --             I := IX ;
04455 --             FOR JJ := NN STEP -1 UNTIL I
04456 --             DO TRY(JJ+1) := TRY(JJ) ;
04457 --             GO TO FOUND ;
04458 -6        END ;
04459 --        I := NN + 1 ;
04460 --  FOUND:
04461 --        COMMENT IF (NN < WID) THEN NN := NN + 1 ;
04462 --        IF (NN < MAX_WID)
04463 --        THEN NN := NN + 1 ;    comment ensure NN < w_size ;
04464 --        TRY(I) := N ;          comment could clobber try(wsize), but probably OK ;
04465 -5      END ;
04466 -4    END ;
04467 --    BESTSCORE := SCORE(TRY(1)) ;
04468 --                       COMMENT   the best moves are now ordered. ;
04469 --    SUFFICE := IF (LEVEL < 3)
04470 --               THEN DRAW
04471 --               ELSE PAWNVALUE ;
04472 --    J := IF ALTERNATIVE
04473 --         THEN 1
04474 --         ELSE 2 ;
04475 --    comment i is nn+1 and that could equal wsize.
04476 --            Would be wrong to change try(wsize) here ;
04477 4-    if (NN > w_size) then begin
04478 --      write("selectrtmv overflow", I, "nn", NN, MAX_WID, "wid", WID,
04479 --            "try(w)", TRY(WSIZE), "try(0)", TRY(0)) ;
04480 --      for xx := 1 until NN
04481 --      do PRINTLINE(TRY(xx), 0) ;
04482 -4    end else
04483 --    TRY(NN+1) := 0 ;
04484 --    IF NN <= 1
04485 4-    THEN BEGIN
04486 --      if NN < 0 then write ("selectrtmv error NN is negative", NN) ;
04487 --      TRY(0) := TRY(WSIZE) := NN ;       comment reset try(wsize) ;
04488 --      RTMV := TRY(NN) ;                  comment rtmv is 0 if nn is 0 ;
04489 -4    END ELSE
04490 4-    BEGIN
04491 --      PAST := TRY(1) ;
04492 --      X := ABS(REWARD(PAST)) ;
04493 --      MINSCR := SCORE(TRY(IF NN > WID
04494 --                          THEN WID
04495 --                          ELSE NN)) ;
04496 --      FOR I := J UNTIL NN
04497 5-      DO BEGIN
04498 --        PRES := TRY(I) ;
04499 --        SCR := SCORE(PRES) ;
04500 --        Y := ABS(REWARD(PRES)) ;
04501 --        IF (Y = 2) AND (X = 1)
04502 --        THEN Y := 0 ;
04503 --        IF (ABS(BESTSCORE - SCR) < SUFFICE)
04504 --        THEN J := I ;
04505 --        TEMP := SCORE(PAST) - SCR ;
04506 --        IF ~CAPTURE_TREE OR LEVEL > 2
04507 --        THEN IF (TEMP < EPSILON) AND (TEMP > DELTA)
04508 --             THEN IF Y > X AND (y >= DISCHECK and y < TWOCHECK)
04509 6-             THEN BEGIN
04510 --                          COMMENT if too many disc. ch., do not re-order ;
04511 --               TRY(I-1) := PRES ;
04512 --               TRY(I) := PAST ;
04513 --               IF I = 2 THEN SCORE(PRES) := SCORE(PAST) ;
04514 --               IF I = 2 THEN REWARD(PRES) := -ABS(REWARD(PRES)) ;
04515 --               PRES := PAST ;
04516 --               Y := X ;
04517 -6        END ;
04518 --        PAST := PRES ;
04519 --        X := Y ;
04520 -5      END ;
04521 --      JJ := J ;
04522 --      IF ~ALTERNATIVE
04523 --      THEN FOR I := 3 UNTIL NN
04524 5-           DO BEGIN
04525 --             J := I ;
04526 --             WHILE(J <= NN AND MOVEFROM(TRY(J)) = MOVEFROM(TRY(I-1)))
04527 --             DO J := J + 1 ;
04528 --             IF (J <= NN) AND (J > I)
04529 --                 AND (SCORE(TRY(I)) -SCORE(TRY(J)) < PAWNVALUE)
04530 6-             THEN BEGIN
04531 --                        COMMENT break up long sequences of moves with same piece ;
04532 --               PRES := TRY(J) ;
04533 --               FOR L := J STEP -1 UNTIL I+1
04534 --               DO TRY(L) := TRY(L-1) ;
04535 --               IF (J > JJ) AND (I <= JJ)
04536 --               THEN JJ := JJ + 1 ;
04537 --               TRY(I) := PRES ;
04538 -6             END ;
04539 -5      END ;
04540 --                             COMMENT   used by search and tree ;
04541 --      NN := IF (NN > WID)
04542 --            THEN WID
04543 --            ELSE NN ;
04544 --      TRY(0) := IF (JJ > NN)
04545 --                THEN NN
04546 --                ELSE JJ ;
04547 --      J := IF (MOVECOUNT > 2) OR ~NEWGAME or MONITOR
04548 --           THEN 1
04549 --           ELSE (TIME(-1) REM TRY(0)) + 1 ;
04550 --      if J = 0 or J > TRY(0) then write("Move Choice Error") ;
04551 --      RTMV := TRY(J) ;
04552 --      IF DEBUG
04553 --      THEN WRITE("SELE", NUM, BESTSCORE, J, RTMV, JJ, NN, WID, EARLY, OPENING,
04554 --                  ALTERNATIVE, LATE_END, MEN(K), PIECES(0)) ;
04555 --      IF SCORE(TRY(NN-1)) <= MINSCR
04556 --      THEN SCORE(TRY(NN-1)) := SCORE(TRY(NN)) ;
04557 --      if NN < WSIZE
04558 --      then TRY(WSIZE) := NN
04559 --                 comment reset try(wsize) ;
04560 5-      else begin
04561 --        TRY(WSIZE) := TRY(0) ;            comment reset try(wsize) ;
04562 --        write("Select-rtmv clobber of try(wsize) avoided") ;
04563 -5      end ;
04564 --                             COMMENT IF TEST AND ALTERNATIVE THEN PRINTMOVES(K) ;
04565 -4    END ;
04566 -3  END OF_SELECTRTMV ;
04567 --  
04568 --  PROCEDURE SETUP ;
04569 3-  BEGIN
04570 --    INTEGER L ;
04571 --  
04572 --    IF (MOVECOUNT > 0)
04573 4-    THEN BEGIN
04574 --      WRITE("FAILURE.  ", "Either type REPEAT, or") ;
04575 --      IF (MOVECOUNT -INITIALCNT > 5) OR CAPTURE_TREE AND SKILL(0|1) ~= " "
04576 --      THEN GAMERECORD(TRUE) ;
04577 -4    END ;
04578 --    BOOK := -1 ;
04579 --    WRITE("New game? (YES or NO)") ;
04580 --    WHILE READU
04581 --    DO TRACER(CHARCOUNT, BUFFER(0|20)) ;
04582 --                             COMMENT delay initialization ;
04583 --    LEVEL := 0 ;
04584 --    DEBIT(-1) := CREDIT(0) := CREDIT(-1) := 0 ;
04585 --    KTEST := ONEVAL := TWOVAL := NUM := MOVEFROM(N) := SKTEST := N := 0 ;
04586 --    FOR L := -1 UNTIL 1
04587 --    DO SPAN(L) := NUMBER(L) := 0 ;
04588 --    REMEMBER := TERMINAL := LEGAL := TRUE ;
04589 --    LOSS(ELIMIT) := SQUARE(ELIMIT) := ELIMIT ;
04590 --    LOSS(0) := SQUARE(0) := 0 ;
04591 --    LASTSQ(0) := LASTSQ(1) := 0 ;
04592 --    LASTDIR(0) := LASTDIR(1) := 0 ;
04593 --    IF (U(0) = "R")
04594 --    THEN GO TO START ;
04595 --    BOOKMOVE := DUP := REC := NOD := SAL := LIMBS := 0 ;
04596 --    TOT := DYN := CAP := BRAN := BRAN_S := REC_S := DUP_S := 0 ;
04597 --    TRY(0) := 0 ;
04598 --    REPLY := WSIZE ;
04599 --    BOTH := CBOTH := ALTERNATIVE := FALSE ;
04600 --    K := NUMB := -1 ;
04601 --    USER := TIME(1) ;
04602 --    CPU := ELAPSEDTIME := USERTIME := COMPUTERTIME := WITA := 0 ;
04603 --    MOVETIME := 180 ;
04604 --    ENDPLAY := 1 ;
04605 --    MOVECOUNT := 0 ;
04606 --                             COMMENT *P AND *3 PROTECTION ;
04607 --    HISTORY(115|25) := HISTORY(85|25) := "    ....            " ;
04608 --    HISTORY(105|10) := "     ( 0) " ;
04609 --    NEWGAME := IF (U(0) = "N")
04610 --               THEN FALSE
04611 --               ELSE TRUE ;
04612 --  AGAIN:
04613 --    IF NEWGAME
04614 --    THEN BUFFER := "RNBQKBNRPPPPPPPP+888888PPPPPPPPRNBQKBNR+"
04615 4-    ELSE BEGIN
04616 --      WRITE("Enter the board (in quasi Forsythe notation)") ;
04617 --      WHILE READU
04618 --      DO TRACER(CHARCOUNT, BUFFER(0|20)) ;
04619 -4    END STARTOLDGAME ;
04620 --    SETBOARD(BUFFER) ;
04621 --    IF ~NEWGAME AND (MOVECOUNT <= 1)
04622 --    THEN MOVECOUNT := 17 ;
04623 --    MOVES_LEFT := 40 - (MOVECOUNT REM 40) ;
04624 --    TIME_LEFT := 324000 ;
04625 --                             COMMENT 90 MINS. ;
04626 --    INITIALCNT := MOVECOUNT ;
04627 --    HISTORY(0|78) := BUFFER(0|78) ;
04628 --    FOR I := -3 UNTIL 3
04629 --    DO HISTORY(I+81|1) := IF CASTLE(I)
04630 --                          THEN "T"
04631 --                          ELSE "F" ;
04632 --  START:
04633 --                            COMMENT REFLECT(BRD) ;
04634 --    IF ~STARTTHISPROBLEM(TRUE)
04635 --    THEN GO TO AGAIN ;
04636 --    OPEN(1) := OPEN(-1) := EARLY := TRUE ;
04637 --    WHO := ENDGAME := FALSE ;
04638 --    IF (~NEWGAME)
04639 4-    THEN BEGIN
04640 --      PRINTSHORTBRD(-1) ;
04641 --      BOOK := 0 ;
04642 -4    END ;
04643 --    LENGTH := MAXLEV ;
04644 --    MODE := IF (MAXTREE = 15)
04645 --             THEN 1                                    comment DEBUG ;
04646 --             ELSE IF (LENGTH > 7) AND (MAXTREE > 999)
04647 --                  THEN 6                               comment EXPERIMENTAL ;
04648 --                  ELSE IF LENGTH > 5
04649 --                       THEN 5                          comment TOURNAMENT ;
04650 --                       ELSE IF (LENGTH > 3)
04651 --                            THEN 4                     comment INTERMEDIATE ;
04652 --                            ELSE IF ~CAPTURE_TREE
04653 --                                 THEN 2                comment SPEED ;
04654 --                                 ELSE 3 ;              comment BEGINNER ;
04655 --    SKILL := CASE MODE OF ("   DEBUG", "   SPEED", "  BEGINNER",
04656 --      "INTERMEDIATE", "TOURNAMENT", "EXPERIMENTAL") ;
04657 --    FOR I := 1 UNTIL 10
04658 --    DO M_TIMES(I) := 60*(CASE I OF (1, 12, 20, 30, 90, 120, 600, 0, 0, 0))
04659 --     ;
04660 --    M_TIMES(0) := M_TIMES(MODE) DIV 3 ;
04661 --    INIT_TREE ;
04662 --    IF (SKILL = "EXPERIMENTAL")
04663 --    THEN QUICK := FALSE
04664 --    ELSE IF (SKILL ~= "INTERMEDIATE")
04665 --         THEN TOURNAMENT := FALSE ;
04666 --    WRITE(SKILL, " Mode") ;
04667 --      writeon(mode, "Length", length, "width", width, "maxtree", maxtree);
04668 --    WRITE("Enter your move or type PLAY") ;
04669 --    SENDTIME := TIME(-1) ;
04670 --    OLDCPU := TIME(1) ;
04671 --    HASH := NEWHASH(BRD, K, KEY) ;
04672 --    REPEATS(ENDPLAY) := HASH ;
04673 --    IF (K < 0) AND INITIALCNT = MOVECOUNT
04674 4-    THEN BEGIN
04675 --                              COMMENT  not repeating part of continuing game ;
04676 --      COUNT := COUNT + 1 ;
04677 --      MMTTS(COUNT, HISTORY) ;
04678 -4    END ;
04679 --    WHO := IF CBOTH
04680 --           THEN TRUE
04681 --           ELSE FALSE ;
04682 -3  END OF_SETUP ;
04683 --  
04684 --  PROCEDURE TAKEBACKMOVE (LOGICAL VALUE HALF_DONE) ;
04685 --    COMMENT  retracts last move made by makemove during mobilityscore. ;
04686 3-  BEGIN
04687 --    INTEGER K, LL ;
04688 --  
04689 --    LOSS(ELIMIT) := SQUARE(ELIMIT) ;
04690 --    K := IF (M5 > 0)
04691 --         THEN 1
04692 --         ELSE -1 ;
04693 --    IF HALF_DONE
04694 4-    THEN BEGIN
04695 --      IF M7 ~= 0 AND (ABS(M7) < KING OR ABS(M5) = PAWN)
04696 5-      THEN BEGIN
04697 --        MEN(-K) := MEN(-K) + 1 ;
04698 --           COMMENT PIECES(M6) := PIECES(M6) + 1 ;
04699 --           COMMENT PIECES(0) := PIECES(0) + 1 ;
04700 -5      END ;
04701 --      LL := 0 ;
04702 --      LOSS(0) := SQUARE(0) ;
04703 -4    END ELSE LL := 2 ;
04704 --    IF ABS(M5) = KING
04705 --    THEN KINGSQ(K) := M2 ;
04706 --    IF M11 > 0 AND M11 ~= M3
04707 --    THEN BRD(M11) := -K*ENPRIS ;
04708 --    IF (M9 > 0)
04709 --    THEN BRD(M9) := IF M8 = 0
04710 --                    THEN -K*PAWN
04711 --                    ELSE K*ROOK ;
04712 --    UNMAKE(M3) ;
04713 --    IF (M8 > 0)
04714 --    THEN UNMAKE(M8) ;
04715 --    BRD(M2) := M5 ;
04716 --    BRD(M3) := M7 ;
04717 --    IF (M9 > 0)
04718 --    THEN MAKE(M9) ;
04719 --    IF (M7 ~= 0)
04720 --    THEN MAKE(M3) ;
04721 --                       COMMENT   restore captured piece. ;
04722 --    MAKE(M2) ;
04723 --                    COMMENT  retract promotion. ;
04724 --    IF M14 ~= 0
04725 --    THEN IF ~STARTTHISPROBLEM(TRUE)
04726 --         THEN WRITE("TAKE", M8, M9, M11, M14) ;
04727 --               COMMENT IF TEST AND (DEBUG OR LL = 0) THEN
04728 --                   WRITE("TAKE", LL, NUMB, MEN(-1), MEN(1), LEVEL, M2, M3, M8, M9,
04729 --                          SEC(0,M3), M11, M14, BRD(M3), CON(-K,M2), MAKEMV) ;
04730 --    FOR II := NUMB STEP -1 UNTIL LL
04731 --    DO REMAKE(RLIST(II), TLIST(II)) ;
04732 --    IF (ABS(M5) = KING)
04733 --    THEN KINGCONTROL(K) ;
04734 --    IF MEN(1) + MEN(-1) ~= PIECES(0)
04735 4-    THEN BEGIN
04736 --      WRITE("CONSISTENCY ", MEN(1), MEN(-1), PIECES(0)) ;
04737 --      IF TEST or warning
04738 --      THEN TRACER(4, "?PX18") ;
04739 -4    END ;
04740 -3  END OF_TAKEBACKMOVE ;
04741 --  
04742 --  PROCEDURE TRACER (INTEGER VALUE CHARCOUNT ; STRING(20) VALUE UU) ;
04743 --    COMMENT initiates trace according to trace parameters ;
04744 3-  BEGIN
04745 --    INTEGER I, J, sf, st ;
04746 --    STRING(140) BUFF ;
04747 --    LOGICAL OLDECHO ;
04748 --  
04749 --    OLDECHO := ECHO ;
04750 --    I := 0 ;
04751 --    IF CHARCOUNT > 19
04752 --    THEN CHARCOUNT := 19 ;
04753 --    WHILE (I < CHARCOUNT)
04754 4-    DO BEGIN
04755 --      I := I + 1 ;
04756 --                        COMMENT  processing terminated if illegal character found
04757 --                                 in input stream ;
04758 --      J := DECODE(UU(I|1)) - 192 ;
04759 --      IF ((J < 0) OR (J > 57))
04760 --      THEN I := CHARCOUNT
04761 --      ELSE CASE J OF
04762 5-      BEGIN
04763 --  
04764 --        BOOK := - BOOK ;
04765 --                                                      COMMENT     "A" ;
04766 --        FOR L := NUMBER(-1) UNTIL -1 DO PRINTLINE(L, 0) ;
04767 --                                                      COMMENT     "B" ;
04768 6-        begin
04769 --          COKO := ~ COKO ;
04770 --          write("COKO is", coko) ;
04771 -6        end ;
04772 --                                                      COMMENT     "C" ;
04773 6-        begin
04774 --          FOR J := 1 UNTIL TRY(WSIZE) DO PRINTLINE(TRY(J), 0) ;
04775 -6        end ;
04776 --                                                      COMMENT     "D" ;
04777 --        EXAMINE := ~ EXAMINE ;
04778 --                                                      COMMENT     "E" ;
04779 --        ECHO := ~ ECHO ;
04780 --                                                      COMMENT     "F" ;
04781 --        IF LOOKAHEAD THEN IF (LASTORIGIN > 0) AND ORIGIN > 0
04782 6-        THEN BEGIN
04783 --          J := NODETO(LASTORIGIN,0) ;
04784 --          if ~MONITOR then IF J > 5
04785 --          THEN J := 5 ; comment by default only display first 5 variations ;
04786 --          PUNCHBRD(TRUE, BUFF) ;
04787 --          printshortbrd(-1) ;
04788 --          FOR REPLY := 1 UNTIL J
04789 7-          DO BEGIN
04790 --            RESTORESTATE(LASTORIGIN) ;
04791 --            PRINTLINE(TRY(REPLY), 0) ;
04792 --            WRITEON(LASTORIGIN, NODETO(LASTORIGIN, 0),
04793 --                    NODETO(LASTORIGIN,REPLY)) ;
04794 --            if (NODETO(LASTORIGIN,REPLY) > 0)
04795 8-            then begin
04796 --              writeon(PARENT(NODETO(LASTORIGIN,REPLY))) ;
04797 --              GAMETREE(NODETO(LASTORIGIN,REPLY), 1, 2) ;
04798 -8            end else writeon("end of variation") ;
04799 -7          END ;
04800 --          RESTORESTATE(ORIGIN) ;
04801 --          SETBOARD(BUFF) ;
04802 --          printshortbrd(-1) ;
04803 --          IF STARTTHISPROBLEM(TRUE)
04804 --          THEN LISTMOVES
04805 --          ELSE GOTO STARTS ;
04806 -6        END else
04807 --          write("No game tree: origin/lastorigin both zero") ;
04808 --                                                      COMMENT     "G" ;
04809 --        comment WRITE("$COPY WITA:COMMANDS(1,2) for description") ;
04810 --        WRITECARD(
04811 --          " August 2008 program resurrected with the help of Carey",
04812 --          " Bloodworth (who rebuilt the missing data file and",
04813 --          " re-implemented system-dependent components)",
04814 --          " and Glyn Webster's Algol-W to C translator-compiler",
04815 --          " working with the 1986 AP9.5 version of Awit.",
04816 --          " Summer 1973 version of WITA, a chess-playing program",
04817 --          " written by T.A. Marsland, Univ. of Alberta, Edmonton",
04818 --          " The primary aim of this program is to explore techniques",
04819 --          " for highly selective searches of large game trees.",
04820 --          " a goal of controlled search with a branching factor no",
04821 --          " greater than six is sought.  The 1968 version of WITA",
04822 --          " was written in Burroughs Extended Algol, for the B-5500.") ;
04823 --                                                      COMMENT     "H" ;
04824 --        WRITE("Use algebraic or Descriptive notation for moves",
04825 --          " A ?OPTION may be entered at any time.",
04826 --          " ENTER ?6 to alter tree-size parameters.") ;
04827 --                                                      COMMENT     "I" ;
04828 --       ;
04829 --       ;
04830 --       ;
04831 --       ;  COMMENT SKIP NON-ALPHABETIC EBCDIC CHARACTERS BETWEEN I AND J ;
04832 --       ;
04833 --       ;
04834 --       ;
04835 --  
04836 --        CAPTURE_TREE := ~CAPTURE_TREE ;
04837 --                                                      COMMENT     "J" ;
04838 --        GO TO STARTS ;
04839 --                                                      COMMENT     "K" ;
04840 6-        BEGIN
04841 --          IF (LOOKAHEAD)
04842 --          THEN EXAMINE := LOOKAHEAD := TEST := FALSE
04843 --          ELSE LOOKAHEAD := TRUE
04844 -6        END ;
04845 --                                                      COMMENT     "L" ;
04846 --        MONITOR := ~MONITOR ;
04847 --                                                      COMMENT     "M" ;
04848 6-        BEGIN
04849 --          TTYOUT := IF TTYOUT = 6
04850 --                    THEN 4
04851 --                    ELSE 6 ;
04852 --          PUT(TTYOUT) ;
04853 -6        END ;
04854 --                                                      COMMENT     "N" ;
04855 6-        BEGIN
04856 --          WRITE ("?C-coko=", COKO, "?1-dumpp=", DUMPP, "?2-ws=", WS, "?45= ",
04857 --                            IF CBOTH
04858 --                            THEN "BOTH"
04859 --                            ELSE IF BOTH
04860 --                                 THEN "USER"
04861 --                                 ELSE "EACH",
04862 --                 "  ", "?L-lookahead=", LOOKAHEAD) ;
04863 --          WRITE("?M-MONITOR=", MONITOR, "?7-test=", TEST, "?Q-quick=", QUICK) ;
04864 --          WRITE("?T-tournament=", TOURNAMENT, "?E-examine=", EXAMINE, "?V-debug=", DEBUG) ;
04865 --          WRITE("ENDGAME=", ENDGAME, "?J-CAPTURE=", CAPTURE_TREE, "PAB=", pab) ;
04866 --           ;
04867 -6        END ;
04868 --                                                      COMMENT     "O" ;
04869 --        IF (MOVECOUNT > 0)
04870 --        THEN PRINTSHORTBRD(-1) ;
04871 --                                                      COMMENT     "P" ;
04872 6-        BEGIN
04873 --          IF QUICK
04874 --          THEN QUICK := LOOKAHEAD := TEST := FALSE
04875 --          ELSE QUICK := LOOKAHEAD := TRUE
04876 -6        END ;
04877 --                                                      COMMENT     "Q" ;
04878 6-        BEGIN
04879 --          I := I + 1 ;
04880 --          REINITIALIZE(UU(I|1)) ;
04881 -6        END ;
04882 --                                                      COMMENT    "Ri" ;
04883 --       ;
04884 --       ;
04885 --       ;
04886 --       ;  COMMENT SKIP NON-ALPHABETIC EBCDIC CHARACTERS BETWEEN R AND S ;
04887 --       ;
04888 --       ;
04889 --       ;
04890 --       ;
04891 --  
04892 --        GAMERECORD (FALSE) ;
04893 --                                                      COMMENT     "S" ;
04894 --        TOURNAMENT := ~ TOURNAMENT ;
04895 --                                                      COMMENT     "T" ;
04896 6-        BEGIN
04897 --          SCORER (UU(I+1|1), UU(I+2|1), UU(I+3|1)) ;
04898 --          I := I + 3 ;
04899 -6        END ;
04900 --                                                      COMMENT     "Usij" ;
04901 --        DEBUG := ~ DEBUG ;
04902 --                                                      COMMENT     "V" ;
04903 --        FOR L := NUMBER(1) STEP -1 UNTIL 1
04904 --        DO PRINTLINE(L, 0) ;
04905 --                                                      COMMENT     "W" ;
04906 6-        BEGIN
04907 --          DUMPER (DECODE(UU(I+1|1)) - 240, DECODE(UU(I+2|1)) - 240) ;
04908 --          I := I + 2 ;
04909 -6        END ;
04910 --                                                      COMMENT     "Xij" ;
04911 6-        BEGIN
04912 --  AGAIN:
04913 --          WRITE("Invalid data, try again") ;
04914 --          WRITE(MOVES_LEFT, TIME_LEFT DIV 3600) ;
04915 --          WRITE ("ENTER MOVES_LEFT & TIME_LEFT(MINS)") ;
04916 --          WHILE READU
04917 --          DO TRACER(CHARCOUNT, BUFFER(0|20)) ;
04918 --          write("In TRACER", color(k), "Move") ;
04919 --          MOVES_LEFT := CONVERTS(U, INERR) ;
04920 --          IF INERR
04921 --          THEN GO TO AGAIN ;
04922 --          TIME_LEFT := CONVERTS(U, INERR) ;
04923 --          IF INERR OR MOVES_LEFT <= 0 OR TIME_LEFT <= 0
04924 --          THEN GO TO AGAIN
04925 --          ELSE TIME_LEFT := TIME_LEFT * 3600 ;
04926 -6        END ;
04927 --                                                      COMMENT     "Y" ;
04928 --        IF (MOVECOUNT > 0)
04929 6-        THEN BEGIN
04930 --          PUNCHBRD(TRUE, HISTORY(0|140)) ;
04931 --          WRITECARD(HISTORY(0|114)) ;
04932 -6        END ;
04933 --                                                      COMMENT     "Z" ;
04934 --       ;
04935 --       ;
04936 --       ;
04937 --       ;  COMMENT SKIP NON-ALPHABETIC EBCDIC CHARACTERS BETWEEN Z AND ZERO ;
04938 --       ;
04939 --       ;
04940 --  
04941 6-        BEGIN
04942 --          WRITE("NODES ", NOD, "TERMINAL ", TOT, "DYNAMIC ", DYN, "CAPTURE ", CAP) ;
04943 --          WRITE("SALVAGE", SAL, "DUPLIC", DUP, "RECLAIM", REC, "BRANCH ", BRAN) ;
04944 --          WRITE("DUP_TREE ", DUP_S, "REC_TREE ", REC_S, "BRAN_SCORED ", BRAN_S) ;
04945 --          WRITE(COLOR(-k), " REFUTation-TABLE", max_plies) ;
04946 --          iocontrol(2) ;
04947 7-          for j := 1 until MAX_WID do begin
04948 8-            for i:= LEVEL until MAX_PLIES do begin
04949 --               sf := REFTAB(j,i) div 1000 ;
04950 --               st := REFTAB(j,i) rem 1000 ;
04951 --               if sf > 10 and st > 10 then
04952 --                  writeon(BOX(sf), BOX(st), "  ")
04953 --               else goto out ;
04954 -8            end ;
04955 --  out:
04956 --            iocontrol(2) ;
04957 -7          end ;
04958 7-          for i := 0 until MAX_WID do begin
04959 --            for j := 1 until MAX_PLIES do
04960 --               writeon(REFUT(j,i)) ;
04961 --            iocontrol(2) ;
04962 -7          end ;
04963 7-          for i := 0 until MAX_WID do begin
04964 --            for j := 1 until MAX_PLIES do
04965 --               writeon(REFCNT(j,i)) ;
04966 --            iocontrol(2) ;
04967 -7          end ;
04968 -6        END ;
04969 --                                                      COMMENT     "0" ;
04970 --        DUMPP := ~ DUMPP ;
04971 --                                                      COMMENT     "1" ;
04972 --        WS := ~ WS ;
04973 --                                                      COMMENT     "2" ;
04974 --        THINKING := ~ THINKING ;
04975 --                                                      COMMENT     "3" ;
04976 6-        BEGIN
04977 --          IF ~ CBOTH
04978 --          THEN IF (BOTH)
04979 --               THEN BOTH := WHO := FALSE
04980 --               ELSE BOTH := WHO := CBOTH := TRUE ;
04981 -6        END ;
04982 --                                                      COMMENT     "4" ;
04983 6-        BEGIN
04984 --          IF (CBOTH)
04985 --          THEN CBOTH := BOTH := FALSE
04986 --          ELSE IF BOTH
04987 --               THEN WHO := FALSE
04988 --               ELSE BOTH := TRUE ;
04989 -6        END ;
04990 --                                                      COMMENT     "5" ;
04991 --        GO TO ENTRY ;
04992 --                                                      COMMENT     "6" ;
04993 --        TEST := ~ TEST ;
04994 --                                                      COMMENT     "7" ;
04995 --  comment        WRITE("$COPY WITA:COMMANDS(3,4) for options") ;
04996 --       WRITECARD(
04997 --                  " ?A -Toggle BOOK, to create the opening book.",
04998 --                  " ?B -Print Black's moves.",
04999 --                  " ?C -Toggle COKO flag, to play another computer.",
05000 --                  " ?D -Dump first moves of principal variations.",
05001 --                  " ?E -Toggle EXAMINE flag, build opponent's tree.",
05002 --                  " ?F -Toggle ECHO flag, to echo input.",
05003 --                  " ?G -Print game tree of principal variations.",
05004 --                  " ?H -History.",
05005 --                  " ?I -Instructions.",
05006 --                  " ?J -Toggle CAPTURE_TREE option.",
05007 --                  " ?K -Kill game, restart another game.",
05008 --                  " ?L -Toggle LOOKAHEAD flag, build game tree to depth 5 ply.",
05009 --                  " ?M -Toggle MONITOR flag, print secondary trees.",
05010 --                  " ?N -Next output to unit 4 or 6.",
05011 --                  " ?O -Print current settings of flags.",
05012 --                  " ?P -Print board from White's viewpoint.",
05013 --                  " ?Q -Toggle QUICK lookahead flag, game tree to depth 3 ply.",
05014 --                  " ?Ri -Retract last i+1 half moves, 0 <= i <= 9.",
05015 --                  " ?S -Print record of current game.",
05016 --                  " ?T -Toggle TOURNAMENT flag, game tree to depth 7 ply.",
05017 --                  " ?Usij -Print snapshot of White(s=+)/Black(s=-) move",
05018 --                  "        list, from moves 6i+1 to 6(j+1), 0 <= i <= j <= 9.",
05019 --                  " ?V -Toggle DEBUG flag, linear/nonlinear scoring function.",
05020 --                  " ?W -Print White's moves.",
05021 --                  " ?Xij -Print square control information, for squares on",
05022 --                  "       rows i to j, 1 <= i <= j <= 8.",
05023 --                  " ?Y -Set time control parameters.",
05024 --                  " ?Z -Print board in quasi Forsythe notation.",
05025 --                  " ?0 -Tree search statistics and refutation table.",
05026 --                  " ?1 -Toggle DUMPP flag, to dump various information.",
05027 --                  " ?2 -Toggle WS flag, to compute opponent's scores.",
05028 --                  " ?3 -Toggle THINKING on opponent's time flag",
05029 --                  " ?4 -Toggle CBOTH flag, computer will play one more side.",
05030 --                  " ?5 -Toggle BOTH flag, user will play one more side.",
05031 --                  " ?6 -Terminate game, restart whole program.",
05032 --                  " ?7 -Toggle TEST flag, to provide more debugging information.",
05033 --                  " ?8 -Print this list of control options.",
05034 --                  " ?9 -Print King's squares, piece count, squares",
05035 --                  "     controlled by Kings, and the en prise squares.",
05036 --                  " BLITZ - reset to Blitz/Speed/Beginner  mode.",
05037 --                  " INTER - reset to Intermediate mode.",
05038 --                  " TOURN - reset to Tournament mode.",
05039 --                  " EXPER - reset to Experimental mode.",
05040 --                  " PLAY  - Force computer to make next move.",
05041 --                  " SWAP  - Complement side to move, other side can move next.",
05042 --                  " FLIP  - Invert colour of pieces and side to move.",
05043 --                  " PAB   - Complement the Palphabeta Flag.",
05044 --                  " WARN  - Complement the Warning Message Flag.",
05045 --                  " STOP  - Terminates the program.",
05046 --                  " " ) ;
05047 --                                                      COMMENT     "8" ;
05048 6-        BEGIN
05049 --          WRITE (DIFFVAL, TWOVAL, KINGSQ(-1), KINGSQ(1)) ;
05050 --          FOR J := K_SQRS(-1) UNTIL K_SQRS(1)
05051 --            DO WRITEON (KSQRS(J)) ;
05052 --          WRITE(LOSS(0)) ;
05053 --          FOR J := 0 UNTIL LOSS(0)
05054 --            DO WRITEON (SQUARE(J)) ;
05055 --          WRITE(LOSS(ELIMIT)) ;
05056 --          FOR J := LOSS(ELIMIT) UNTIL ELIMIT
05057 --            DO WRITEON(SQUARE(J)) ;
05058 --          WRITE(ENDPLAY) ;
05059 --          FOR J := -1 UNTIL 1
05060 --            DO WRITEON(CLEARPAWN(J)) ;
05061 --          FOR J := 1 UNTIL ENDPLAY
05062 --            DO WRITEON(REPEATS(J)) ;
05063 --          FOR J := WQRSQ UNTIL BKRSQ
05064 --          DO IF J REM BRDWIDTH = 1
05065 --             THEN WRITE(CHECK_S(-1,J)+CHECK_S(1,J))
05066 --             ELSE IF BRD(J) ~= EDGE
05067 --                  THEN WRITEON(CHECK_S(-1,J)+CHECK_S(1,J)) ;
05068 --          FOR J := WQRSQ UNTIL BKRSQ
05069 --          DO IF J REM BRDWIDTH = 1
05070 --             THEN WRITE(FORKS(-K,J))
05071 --             ELSE IF BRD(J) ~= EDGE
05072 --                  THEN WRITEON(FORKS(-K,J)) ;
05073 --        IOCONTROL(2) ;
05074 --        FOR I := -8 UNTIL 8
05075 --          DO WRITEON(PIECES(I)) ;
05076 --        WRITEON(MEN(1), MEN(-1)) ;
05077 -6      END ;
05078 --                                                    COMMENT     "9" ;
05079 -5    END ;
05080 -4  END ;
05081 --  WRITE("CONTINUE (Tracer ?", UU(1|4), " exit):") ;
05082 -3  END OF_TRACER ;
05083 --  
05084 --  PROCEDURE USEBOOK ;
05085 3-  BEGIN
05086 --    STRING(140) BUFF ;
05087 --    INTEGER I, LEN, N, H, R, J ;
05088 --    INTEGER ARRAY OFFSETS(0::10) ;
05089 --    LOGICAL SPECIAL ;
05090 --  
05091 --    N := -HALFP ;
05092 --    HASH := NEWHASH(BRD, K, KEY) ;
05093 --    SPECIAL := FALSE ;
05094 --  LOOP:
05095 --    TRANSFER(BUFF, LEN, 16384+2, HASH, 2, -1) ;
05096 --    BOOK := 0 ;
05097 --    IF (LEN <= 0)
05098 --    THEN WRITE(HASH, KEY(0|2), " No more book")
05099 --    ELSE IF (BUFF(0|2) = KEY(0|2))
05100 4-         THEN BEGIN
05101 --           OFFSETS(0) := J := 3 ;
05102 --           R := 0 ;
05103 --           FOR I := 7 UNTIL LEN-1
05104 --           DO IF BUFF(I|1) = "!"
05105 5-              THEN BEGIN
05106 --                IF SPECIAL
05107 --                THEN R := R + 1
05108 --                ELSE R := 1 ;
05109 --                SPECIAL := TRUE ;
05110 --                OFFSETS(R-1) := J ;
05111 -5           END ELSE IF ~SPECIAL AND BUFF(I|1) = "?"
05112 --                    THEN R := R - 1
05113 --                    ELSE IF (BUFF(I|1) = ".")
05114 --                         THEN IF SPECIAL
05115 --                              THEN J := I + 1
05116 5-                         ELSE BEGIN
05117 --                           R := R + 1 ;
05118 --                           OFFSETS(R) := J := I + 1 ;
05119 -5           END ;
05120 --           IF TEST OR R = 0
05121 5-           THEN BEGIN
05122 --             FOR I := 0 UNTIL R
05123 --             DO WRITEON(OFFSETS(I)) ;
05124 --             FOR I := 3 UNTIL LEN-1
05125 --             DO WRITEON(BUFF(I|1)) ;
05126 --             WRITE("HASH IS ", HASH, " KEY IS ", KEY(0|2)) ;
05127 -5           END ;
05128 --           IF R > 0
05129 5-           THEN BEGIN
05130 --                         COMMENT move till period ;
05131 --             R := IF R <= 1
05132 --                  THEN OFFSETS(0)
05133 --                  ELSE OFFSETS((TIME(-1) DIV 60) REM R) ;
05134 --             I := 0 ;
05135 --             WHILE BUFF(I + R |1) ~= "."
05136 6-             DO BEGIN
05137 --               U(I) := BUFF(I + R |1) ;
05138 --               I := I + 1 ;
05139 -6             END ;
05140 --             U(I) := "." ;
05141 --             CHARCOUNT := I ;
05142 --             LISTMOVES ;
05143 --             BOOK := -1 ;
05144 --             INIT_TREE ;   Comment added 7 September 2009.  Book enter, exit,
05145 --                                   re-enter problem ;
05146 --             REPLY := 0 ;
05147 --             IF ~GETMOVE(U)
05148 6-             THEN BEGIN
05149 --               WRITE(HASH, "BOOK AMBIGUOUS  ", BUFF(R|6), R, BUFF(0|20))
05150 --                ;
05151 --                 tracer(2, "?SP") ;
05152 --               GO TO STARTS ;
05153 -6             END ;
05154 -5           END ;
05155 -4         END ELSE
05156 4-         BEGIN
05157 --                  COMMENT Even though the quadratic residue method was
05158 --                          used previously, implementation of the Zobrist method,
05159 --                          which distributes the initial indices more uniformly
05160 --                          across the table, makes use of the simpler linear
05161 --                          resolution ;
05162 --           HASH := HASH + K ;
05163 --           IF TEST
05164 --           THEN WRITEON(KEY, " Book conflict ", HASH, BUFF(0|2)) ;
05165 --           GO TO LOOP ;
05166 -4         END ;
05167 -3  END OF_USEBOOK ;
05168 --  
05169 --  PROCEDURE CREATEBOOK ;
05170 3-  BEGIN
05171 --    INTEGER LINE, LEN, BUFLEN, COUNT, R, TLEN ;
05172 --    STRING(140) BUFF, BUFR ;
05173 --    STRING(2) TERMINATOR ;
05174 --      COMMENT STRING(1) ARRAY MC(0::11) ;
05175 --  READIN:
05176 --    TRANSFER(BUFF, LEN, 32, LINE, 1, -1) ;
05177 --    IF (LEN < 0)
05178 --    THEN BOOK := -BOOK
05179 --    else if (LEN = 0)
05180 --    then go to READIN
05181 4-    ELSE BEGIN
05182 --      BUFF(LEN|1) := " " ;
05183 --      R := COUNT := 0 ;
05184 --      WHILE BUFF(R|1) = " "
05185 --      DO R := R + 1 ;
05186 --      IF BUFF(R|1) < "0" OR BUFF(R|1) > "9" OR R >= LEN
05187 --      THEN GO TO READIN ;
05188 --      WHILE (BUFF(R|1) ~= " ")
05189 5-      DO BEGIN
05190 --        COUNT := 10 * COUNT + DECODE(BUFF(R|1)) - 240 ;
05191 --        R := R + 1 ;
05192 -5      END ;
05193 --      COUNT := COUNT + COUNT ;
05194 --      IF LEN < 13 OR BUFF(8|4) ~= "    "
05195 --      THEN COUNT := COUNT - 1 ;
05196 --      WHILE (BUFF(R|1) = " ")
05197 --      DO R := R + 1 ;
05198 --      WHILE (BOOKMOVE - COUNT > 9)
05199 5-      DO BEGIN
05200 --        REINITIALIZE("9") ;
05201 --        BOOKMOVE := BOOKMOVE - 10 ;
05202 -5      END ;
05203 --      IF (BOOKMOVE >= COUNT)
05204 --      THEN REINITIALIZE(CODE(BOOKMOVE - COUNT + 240)) ;
05205 --      BOOKMOVE := COUNT ;
05206 --  NEWMOVE:
05207 --                  COMMENT try to handle two moves per line ;
05208 --      HASH := NEWHASH(BRD, K, KEY) ;
05209 --      TLEN := COUNT := 0 ;
05210 --      WHILE (BUFF(R|1) ~= " " AND R < LEN)
05211 5-      DO BEGIN
05212 --        MC(COUNT) := BUFF(R|1) ;
05213 --        IF (BUFF(R|1) = "!" OR BUFF(R|1) = "?" OR BUFF(R|1) = "+")
05214 6-        THEN BEGIN
05215 --          TERMINATOR(TLEN|1) := BUFF(R|1) ;
05216 --          TLEN := TLEN + 1 ;
05217 -6        END ;
05218 --        COUNT := COUNT + 1 ;
05219 --        R := R + 1 ;
05220 -5      END ;
05221 --      MC(COUNT) := "." ;
05222 --      CHARCOUNT := COUNT ;
05223 --      LISTMOVES ;
05224 --      IF ~GETMOVE(MC)
05225 5-      THEN BEGIN
05226 --        WRITE("Illegal move at line ", LINE, R, BUFF(0|20)) ;
05227 --        GO TO QUIT ;
05228 -5      END ;
05229 --      FINDRTMV ;
05230 --      IF NULLMOVE
05231 5-      THEN BEGIN
05232 --        WRITE("NULLMOVE AT LINE ", LINE) ;
05233 --        GO TO QUIT ;
05234 -5      END ;
05235 --  RDBOOK:
05236 --      TRANSFER(BUFR, BUFLEN, 16386, HASH, 2, -1) ;
05237 --      IF (BUFLEN > 0)
05238 5-      THEN BEGIN
05239 --        IF KEY(0|2) ~= BUFR(0|2)
05240 6-        THEN BEGIN
05241 --          WRITE("PRIMARY CONFLICT AT HASH ", HASH) ;
05242 --          HASH := HASH + K ;
05243 --          GO TO RDBOOK ;
05244 -6        END ;
05245 -5      END ELSE
05246 5-      BEGIN
05247 --        BUFLEN := 3 ;
05248 --        BUFR(0|2) := KEY(0|2) ;
05249 --        BUFR(2|1) := " " ;
05250 -5      END ;
05251 --      IF TEST
05252 --      THEN BUFR(BUFLEN|20) := " " ;
05253 --      BUFR(BUFLEN|2) := BOX(MOVEFROM(RTMV)) ;
05254 --      BUFR(BUFLEN+2|2) := BOX(MOVETO(RTMV)) ;
05255 --                  COMMENT IF TEST THEN
05256 --                            WRITE("HASH: ", HASH, " BUFF: ", BUFR(0|60)) ;
05257 --      FOR I := 1 UNTIL TLEN
05258 --      DO BUFR(BUFLEN+3+I|1) := TERMINATOR(I-1|1) ;
05259 --      BUFR(BUFLEN+TLEN+4|1) := "." ;
05260 --      COUNT := 3 ;
05261 --      IF (BUFLEN > 0)
05262 --      THEN WHILE (COUNT < BUFLEN)
05263 5-           DO BEGIN
05264 --             IF (BUFR(COUNT|4) = BUFR(BUFLEN|4))
05265 6-             THEN BEGIN
05266 --               IF (TLEN > 0 AND BUFR(COUNT+4|1) ~= BUFR(BUFLEN+4|1))
05267 --               THEN WRITE("DUPLICATE AT LINE ", HASH, LINE,
05268 --                 ".   BUFFER IS ", BUFR(0|60)) ;
05269 --               GO TO FOUNDUP ;
05270 -6             END ;
05271 --             WHILE BUFR(COUNT|1) ~= "."
05272 --             DO COUNT := COUNT + 1 ;
05273 --             COUNT := COUNT + 1 ;
05274 -5      END ;
05275 --      WRITE("New Move: ", HASH, BUFR(BUFLEN|5)) ;
05276 --      BUFLEN := BUFLEN + TLEN + 5 ;
05277 --      TRANSFER(BUFR, BUFLEN, 16386, HASH, 2, 1) ;
05278 --  FOUNDUP:
05279 --      FINALIZE ;
05280 --      WHILE BUFF(R|1) = " " AND R < LEN
05281 --      DO R := R + 1 ;
05282 --      IF R >= LEN OR R >= 20
05283 --      THEN GOTO READIN ;
05284 --      BOOKMOVE := BOOKMOVE + 1 ;
05285 --      GOTO NEWMOVE ;
05286 -4    END ;
05287 --  QUIT:
05288 --    PRINTSHORTBRD(-1) ;
05289 -3  END OF_CREATEBOOK ;
05290 --  
05291 --  PROCEDURE INIT_TREE ;
05292 3-  BEGIN
05293 --    if warning then
05294 --      write("Entering INIT_TREE ");
05295 --    new_count := old_count := 0 ;
05296 --    OPENING := MOVECOUNT <= 16 ;
05297 --    OPEN(1) := OPEN(-1) := OPENING ;
05298 --    EARLY := MOVECOUNT < 8 ;
05299 --    MAXL := MAXTREE ;
05300 --    MAXNODES := 1 ;
05301 --    ORIGIN := 0 ;
05302 --    FOR L := 0 UNTIL MAXTREE
05303 4-    DO BEGIN
05304 --      PARENT(L) := 0 ;
05305 --      GETNODE(L) := L ;
05306 --      NODETO(L,0) := -FIVES ;
05307 -4    END ;
05308 --    GETNODE(MAXTREE+1) := 0 ;
05309 --    PREVSCR := OLDSCR := FIVES ;
05310 --    LASTORIGIN := SAVEL := 0 ;
05311 --    FOR LEV := 1 UNTIL MAX_PLIES
05312 --    DO REFUT(LEV,0) := REFCNT(LEV,0) := 0 ;
05313 --    M_TIMES(0) := M_TIMES(MODE) DIV 3 ;
05314 --  
05315 -3  END OF_INIT_TREE ;
05316 --  
05317 --  PROCEDURE BLITZ ;
05318 3-  BEGIN
05319 --    MODE := 3 ;
05320 --    MAXLEV := 3 ;
05321 --    MAX_PLIES := MAXLEV + MAXPLY ;
05322 --    MAX_WID := WIDTH := 9 ;
05323 --    INIT_TREE ;
05324 --    WRITE("BLITZ mode: ", "maxlev=", MAXLEV,
05325 --          "max_plies=", MAX_PLIES, "max_wid=", MAX_WID) ;
05326 --    write("Re-starting.  Type REPEAT followed by either PLAY or a move") ;
05327 --    goto starts ;
05328 -3  END OF_BLITZ ;
05329 --  
05330 --  PROCEDURE INTERMEDIATE ;
05331 3-  BEGIN
05332 --    MODE := 4 ;
05333 --    MAX_PLIES := 5 + MAXPLY ;
05334 --    IF MAX_PLIES > DEPTH_LIMIT
05335 --    THEN MAX_PLIES := DEPTH_LIMIT ;
05336 --    MAXLEV := MAX_PLIES - MAXPLY ;
05337 --    MAX_WID := 12 ;
05338 --    IF MAX_WID > WIDTH_LIMIT
05339 --    THEN MAX_WID := WIDTH_LIMIT ;
05340 --    WIDTH := MAX_WID ;
05341 --    INIT_TREE ;
05342 --    WRITE("INTERMEDIATE mode: ", "maxlev=", MAXLEV,
05343 --          "max_plies=", MAX_PLIES, "max_wid=", MAX_WID) ;
05344 --    write("Re-starting.  Type REPEAT followed by either PLAY or a move") ;
05345 --    goto starts ;
05346 -3  END OF_INTERMEDIATE ;
05347 --  
05348 --  PROCEDURE EXPERIMENTAL ;
05349 3-  BEGIN
05350 --    MODE := 6 ;
05351 --    MAX_PLIES := 9 + MAXPLY ;
05352 --    IF MAX_PLIES > DEPTH_LIMIT
05353 --    THEN MAX_PLIES := DEPTH_LIMIT ;
05354 --    MAXLEV := MAX_PLIES - MAXPLY ;
05355 --    MAX_WID := w_size ;
05356 --    IF MAX_WID > WIDTH_LIMIT
05357 --    THEN MAX_WID := WIDTH_LIMIT ;
05358 --    WIDTH := MAX_WID ;
05359 --    INIT_TREE ;
05360 --    WRITE("EXPERIMENTAL mode: ", "maxlev=", MAXLEV,
05361 --          "max_plies=", MAX_PLIES, "max_wid=", MAX_WID) ;
05362 --    write("Re-starting.  Type REPEAT followed by either PLAY or a move") ;
05363 --    goto starts ;
05364 -3  END OF_EXPERIMENTAL ;
05365 --  
05366 --  PROCEDURE TOURNAMENTS ;
05367 3-  BEGIN
05368 --    MODE := 5 ;
05369 --    MAX_PLIES := 7 + MAXPLY ;
05370 --    IF MAX_PLIES > DEPTH_LIMIT
05371 --    THEN MAX_PLIES := DEPTH_LIMIT ;
05372 --    MAXLEV := MAX_PLIES - MAXPLY ;
05373 --    MAX_WID := 19 ;
05374 --    IF MAX_WID > WIDTH_LIMIT
05375 --    THEN MAX_WID := WIDTH_LIMIT ;
05376 --    WIDTH := MAX_WID ;
05377 --    INIT_TREE ;
05378 --    WRITE("TOURNAMENT mode: ", "maxlev=", MAXLEV,
05379 --          "max_plies=", MAX_PLIES, "max_wid=", MAX_WID) ;
05380 --    write("Re-starting.  Type REPEAT followed by either PLAY or a move") ;
05381 --    goto starts ;
05382 -3  END OF_TOURNAMENTS ;
05383 --  
05384 --  PROCEDURE Flipper ;
05385 3-  begin
05386 --    integer i, j, pc ;
05387 --  
05388 --    j := wqrsq + 7*brdwidth ;
05389 --    for i := wqrsq until bkrsq - 4*brdwidth
05390 4-    do begin
05391 --       if BRD(i) ~= EDGE
05392 5-       then begin
05393 --         pc := BRD(j) ;
05394 --         BRD(j) := -BRD(i) ;
05395 --         BRD(i) := -pc ;
05396 -5       end ;
05397 --         if (i rem 10) = 0
05398 --         then j := j - 20 ;
05399 --         j := j + 1 ;
05400 -4    end ;
05401 --    K := -K ;
05402 --    PRINTSHORTBRD(-K) ;
05403 -3  END OF_Flipper ;
05404 --  
05405 --  PROCEDURE Reclaim_Node (integer root; string(7) value location) ;
05406 3-  begin
05407 4-    if root > 0 then begin
05408 --      for i := POINT+1 until MAXL do
05409 --      if ROOT = GETNODE(i)
05410 --      then goto OUT ;
05411 5-      if maxl < maxtree then begin
05412 --        maxl := maxl + 1 ;
05413 --        getnode(maxl) := root ;
05414 --        getnode(maxl+1) := 0 ;
05415 --      end else if point > 0 then begin
05416 --        getnode(point) := root ;
05417 --        point := point - 1 ;
05418 -5      end
05419 5-      else begin
05420 --        write("Reclaim_Node cannot return", root, " to getnode list") ;
05421 --        goto OUT ;
05422 -5      end ;
05423 --      if TEST then
05424 --        write(location, " retrieved node", root, "p=", point, "maxl=", maxl) ;
05425 --      for i := NODETO(ROOT,0) step -1 until 1 do
05426 --      if NODETO(ROOT,i) > 0 then
05427 --        Reclaim_Node(NODETO(ROOT,i), "Reclaim") ;
05428 --  OUT:
05429 -4    end ;
05430 -3  END OF_Reclaim_Node ;
05431 --  
05432 --  PROCEDURE DisplayLostNodes ;
05433 3-  begin
05434 --    for i := 1 until maxtree do
05435 --      holding(i) := 0 ;
05436 --    for i := point+1 until maxl do
05437 --      holding(getnode(i)) := getnode(i) ;
05438 --    TraverseTree(origin) ;
05439 --    write("The affected nodes are") ;
05440 --    iocontrol(2) ;
05441 --    for i := 1 until maxtree do
05442 --      if holding(i) = 0 then writeon(i)
05443 --      else if holding(i) > i then writeon(-i) ;
05444 --    iocontrol(2) ;
05445 -3  END OF_DisplayLostNodes ;
05446 --  
05447 --  PROCEDURE TraverseTree (integer node) ;
05448 3-  begin
05449 4-    if node > 0 then begin
05450 --      for i := nodeto(node,0) step -1 until 1 do
05451 --        TraverseTree(nodeto(node,i)) ;
05452 --      if holding(node) ~= 0 then
05453 --        write("Double dipping node/holding(node)", node, holding(node)) ;
05454 --      holding(node) := holding(node) + node ;
05455 -4    end ;
05456 -3  END OF_TraverseTree ;
05457 --  
05458 --  PROCEDURE LISTLEGALMOVES (LOGICAL VALUE LOSING) ;
05459 --  COMMENT  only legal moves are listed ;
05460 3-  BEGIN
05461 --    INTEGER NM ;
05462 --    KTEST := 0 ;
05463 --                        COMMENT enprise makes a list of pieces that are attacked
05464 --                                and provides some incentive to move them. ;
05465 --                        COMMENT Do not penalize q move ;
05466 --    NM := ABS(CON(-K,KINGSQ(K))) ;
05467 --    INCHECK := IF (NM = 0)
05468 --               THEN FALSE
05469 --               ELSE TRUE ;
05470 --    CHECKSQ := IF INCHECK
05471 --               THEN CONTROL(KINGSQ(K),-K)
05472 --               ELSE HOLE ;
05473 --                             COMMENT only used when incheck is true ;
05474 --    DBLCHECK := IF (NM < 2)
05475 --                THEN FALSE
05476 --                ELSE TRUE ;
05477 --    LISTMOVES ;
05478 --    IF INCHECK
05479 --    THEN UPPER := EIGHTS ;
05480 --                       COMMENT   generates all potential moves. ;
05481 --    ONEVAL := DIFFVAL*K ;
05482 --    REALVAL := ONEVAL + TWOVAL ;
05483 --                       COMMENT inc. enprise piece ;
05484 --    IF SCORES
05485 --    THEN SELECTRTMV (LOSING) ;
05486 -3  END OF_LISTLEGALMOVES ;
05487 --  
05488 --  COMMENT ********************make*************** ;
05489 --  
05490 --  PROCEDURE MAKE (INTEGER VALUE I) ;
05491 3-  BEGIN
05492 --    INTEGER PC, SQ, L1, KK ;
05493 --  
05494 --    PC := BRD(I) ;
05495 --                 COMMENT CAPTURE_CH(I) := FALSE ;
05496 --    KK := IF (PC > 0)
05497 --          THEN 1
05498 --          ELSE -1 ;
05499 --                 COMMENT IF DEBUG THEN WRITE("MAK", I, PC) ;
05500 --    MOVESQUARE(I) ;
05501 --    POS(I) := CLIST ;
05502 --    FOR L := 1 UNTIL CLIST
05503 --    DO POSITION(I,L) := CHECKLIST(L) ;
05504 --    FOR L := SLIST UNTIL LIM
05505 --    DO POSITION(I,L) := CHECKLIST(L) ;
05506 --    POSITION(I,0) := KLIST ;
05507 --    L1 := LOSS(ELIMIT) ;
05508 --    FOR L := 1 UNTIL KLIST
05509 4-    DO BEGIN
05510 --      SQ := CHECKLIST(L) ;
05511 --      FIXIT(I, SQ, KK) ;
05512 --      IF (K*BRD(SQ) < 0)
05513 5-      THEN BEGIN
05514 --        L1 := L1 - 1 ;
05515 --        SQUARE(L1) := SQ ;
05516 --                       COMMENT IF DEBUG THEN WRITE("MAKE", I, PC, SQ) ;
05517 -5      END ;
05518 -4    END ;
05519 --    IF ABS(PC) = KING
05520 --    THEN FOR L := SLIST UNTIL LIM-1
05521 --         DO IF PC*BRD(CHECKLIST(L)) < 0
05522 4-            THEN BEGIN
05523 --              L1 := L1 - 1 ;
05524 --              SQUARE(L1) := CHECKLIST(L) ;
05525 -4         END ;
05526 --          COMMENT compensates for fundamental differences in handling King moves.
05527 --                  A King is said to "defend" those squares which are attacked
05528 --                  by opponent (even though not occupied by own piece) ;
05529 --    LOSS(ELIMIT) := L1 ;
05530 --    FOR L := SLIST UNTIL LIM-1
05531 --    DO FIXIT(I, CHECKLIST(L), KK) ;
05532 --    SEEKPAWN(I) ;
05533 -3  END OF_MAKE ;
05534 --  
05535 --  PROCEDURE MAKEMOVE (INTEGER VALUE N ; LOGICAL VALUE FINAL) ;
05536 --  
05537 --  COMMENT  moves pieces and keeps track of piece count. ;
05538 3-  BEGIN
05539 --    INTEGER I, TT, M, M1, T, L, K, OPAWN, PC, K_FILE, CREDITS, DEBITS,
05540 --            R_SQ, L_SQ, COL, GOOD, WEAK, K_PAWN, A, B, M21, M22, M31, M33,
05541 --            II, KSQ, SQ_K, ATTA, SQA, PASS_PAWN, DEFN, SQ3, NEW_DIR, NODEBIT ;
05542 --    LOGICAL ROOKMOVE, PP_CHANGE, DELIBERATE ;
05543 --    INTEGER ARRAY C, D(0::15) ;
05544 --                 COMMENT credits/debits C(0...15) AND D(0...15) EXPLAINED IN
05545 --                    awit.lib(15000) and at end of this file ;
05546 --  
05547 --    PROCEDURE MAKEFINAL ;
05548 4-    BEGIN
05549 --      MATE := IF TT >= 5
05550 --              THEN TRUE
05551 --              ELSE FALSE ;
05552 --      STALEM := IF ~GIVINGCH AND TT >= 1
05553 --                THEN TRUE
05554 --                ELSE FALSE ;
05555 --      HASH := -NEWHASH(BRD, K, KEY) ;
05556 --      STACK_HASH(LEVEL) := HASH ;
05557 --      VALUES(0) := 0 ;
05558 --      LASTSQ(LEVEL) := M3 ;
05559 --      LASTDIR(LEVEL) := NEW_DIR ;
05560 --      GARDE := EARLY ;
05561 --      IF GARDE AND (CON(-K,KSQ-1) = 0)
05562 --      THEN GARDE := FALSE ;
05563 --                    COMMENT make early game positions, in which the queen is
05564 --                                attacked, non-quiescent ;
05565 --      IF (M6 ~= EMPTY) AND ~PP_CHANGE
05566 5-      THEN BEGIN
05567 --        PIECES(M6) := PIECES(M6) - 1 ;
05568 --        PIECES(0) := PIECES(0) - 1 ;
05569 --        MEN(-K) := MEN(-K) - 1 ;
05570 -5      END ;
05571 --                    COMMENT capture ;
05572 --      FLAGS := TRUE ;
05573 --                    COMMENT  promotion increase separate. ;
05574 --      IF M14 ~= 0 AND ~PP_CHANGE
05575 --      THEN PIECES(K_PAWN) := PIECES(K_PAWN) - 1
05576 --      ELSE IF CASTLE(K) OR CASTLE(TWO(K))
05577 --           THEN IF (M4 = KING)
05578 --                THEN CASTLE(K) := CASTLE(TWO(K)) := FLAGS := FALSE
05579 --                ELSE IF (M4 = ROOK)
05580 --                     THEN IF (M2 = QRSQ(K))
05581 --                          THEN CASTLE(TWO(K)) := FLAGS := FALSE
05582 --                                      COMMENT  q-rook moving. ;
05583 --                          ELSE IF (M2 = KRSQ(K))
05584 --                               THEN CASTLE(K) := FLAGS := FALSE ;
05585 --                                COMMENT  k-rook moving. ;
05586 --      IF CASTLING
05587 --      THEN CASTLE(THREE(K)) := TRUE ;
05588 --      IF (ABS(M6) = ROOK)
05589 --      THEN IF (M3 = QRSQ(-K))
05590 --           THEN CASTLE(-TWO(K)) := FLAGS := FALSE
05591 --           ELSE IF (M3 = KRSQ(-K))
05592 --                THEN CASTLE(-K) := FLAGS := FALSE ;
05593 --      IF ~PP_CHANGE
05594 --      THEN DIFFVAL := DIFFVAL + (VALUES(ABS(M6)) +(IF M14 ~= 0
05595 --                                                   THEN VALUES(ABS(M14)) - PVAL
05596 --                                                   ELSE 0))*K ;
05597 --      ONEVAL := -K*DIFFVAL ;
05598 --                          COMMENT ONEVAL needed by tree reversal ;
05599 --      M := ELIMIT ;
05600 --      TWOVAL := 0 ;
05601 --      IF (ATTA ~= 0)
05602 --      THEN IF (SACRIFICE(M3, FALSE))
05603 5-           THEN BEGIN
05604 --             M := M - 1 ;
05605 --             SQUARE(M) := M3 ;
05606 --                            COMMENT  moving piece can be recaptured ;
05607 --             IF (LOSSES > TWOVAL)
05608 --             THEN TWOVAL := LOSSES ;
05609 --             LOSS(M) := VALUES(M4) ;
05610 -5      END ;
05611 --      FOR I := 1 UNTIL LOSS(0)
05612 --      DO IF (K*BRD(SQUARE(I)) > 0)
05613 --         THEN IF SACRIFICE(SQUARE(I), FALSE) OR SQR(10) ~= ATTASQRS(10)
05614 5-              THEN BEGIN
05615 --                M := M - 1 ;
05616 --                SQUARE(M) := SQUARE(I) ;
05617 --                LOSS(M) := IF (I > SQUARE(0))
05618 --                           THEN LOSSES
05619 --                           ELSE LOSS(I) ;
05620 --                IF LOSS(M) > TWOVAL
05621 --                THEN TWOVAL := LOSS(M) ;
05622 --                FOR J := M+1 UNTIL ELIMIT-1
05623 --                DO IF (SQUARE(M) = SQUARE(J))
05624 --                   THEN M := M + 1 ;
05625 -5      END ;
05626 --      LOSS(ELIMIT) := SQUARE(ELIMIT) := M ;
05627 --      IF M4 = KING
05628 --      THEN CHECK_SQRS(K) ;
05629 -4    END OF_MAKEFINAL ;
05630 --  
05631 --    PROCEDURE PAWN_MOVE ;
05632 4-    BEGIN
05633 --      INTEGER PC, TT ;
05634 --  
05635 --      DEFN := K*SEC(0,M3) ;
05636 --      IF EARLY
05637 5-      THEN BEGIN
05638 --        II := IF (K > 0)
05639 --              THEN 25
05640 --              ELSE 75 ;
05641 --                     COMMENT encourage appropriate pawn structure so that Bishops
05642 --                             can move ;
05643 --              IF (BASE = II) AND (ABS(BRD(II+2)) = PAWN)
05644 --                  OR (BASE = II+2) AND (ABS(BRD(II)) = PAWN)
05645 --                  OR (BASE = II-1) AND (ABS(BRD(II-3)) = PAWN)
05646 --                  OR (BASE = II-3) AND (ABS(BRD(II-1)) = PAWN)
05647 --              THEN C(1) := + (IF (M1 = PFTWO)
05648 --                              THEN IF ABS(BASE-II) > 1
05649 --                                   THEN 0
05650 --                                   ELSE 1
05651 --                              ELSE 1) ;
05652 -5      END ;
05653 --      IF (M7 ~= 0)
05654 --      THEN IF PAWNS(M3) = 0
05655 --           THEN PROMCAPT := ABS(M7)
05656 5-      ELSE BEGIN
05657 --        FOR L := -K_FILE, K_FILE
05658 6-        DO BEGIN
05659 --          I := M3 + L ;
05660 --          WHILE (BRD(I) = 0)
05661 --          DO I := I + L ;
05662 --          PC := BRD(I) ;
05663 --          IF ABS(PC) = ROOK
05664 --          THEN C(7) := C(7) + (IF DEFN >= 0 AND K*PC < 0
05665 --                               THEN 1
05666 --                               ELSE -1) ;
05667 --          IF PC = K_PAWN AND (ATTA = 0 OR DEFN >= 0
05668 --             AND ABS(BRD(CONTROL(M3,ATTA))) > PAWN)
05669 --          THEN C(2) := C(2) - 2 ;
05670 --                      COMMENT  double-pawn debit, if not recapturable ;
05671 --          I := BASE + L ;
05672 --          WHILE (BRD(I) = 0)
05673 --          DO I := I + L ;
05674 --          PC := BRD(I) ;
05675 --          IF ABS(PC) = ROOK
05676 --          THEN C(7) := C(7) + (IF K*PC > 0
05677 --                               THEN 1
05678 --                               ELSE -1) ;
05679 --          IF (PC = K_PAWN)
05680 --          THEN C(3) := C(3) + 1 ;
05681 --                  COMMENT undouble-pawn credit ;
05682 -6        END ;
05683 --                      COMMENT capture isolates/joins a pawn? ;
05684 --        D(1) := 0 ;
05685 --        FOR L := -1, 1
05686 6-        DO BEGIN
05687 --          COL := COLS(BASE) + L ;
05688 --          T := ISOLATE(COL, K_PAWN, -K_FILE, -K) ;
05689 --          IF T ~= 0 AND COL = COLS(M3)
05690 7-          THEN BEGIN
05691 --            T := -2 ;
05692 --            C(2) := 0 ;
05693 -7          END ;
05694 --          D(1) := D(1) + T ;
05695 -6        END ;
05696 --        IF C(2) = 0
05697 6-        THEN BEGIN
05698 --          BRD(M3) := 0 ;
05699 --          BRD(BASE) := K_PAWN ;
05700 --          D(1) := D(1) - ISOLATE(COLS(BASE), K_PAWN, -K_FILE, -K) ;
05701 --          BRD(M3) := K_PAWN ;
05702 --          BRD(BASE) := 0 ;
05703 -6        END ;
05704 -5      END ;
05705 --      IF ENDGAME OR RANKS(ROWS(M3)) = K OR PASS_PAWN = BASE OR M7 ~= 0
05706 5-      THEN BEGIN
05707 --        T := IF M14 ~= 0
05708 --             THEN 1
05709 --             ELSE PASSEDPAWN(M3, K) ;
05710 --                    COMMENT no credit for one square advance from pawn origin,
05711 --                            or if sacrificing then same credit as if not moving ;
05712 --        IF M7 = 0
05713 --        THEN IF PAWNS(BASE) = -K AND M1 ~= PFTWO
05714 --             THEN T := 0
05715 --             ELSE IF K*SEC(0,M3) < 0
05716 6-                  THEN BEGIN
05717 --                     TT := PASSEDPAWN(M3, -K) ;
05718 --                     IF T > 0 AND TT = 0
05719 --                     THEN T := 1
05720 --                     ELSE T := TT ;
05721 -6                  END ;
05722 --        IF T > 0
05723 --        THEN IF PASS_PAWN = KSQ OR (ROWS(M3) -ROWS(PASS_PAWN))*K > 0
05724 --                 OR ROWS(M3) = ROWS(PASS_PAWN) AND (CON(-K,M3) = 0
05725 --                 AND CON(-K,PASS_PAWN) ~= 0 OR CON(-K,M3+K_FILE) = 0
05726 --                 AND CON(-K,PASS_PAWN+K_FILE) ~= 0)
05727 --             THEN IF ~FINAL
05728 --                  THEN PASS_PAWN := M3
05729 6-                  ELSE BEGIN
05730 --                    IF PAWNS(M3) ~= 0
05731 --                    THEN CLEARPAWN(K) := M3
05732 --                    ELSE IF STARTTHISPROBLEM(TRUE)
05733 --                         THEN PP_CHANGE := TRUE
05734 --                         else write("Impossible", KSQ, PASS_PAWN, M3) ;
05735 --                    PASS_PAWN := CLEARPAWN(K) ;
05736 -6        END ;
05737 --        IF DEBUG
05738 --        THEN WRITE("PASS", M3, CLEARPAWN(K), PASS_PAWN, T, FINAL) ;
05739 --                          COMMENT PASS_PAWN only updated if new primary pawn ;
05740 --                          COMMENT  credit for pushing passed pawn ;
05741 --        IF T > 1
05742 --        THEN IF DEFN >= 0
05743 6-             THEN BEGIN
05744 --               PP_STATUS := PASSEDPAWN(BASE, K) +
05745 --                              (IF RANKS(ROWS(M3)) = -K
05746 --                               THEN PAWNVAL(ROWS(M3))
05747 --                               ELSE PAWNVAL(ROWS(BASE))) ;
05748 --               T := T + PAWNVAL(ROWS(M3)) ;
05749 --               IF FINAL
05750 --               THEN T := T - PP_STATUS ;
05751 --               IF BOTV(KING,OFFSET(M33)-OFFSET(SQ_K)) ~= 2
05752 --               THEN PP_STATUS := PP_STATUS DIV 2
05753 --               ELSE T := T DIV 2 ;
05754 -6        END ELSE T := T DIV 2 ;
05755 --                                COMMENT O.K. as long as OPAWN is not pinned ;
05756 --        IF DEBUG
05757 --        THEN WRITE("P-M", M3, PASS_PAWN, PP_STATUS, T,DEFN) ;
05758 --        IF PASS_PAWN = M3
05759 --        THEN D(15) := D(15) + T
05760 --        ELSE D(2) := T ;
05761 --        IF CLEARPAWN(-K) ~= SQ_K AND CLEARPAWN(-K) ~= M3
05762 --             AND M4 = PAWN AND PASSEDPAWN(CLEARPAWN(-K), -K) = 0
05763 6-        THEN BEGIN
05764 --          BRD(M3) := 0 ;
05765 --          D(2) := D(2) + PASSEDPAWN(CLEARPAWN(-K), -K) ;
05766 --          BRD(M3) := M5 ;
05767 -6        END ;
05768 --                          COMMENT  pawn capture may deny opponent passed pawn ;
05769 --        IF DEBUG
05770 --        THEN WRITE("ELIM", CLEARPAWN(-K), SQ_K, D(2), M3) ;
05771 --                          COMMENT do not accumulate ;
05772 --        IF DELIBERATE
05773 --        THEN NODEBIT := NODEBIT + D(2) ;
05774 --                          COMMENT debit for creating passed pawn ;
05775 --        A := M22 - 1 ;
05776 --        B := M22 + 1 ;
05777 --        IF (M3 = A)
05778 --        THEN A := A + 1
05779 --        ELSE IF (M3 = B)
05780 --             THEN B := B - 1 ;
05781 --             FOR J := 0 STEP K_FILE UNTIL (IF (M1 = PFTWO)
05782 --                      THEN K_FILE
05783 --                      ELSE 0)
05784 --        DO FOR I := A+J, B+J
05785 --        DO IF BRD(I) = OPAWN OR BRD(I+K_FILE) = OPAWN AND BRD(I) = NIL
05786 6-           THEN BEGIN
05787 --             II := I - K_FILE ;
05788 --             IF BRD(I) = NIL OR BRD(II) ~= NIL
05789 --             THEN II := I ;
05790 --             T := PASSEDPAWN(II, -K) ;
05791 --             IF DEBUG
05792 --             THEN WRITE("PP_CRE", I, BRD(I), II, T) ;
05793 --                               COMMENT see if opponent can create a pp.,
05794 --                                       either by pushing or by capturing ;
05795 7-             IF BRD(I) = NIL THEN BEGIN
05796 --               TT := PASSEDPAWN(M3, -K) ;
05797 --               IF T > 0 AND BRD(M3+K_FILE) ~= OPAWN
05798 --               THEN T := T - PASSEDPAWN(M3+K_FILE, K) ;
05799 --               IF T < TT
05800 --               THEN T := TT ;
05801 -7             END ;
05802 --                      COMMENT does each side get equal pp potential ;
05803 --                      COMMENT IF RANKS(ROWS(II)) = -K THEN T := T + PAWNVAL(ROWS(II)) ;
05804 --             IF T < 0
05805 --             THEN T := 0 ;
05806 --             D(3) := D(3) -T ;
05807 -6        END ;
05808 -5      END ;
05809 --                          COMMENT Phalanx, backpawn and hole removal ;
05810 --    IF (M1 = PFTWO OR PAWNS(BASE) ~= -K)
05811 5-    THEN BEGIN
05812 --      T := 0 ;
05813 --      COL := ABS(COLS(M3) - COLS(KSQ)) ;
05814 --                          COMMENT  5. Phalanx creation credit, and hole removal ;
05815 --      IF (~OPENING OR COL > 1)
05816 --      THEN T := T + (IF BRD(M3+1) = K_PAWN
05817 --                     THEN IF BRD(M3-1) = K_PAWN
05818 --                          THEN 2
05819 --                          ELSE 1
05820 --                          ELSE IF BRD(M3-1) = K_PAWN
05821 --                               THEN 1
05822 --                               ELSE 0) ;
05823 --                          COMMENT  4.  Push backward pawns, if no phalanx credit,
05824 --                                           if in home half of board ;
05825 --      IF ~OPENING AND T = 0
05826 --      THEN IF (COL > 1 OR ENDGAME) AND (BACKPAWN(BASE, -K_FILE, K_PAWN) > 0)
05827 --              AND RANKS(ROWS(BASE))*K < 0
05828 --           THEN T := T + 1 ;
05829 --                          COMMENT  5a.  Hole removal ;
05830 --      IF COL = 1
05831 --      THEN IF M1 = PFTWO
05832 --           THEN T := T + (IF BRD(M31-1) = K_PAWN AND BRD(M31+1) = K_PAWN
05833 --                          THEN 1
05834 --                          ELSE 0)
05835 --                          ELSE IF OPENING AND BRD(M3+1) = K_PAWN
05836 --                                    AND BRD(M3-1) = K_PAWN
05837 --                               THEN T := T + 1 ;
05838 --      C(4) := + T ;
05839 -5    END ;
05840 --                          COMMENT   debit for creating holes ;
05841 --      T := 0 ;
05842 --      FOR I := -2, 0, 2
05843 --      DO IF BRD(M33+I) = OPAWN AND (I = 0 OR BRD(M33) = 0)
05844 --         THEN FOR J := -1, 1
05845 --              DO IF I*J >= 0
05846 --                 THEN IF BRD(M31+J) = K_PAWN AND BACKPAWN(M31+J, -K_FILE, K_PAWN) > 0
05847 --                      THEN IF SEC(0,M3+J)*K < 0
05848 --                           THEN T := T - 2 ;
05849 --                                    COMMENT  V formation debit ;
05850 --      IF BRD(M3-2) = K_PAWN AND BRD(M31-1) = K_PAWN
05851 --      THEN T := T - 1 ;
05852 --      IF BRD(M3+2) = K_PAWN AND BRD(M31+1) = K_PAWN
05853 --      THEN T := T - 1 ;
05854 --      D(4) := T ;
05855 -4    END OF_PAWN_MOVE ;
05856 --  
05857 --    PROCEDURE CAPTURE ;
05858 4-    BEGIN
05859 --                        COMMENT  have captured a pawn ;
05860 --      FOR L := -1, 0, 1
05861 5-      DO BEGIN
05862 --        I := M31 + L ;
05863 --        WHILE (ABS(BRD(I)) ~= PAWN) AND (BRD(I) ~= EDGE)
05864 --        DO I := I - K_FILE ;
05865 --                       COMMENT capture creates passed pawn ;
05866 --        T := IF (BRD(I) = K_PAWN)
05867 --             THEN PASSEDPAWN(I, K)
05868 --             ELSE 0 ;
05869 --        IF T > 0
05870 6-        THEN BEGIN
05871 --                      COMMENT do not get too excited about wing pawns ;
05872 --          IF COLS(I) = 1 OR COLS(I) = 8
05873 --          THEN T := T - 1 ;
05874 --          IF FINAL AND PASS_PAWN ~= KSQ AND COLS(I) ~= COLS(PASS_PAWN)
05875 --          THEN DEBITS := DEBITS + T ;
05876 --                          COMMENT  carry forward credits for second pp ;
05877 --          IF PASS_PAWN = KSQ OR (ROWS(I) - ROWS(PASS_PAWN))*K > 0
05878 --          THEN IF FINAL
05879 --               THEN PASS_PAWN := CLEARPAWN(K) := I
05880 --               ELSE PASS_PAWN := I ;
05881 --                    COMMENT if PASS_PAWN = I then new principal passed pawn ;
05882 --          IF PASS_PAWN = I
05883 --          THEN D(13) := D(13) + T
05884 --          ELSE D(5) := D(5) + T ;
05885 --                    COMMENT debit opponent for secondary PP creation ;
05886 --          IF DEBUG
05887 --          THEN WRITE("NEW_PP", PASS_PAWN, I, T, BRD(I), K_PAWN) ;
05888 -6        END ;
05889 -5      END ;
05890 --      IF DELIBERATE
05891 --      THEN NODEBIT := NODEBIT + D(5) ;
05892 --      IF ABS(ATTA) ~= 1
05893 --      THEN I := 0 ELSE
05894 --      I := IF BRD(M33-1) = OPAWN
05895 --           THEN M33 - 1
05896 --           ELSE IF BRD(M33+1) = OPAWN
05897 --                THEN M33 + 1
05898 --                ELSE 0 ;
05899 --      D(6) := 0 ;
05900 --                    COMMENT did we capture an isolated pawn ;
05901 --      IF I = 0 AND LEVEL > 1
05902 --      THEN D(6) := +ISOLATE(COLS(M3), OPAWN, K_FILE, K) ;
05903 --      IF I ~= 0
05904 5-      THEN BEGIN
05905 --                    COMMENT recapture leaves opponent with isolated pawn ;
05906 --        BRD(I) := 0 ;
05907 --        BRD(M3) := OPAWN ;
05908 --        D(6) := -ISOLATE(COLS(M3), OPAWN, K_FILE, K) ;
05909 --        BRD(I) := OPAWN ;
05910 --        BRD(M3) := M5 ;
05911 -5      END ;
05912 --                    COMMENT did the capture create an isolated pawn? ;
05913 --      IF I = 0
05914 --      THEN FOR L := -1, 1
05915 --           DO D(6) := D(6) - ISOLATE(COLS(M3)+L, OPAWN, K_FILE, K) ;
05916 --      II := LASTSQ(LEVEL-1) ;
05917 --      I := IF M3 = II
05918 --           THEN M33
05919 --           ELSE M3 ;
05920 --      T := 0 ;
05921 --      IF (RANKS(ROWS(I)) = -K)
05922 --      THEN T := T + PAWNVAL(ROWS(I)) ;
05923 --                    COMMENT SACRIFICE gives credit for capturing advanced pawn ;
05924 --      IF M3 = CLEARPAWN(-K)
05925 5-      THEN BEGIN
05926 --        T := T + PASSEDPAWN(I, -K) + PP_BLOCK(M3, -K_FILE) ;
05927 --        IF FINAL
05928 --        THEN IF STARTTHISPROBLEM(TRUE)
05929 --             THEN PP_CHANGE := TRUE ;
05930 -5      END ELSE IF CLEARPAWN(-K) ~= KINGSQ(-K)
05931 --               THEN T := T + PASSEDPAWN(I, -K)
05932 --               ELSE IF (ENDGAME OR T >= 3) AND (LEVEL = 1 OR M3 ~= II)
05933 --                    THEN T := T + (IF M3 ~= II AND BRD(M31) = NIL
05934 --                                   THEN PASSEDPAWN(M31, -K)
05935 --                                   ELSE IF M4 = PAWN
05936 --                     THEN 0
05937 --                     ELSE PASSEDPAWN(I, -K)) ;
05938 --                          COMMENT either captured principal or secondary passed pawn,
05939 --                                  or advanced pawn ;
05940 --      IF T ~= 0 AND DEBUG
05941 --      THEN WRITE("RID_AP", PASS_PAWN, M3, T, II, I, CLEARPAWN(-K), DELIBERATE) ;
05942 --                          COMMENT do not accummulate, deliberate opponent ;
05943 --      D(7) := + T ;
05944 --      IF DELIBERATE
05945 --      THEN IF LEVEL = 1
05946 --           THEN NODEBIT := NODEBIT + T
05947 --           ELSE NODEBIT := NODEBIT + T ;
05948 --                          COMMENT opponent debit for loss of PP ;
05949 --      IF ABS(ATTA) <= 2
05950 5-      THEN BEGIN
05951 --                          COMMENT will a recapture double pawns ;
05952 --        IF (BRD(M33+1) = OPAWN OR BRD(M33-1) = OPAWN)
05953 --            AND (BRD(M31) = OPAWN OR BRD(M33) = OPAWN OR BRD(M33+K_FILE) = OPAWN)
05954 --        THEN C(5) := + (IF ABS(ATTA) = 1
05955 --                        THEN 2
05956 --                        ELSE 1) ;
05957 -5      END ;
05958 --                          COMMENT credit for backpawn capture.
05959 --                                 No special credit for capturing isolated pawn ;
05960 --      IF ~OPENING AND BACKPAWN(M3, K_FILE, OPAWN) > 0
05961 --        AND ISOLATE(COLS(M3), PAWN, K_FILE, K) = 0
05962 --      THEN D(11) := 1 ;
05963 -4    END OF_CAPTURE ;
05964 --  
05965 --    PROCEDURE SPECIAL_MOVE ;
05966 4-    BEGIN
05967 --      IF (M1 = QSIDE) OR (M1 = KSIDE)
05968 5-      THEN BEGIN
05969 --                       COMMENT   m8 is the new square of the rook ;
05970 --                       COMMENT   m9 is the old square of the rook ;
05971 --        IF (M1 = QSIDE)
05972 6-        THEN BEGIN
05973 --                      COMMENT  castle q-side ;
05974 --          M8 := R_SQ ;
05975 --          L := L_SQ ;
05976 --          M9 := L_SQ - 1 ;
05977 --                    COMMENT   queen rook ;
05978 -6        END ELSE IF (M1 = KSIDE)
05979 6-                 THEN BEGIN
05980 --                         COMMENT  castle k-side. ;
05981 --                   M8 := L_SQ ;
05982 --                   L := M3 ;
05983 --                   M9 := R_SQ ;
05984 --                      COMMENT   king rook ;
05985 -6        END ;
05986 --        M10 := BRD(M8) := BRD(M9) ;
05987 --        CASTLING := TRUE ;
05988 --        UNMAKE(M9) ;
05989 --        IF ~ENDGAME
05990 6-        THEN BEGIN
05991 --          FOR J := L, L-1, L+1
05992 7-          DO BEGIN
05993 --            GOOD := WEAK := 0 ;
05994 --            FOR I := 1,2,3
05995 --            DO IF (BRD(J+I*K_FILE) = K_PAWN)
05996 --               THEN GOOD := 1 ;
05997 --            FOR I := 4,5,6
05998 --            DO IF (BRD(J+I*K_FILE) = OPAWN)
05999 --               THEN WEAK := -1 ;
06000 --            GOODCASTLE := GOODCASTLE + ( IF (WEAK = 0)
06001 --                                         THEN -GOOD
06002 --                                         ELSE GOOD - WEAK) ;
06003 --                               COMMENT goodcastle is incremented by -1, 0, 1, or 2 ;
06004 --            IF (J = L) AND (GOODCASTLE = 0)
06005 --            THEN GOODCASTLE := -1 ;
06006 -7          END ;
06007 --          GOODCASTLE := IF (GOODCASTLE < -1)
06008 --                        THEN -2
06009 --                        ELSE IF (GOODCASTLE > 3)
06010 --                             THEN 2
06011 --                             ELSE IF (GOODCASTLE > 1)
06012 --                                  THEN 1
06013 --                                  ELSE IF (GOODCASTLE < 1)
06014 --                    THEN -1
06015 --                    ELSE 0 ;
06016 --          C(7) := C(7) + OPENFILE(M8) ;
06017 -6        END ;
06018 -5      END ELSE IF ~ENDGAME AND (M4 = KING)
06019 --               THEN GOODCASTLE := IF CASTLE(K) ~= CASTLE(TWO(K))
06020 --                                  THEN -1
06021 --                                  ELSE IF CASTLE(K)
06022 --                    THEN -2
06023 --                    ELSE 0
06024 --                    ELSE IF (M1 = ENPRIS)
06025 5-                         THEN BEGIN
06026 --                           M9 := M31 ;
06027 --                           UNMAKE(M9) ;
06028 --                                     COMMENT m9 is the square of the enpassant
06029 --                                                 pawn. ;
06030 --                           M6 := M10 := OPAWN ;
06031 -5      END ELSE IF (M1 = PFTWO)
06032 5-               THEN BEGIN
06033 --                             COMMENT board edge takes care of things ;
06034 --                 IF (BRD(R_SQ) = OPAWN) OR (BRD(L_SQ) = OPAWN)
06035 6-                 THEN BEGIN
06036 --                   M8 := M31 ;
06037 --                   BRD(M8) := -M12 ;
06038 --                   REMEMBER := TRUE ;
06039 --                             COMMENT m8 is a potential ep. sq ;
06040 --                   IF (BRD(R_SQ) = OPAWN)
06041 --                   THEN REMAKE(R_SQ, R_SQ) ;
06042 --                   IF (BRD(L_SQ) = OPAWN)
06043 --                   THEN REMAKE(L_SQ, L_SQ) ;
06044 -6                 END ;
06045 --                 COL := COLS(M3) ;
06046 --                 IF OPENING AND ABS(BRD(M33)) ~= PAWN
06047 6-                 THEN BEGIN
06048 --                   IF ((COL = 8) AND (CASTLE(K) OR EARLY)) OR ((COL = 1)
06049 --                        AND (CASTLE(TWO(K)) OR EARLY))
06050 --                   THEN C(9) := IF ABS(COL - COLS(KINGSQ(-K))) > 2
06051 --                                THEN -2
06052 --                                ELSE 0 ;
06053 --                       COMMENT  discourage P-R4 ;
06054 -6                 END ;
06055 --                 IF ~ENDGAME
06056 --                 THEN IF COL ~= 5 AND COL = COLS(KSQ)
06057 --                      THEN C(10) := -1 ;
06058 -5      END ;
06059 -4    END OF_SPECIAL_MOVE ;
06060 --  
06061 --  COMMENT "PASSED PAWN SITUATIONS" ;
06062 --  
06063 --    PROCEDURE OPPON_PP ;
06064 4-    BEGIN
06065 --      I := PP_BLOCK(CLEARPAWN(-K), -K_FILE) ;
06066 --      T := PASSEDPAWN(CLEARPAWN(-K), -K) ;
06067 --      IF DEBUG
06068 --      THEN WRITE("PROMOTE", CLEARPAWN(-K), I, T) ;
06069 --      IF T > 7 OR T = 7 AND I <= 0
06070 --      THEN I := I - (IF GIVINGCH
06071 --                     THEN 1
06072 --                     ELSE 2)*(T-6) ;
06073 --      IF I > 0
06074 --      THEN T := T + 2 ;
06075 --                       COMMENT promotion imminent ;
06076 --      D(14) := I - (IF GIVINGCH OR M6 ~= 0 AND M4 >= ROOK
06077 --                    THEN T DIV 2
06078 --                    ELSE T) ;
06079 -4    END OF_OPPON_PP ;
06080 --  
06081 --    PROCEDURE COMPU_PP ;
06082 4-    BEGIN
06083 --      INTEGER LL ;
06084 --  
06085 --      IF ROOKMOVE
06086 --      THEN C(14) := IF COLS(M3) = COLS(PASS_PAWN)
06087 --                    THEN 1
06088 --                    ELSE IF COLS(BASE) = COLS(PASS_PAWN)
06089 --                         THEN -1
06090 --                         ELSE 0 ;
06091 --      I := PASS_PAWN ;
06092 --      II := I + FILES(K) ;
06093 --      L := IF PAWNS(I) ~= 0
06094 --           THEN SEC(0,II)*K
06095 --           ELSE -1 ;
06096 --      LL := K*SEC(0,I) ;
06097 --      T := PASSEDPAWN(I, K) ;
06098 --      IF LL < 0 AND (~GIVINGCH OR L < 0)
06099 --      THEN T := T DIV 2 ;
06100 --      IF T > 0 AND BRD(II) = 0 AND (L >= 0 OR LL < 0)
06101 --      THEN C(15) := + 1 + L ;
06102 --      IF T = 7 AND PAWNS(I) = K AND (L >= 0 OR LL = -K
06103 --               AND HIDDEN(II, I, I, K, FALSE))
06104 --      THEN T := 9 ;
06105 --      IF PASS_PAWN = M3
06106 --      THEN IF LL >= 0
06107 --           THEN T := T      COMMENT was T - 2 ;
06108 --           ELSE T := PASSEDPAWN(I-FILES(K), K) ;
06109 --      IF DEBUG
06110 --      THEN WRITE("COMPU_PP", PASS_PAWN, M3, T, L, LL) ;
06111 --      IF D(14) = 0
06112 --      THEN T := IF T < 3
06113 --                THEN T
06114 --                ELSE IF T > 9
06115 --                     THEN 10
06116 --                     ELSE IF T > 8
06117 --                          THEN 6
06118 --                          ELSE IF T > 7
06119 --                               THEN 4
06120 --                               ELSE 2 ;
06121 --      IF D(13) = 0
06122 --      THEN D(15) := D(15) + T ;
06123 -4    END OF_COMPU_PP ;
06124 --  
06125 --  @TITLE, "MAKEMOVE"
06126 --  
06127 --    FOR I := 1 UNTIL 15
06128 --    DO C(I) := D(I) := 0 ;
06129 --    PP_CHANGE := FALSE ;
06130 --    M2 := MOVEFROM(N) ;
06131 --    CASTLING := FALSE ;
06132 --    K := IF (BRD(M2) > 0)
06133 --         THEN 1
06134 --         ELSE -1 ;
06135 --    PROMCAPT := M8 := M9 := M14 := M10 := 0 ;
06136 --    K_PAWN := K*PAWN ;
06137 --    OPAWN := -K_PAWN ;
06138 --    K_FILE := FILES(K) ;
06139 --    PASS_PAWN := CLEARPAWN(K) ;
06140 --    C(0) := -DEBIT(LEVEL-2) ;
06141 --    IF FINAL
06142 4-    THEN BEGIN
06143 --      DEBIT(LEVEL) := DEBIT(LEVEL-1) := 0 ;
06144 --      PP_STATUS := 0 ;
06145 --      LOSS(ELIMIT) := SQUARE(ELIMIT) ;
06146 --      REMEMBER := TERMINAL := TRUE ;
06147 --      BASE := M2 ;
06148 -4    END ;
06149 --    CREDIT(LEVEL) := CREDIT(LEVEL-2) ;
06150 --    D(0) := GOODCASTLE := BACKROW := 0 ;
06151 --    CREDITS := DEBITS := 0 ;
06152 --    MAKEMV := TRUE ;
06153 --    M3 := MOVETO(N) ;
06154 --    M5 := BRD(M2) ;
06155 --    M4 := ABS(M5) ;
06156 --    SQ_K := KINGSQ(-K) ;
06157 --    KSQ := IF M4 = KING
06158 --           THEN BASE
06159 --           ELSE KINGSQ(K) ;
06160 --    DELIBERATE := M3 = LASTSQ(LEVEL-1) ;
06161 --    NODEBIT := 0 ;
06162 --    IF (REMEMBER)
06163 4-    THEN BEGIN
06164 --      T := SQUARE(0) ;
06165 --      L := SQUARE(ELIMIT) ;
06166 --      IF FINAL
06167 --      THEN HIDDENLOSS(N, T, L) ;
06168 --      M11 := 0 ;
06169 --      M12 := -ENPRIS*K ;
06170 --      L := 46 + 15*K ;
06171 --      T := L + 7 ;
06172 --      FOR I := L UNTIL T
06173 --      DO IF (BRD(I) = M12)
06174 5-         THEN BEGIN
06175 --           BRD(I) := EMPTY ;
06176 --           M11 := I ;
06177 -5      END ;
06178 --      RLIST(0) := TLIST(0) := KSQ ;
06179 --      P_NUMB := 1 ;
06180 --      RLIST(1) := TLIST(1) := SQ_K ;
06181 -4    END ;
06182 --    M6 := M7 := BRD(M3) ;
06183 --    NEW_DIR := IF INCHECK OR CASTLING OR M7 ~= 0 OR M4 = PAWN
06184 --               THEN 0
06185 --               ELSE ABS(BOTV(EDGE, OFFSET(BASE) -OFFSET(M3))) ;
06186 --    IF BASE = OLD_DEST AND NEW_DIR = OLD_DIR
06187 --    THEN C(13) := -1 ;
06188 --                       COMMENT tempo loss, inline move ;
06189 --    NUMB := T_NUMB := P_NUMB ;
06190 --    M1 := ABS(REWARD(N)) ;
06191 --    IF (M1 < CHECKING)
06192 --    THEN TT := 0
06193 4-    ELSE BEGIN
06194 --      TT := M1 DIV CHECKING ;
06195 --      M1 := M1 REM CHECKING ;
06196 -4    END ;
06197 --    ROOKMOVE := IF (M4 = ROOK) AND (ROWS(BASE) = ROWS(M3))
06198 --                THEN TRUE
06199 --                ELSE FALSE ;
06200 --    IF M4 = ROOK AND ~ROOKMOVE AND K*SEC(0,M3) > 0
06201 4-    THEN BEGIN
06202 --      IF ABS(ROWS(M3) - ROWS(SQ_K)) = 1
06203 --      THEN D(8) := + 1 ;
06204 --      IF ABS(ROWS(BASE) - ROWS(SQ_K)) = 1 AND ROWS(M3) ~= ROWS(SQ_K)
06205 --      THEN D(8) := D(8) - 1 ;
06206 -4    END ;
06207 --    UNMAKE(M2) ;
06208 --                       COMMENT   moving piece ;
06209 --    IF (M7 ~= 0)
06210 --    THEN UNMAKE(M3) ;
06211 --                       COMMENT   captured piece ;
06212 --    IF (M1 > PFTWO)
06213 4-    THEN BEGIN
06214 --      M1 := M1 - PROMOTE ;
06215 --      BRD(M3) := M14 := (M1)*K ;
06216 --                    COMMENT   promoted piece ;
06217 --      PIECES(M14) := PIECES(M14) + 1 ;
06218 -4    END ELSE BRD(M3) := M5 ;
06219 --    IF (M3 = M11)
06220 --    THEN M7 := M12 ;
06221 --    IF ROOKMOVE
06222 --    THEN C(8) := DOUBLE(M3, FILE, K) - DOUBLE(BASE, FILE, K)
06223 --    ELSE IF ENDGAME AND M4 = ROOK AND COLS(BASE) = COLS(M3)
06224 --         THEN C(8) := DOUBLE(M3, 1, K) - DOUBLE(BASE, 1, K) ;
06225 --                       COMMENT GIVING UP FILE? ;
06226 --    M33 := M3 + K_FILE ;
06227 --    M22 := BASE + K_FILE ;
06228 --    M31 := M3 - K_FILE ;
06229 --    M21 := BASE -K_FILE ;
06230 --      COMMENT   M33
06231 --                M3
06232 --                M31
06233 --                     used primarily to locate blocked pawns.
06234 --                M22
06235 --                BASE
06236 --                M21 ;
06237 --    R_SQ := M3 + 1 ;
06238 --    L_SQ := M3 - 1 ;
06239 --    IF M1 > KING
06240 --    THEN SPECIAL_MOVE ;
06241 --    FOR L := CON(-1,M2) UNTIL CON(1,M2)
06242 --    DO IF (L ~= 0)
06243 --       THEN REMAKE(CONTROL(M2,L), M2) ;
06244 --    IF REMEMBER
06245 --    THEN P_NUMB := NUMB ;
06246 --    REMEMBER := TERMINAL ;
06247 --                       COMMENT   only increment numb if terminal move ;
06248 --    FOR L := CON(-1,M3) UNTIL CON(1,M3)
06249 --    DO IF (L ~= 0)
06250 --       THEN REMAKE(CONTROL(M3,L), M3) ;
06251 --    IF (M10 = OPAWN) OR (CASTLING)
06252 --    THEN
06253 4-    BEGIN
06254 --                      COMMENT   enpassant pawn ;
06255 --      FOR L := CON(-1,M9) UNTIL CON(1,M9)
06256 --      DO IF (L ~= 0)
06257 --         THEN REMAKE(CONTROL(M9,L), M9) ;
06258 --      IF (CASTLING)
06259 5-      THEN BEGIN
06260 --                    COMMENT   ex defence of rooks square ;
06261 --        FOR L := CON(-1,M8) UNTIL CON(1,M8)
06262 --        DO IF (L ~= 0)
06263 --           THEN REMAKE(CONTROL(M8,L), M8) ;
06264 --        MAKE(M8) ;
06265 -5      END ;
06266 -4    END ;
06267 --    MAKEMV := FALSE ;
06268 --    MAKE(M3) ;
06269 --    IF ROOKMOVE
06270 --    THEN C(7) := C(7) - OPENFILE(BASE) + OPENFILE(M3) ;
06271 --                    COMMENT capture of a pawn may open, or half open, a file(+1).
06272 --                            Also, doubled rooks may exist.
06273 --                               Note a minor piece may capture a pawn and open
06274 --                               a file which contains a rook/queen ;
06275 --    IF M7 = OPAWN THEN
06276 --    IF M4 = ROOK AND COLS(M3) = COLS(BASE)
06277 --    THEN C(8) := C(8) + DOUBLE(M3, FILE, K) + 1
06278 4-    ELSE FOR J := -10, 10 DO BEGIN
06279 --      SQ3 := M3 ;
06280 --      PC := 0 ;
06281 --      WHILE ABS(PC) ~= EDGE AND PC ~= PAWN
06282 5-      DO BEGIN
06283 --        SQ3 := SQ3 + J ;
06284 --        PC := K*BRD(SQ3) ;
06285 --        IF PC = ROOK
06286 --        THEN C(8) := C(8) + 1 ;
06287 -5      END ;
06288 -4    END ;
06289 --    IF M4 >= BISHOP AND M4 <= QUEEN
06290 --    THEN HIDDENATTACK ;
06291 --    IF (M4 = KING)
06292 4-    THEN BEGIN
06293 --      IF FINAL AND (PASS_PAWN = BASE)
06294 --      THEN CLEARPAWN(K) := M3 ;
06295 --      KINGSQ(K) := M3 ;
06296 --      KINGCONTROL(K) ;
06297 -4    END ;
06298 --        COMMENT  REMAKE(KSQ, KSQ) ;
06299 --    REMAKE(SQ_K, SQ_K) ;
06300 --    ATTA := CON(-K,M3) ;
06301 --    IF (M4 = PAWN)
06302 --    THEN PAWN_MOVE ;
06303 --    IF (M7 = OPAWN) OR (ABS(M7) = ENPRIS)
06304 --    THEN CAPTURE ;
06305 --    IF OPENING
06306 4-    THEN BEGIN
06307 --                        COMMENT penalize early queen moves ;
06308 --      IF EARLY
06309 --      THEN IF (M4 = QUEEN) AND M1 = 0 AND (CON(-K,BASE) = 0) AND ~INCHECK
06310 --           THEN C(11) := -3 ;
06311 --           IF M4 = KING AND ~CASTLING AND ~INCHECK
06312 --           THEN C(11) := -1 ;
06313 --                          COMMENT is the King forced to recapture ;
06314 --      IF M7 ~= 0 AND CON(-K,M3) = -K AND CONTROL(M3,-K) = KINGSQ(-K)
06315 --      THEN C(11) := C(11) + 1 ;
06316 --      BACKROW := IF (M4 = BISHOP OR M4 = KNIGHT)
06317 --                                 AND ROWS(BASE) = (IF K > 0
06318 --                                                   THEN 1
06319 --                                                   ELSE 8)
06320 --                 THEN AGITATE + 1
06321 --                 ELSE AGITATE ;
06322 -4    END ;
06323 --      IF M4 = KING AND ~CASTLING AND ~ENDGAME
06324 --      THEN IF (CASTLE(K) OR CASTLE(2*K))
06325 --           THEN C(11) := -2 ;
06326 --                             COMMENT can one threaten a checking fork? ;
06327 --    IF M4 > PAWN AND M4 < KING
06328 --    THEN FOR I := 1 UNTIL POS(M3)
06329 --         DO IF FORKS(-K,POSITION(M3,I)) = M5
06330 --            THEN C(11) := C(11) + 3 ;
06331 --                      COMMENT influence on pawn structures ;
06332 --                      COMMENT give pawn structure credits ;
06333 --                      COMMENT 1. Block opponent pawn, fill hole with N, P, or B ;
06334 --    IF (BRD(M33) = OPAWN) AND (ATTA = 0 OR SEC(0,M3)*K >= 0)
06335 4-    THEN BEGIN
06336 --      T := BACKPAWN(M33, K_FILE, OPAWN) ;
06337 --      IF T < 0 AND M4 ~= KNIGHT
06338 --      THEN T := 0 ;
06339 --      IF (T > 0) AND (M4 <= BISHOP)
06340 --      THEN T := IF M4 = PAWN AND BACKPAWN(M3, -K_FILE, K_PAWN) > 0
06341 --                THEN 0
06342 --                ELSE T ;
06343 --      D(9) := T ;
06344 --                       COMMENT - fix opponent hole ;
06345 --      T := D(4) ;
06346 --      IF M4 = PAWN OR M4 = BISHOP OR M4 = QUEEN
06347 --      THEN FOR J := -1, 1
06348 --           DO IF BRD(M33+K_FILE+J) = OPAWN AND BRD(M33+J) = EMPTY
06349 --              THEN IF NEW_DIR ~= ABS(M33+J-M3)
06350 5-                   THEN BEGIN
06351 --                          COMMENT can pawn advance safely ;
06352 --                     II := K*CON(0,M33+J) ;
06353 --                     IF II > 1 OR
06354 --                        II = 1 AND ~HIDDEN(M33+J, M33+J+K_FILE, SQ3, -K, FALSE)
06355 --                     THEN T := T + 2 ;
06356 -5                   END ;
06357 --      D(4) := T ;
06358 -4    END ;
06359 --                          COMMENT 3.  Do not block own pawns after opening phase.
06360 --                                      Do not block central pawn anytime ;
06361 --    IF ~INCHECK AND M1 = 0 AND BRD(M31) = K_PAWN AND (COLS(M3) = 4
06362 --            OR COLS(M3) = 5 OR ~EARLY AND ROWS(BASE) ~= ROWS(KRSQ(K))
06363 --                                      AND BACKPAWN(M31, -K_FILE, K_PAWN) > 0)
06364 --    THEN D(10) := -1 ;
06365 --    T := 0 ;
06366 --                          COMMENT  6. Unblock own backward pawns after opening phase ;
06367 --    IF ~EARLY AND ~INCHECK AND (BRD(M21) = K_PAWN)
06368 --         AND (BACKPAWN(M21,-K_FILE, K_PAWN) > 0)
06369 --    THEN T := T + 1 ;
06370 --                          COMMENT 2. Do not unblock opponent backward pawns ;
06371 --    IF ~INCHECK AND M22 ~= M33 AND BRD(M22) = OPAWN
06372 --        AND K*CON(0,BASE) > 0
06373 --        AND RANKS(ROWS(M22)) = K AND (BACKPAWN(M22, K_FILE, OPAWN) > 0)
06374 --    THEN T := T - 1 ;
06375 --    D(11) := D(11) + T ;
06376 --                          COMMENT penalty for giving up fix on opponent hole ;
06377 --    IF (BRD(M22) = OPAWN) AND (M4 = BISHOP OR M4 = QUEEN)
06378 --    THEN FOR J := -1, 1
06379 --         DO IF BRD(M22+K_FILE+J) = OPAWN AND BRD(M33+J) = EMPTY
06380 --            THEN IF NEW_DIR ~= ABS(M22+J-BASE)
06381 --                 THEN IF SEC(0,M22+J)*K = 0
06382 --                      THEN D(4) := D(4) - 2 ;
06383 --                          COMMENT   moving piece ;
06384 --    I := ABS(CON(K,SQ_K)) ;
06385 --    IF (I = 0)
06386 --    THEN GIVINGCH := FALSE
06387 4-    ELSE BEGIN
06388 --      GIVINGCH := TRUE ;
06389 --                             COMMENT do not count hidden pieces ;
06390 --      DOUBLECH := IF (I = 2)
06391 --                  THEN TRUE
06392 --                  ELSE FALSE ;
06393 --      II := IF (I = 1) AND (M3 ~= CONTROL(SQ_K,K))
06394 --            THEN 3
06395 --            ELSE IF DOUBLECH
06396 --                 THEN 4
06397 --                 ELSE I + 1 ;
06398 --                             COMMENT  castling with check yields dis. ch. ;
06399 --      IF M14 ~= 0
06400 --      THEN M1 := M1 + PROMOTE ;
06401 --      REWARD(N) := M1 + (II)*CHECKING ;
06402 --                                   COMMENT dis. or dbl. check ;
06403 -4    END ;
06404 --                             COMMENT penalize tempo wasting moves in opening ;
06405 --                             COMMENT discourage successive moves with same piece ;
06406 --    IF M14 ~= 0
06407 --    THEN IF DEFN < 0 AND ~HIDDEN(M3, CONTROL(M3,-K), SQ3, K, FALSE)
06408 --         THEN C(6) := -20
06409 --         ELSE D(12) := IF ATTA = 0 AND LENGTH > LEVEL
06410 --                       THEN LENGTH - LEVEL + 1
06411 --                       ELSE 2 ;
06412 --    FOR I := 0 UNTIL 12
06413 --    DO DEBITS := DEBITS + D(I) ;
06414 --    IF FINAL
06415 --    THEN DEBIT(LEVEL-1) := DEBIT(LEVEL-1) + DEBITS
06416 --                            + C(7) DIV 2 - NODEBIT ;
06417 --    IF CLEARPAWN(-K) ~= SQ_K AND M3 ~= CLEARPAWN(-K)
06418 --    THEN OPPON_PP ;
06419 --    IF PASS_PAWN ~= KSQ
06420 --    THEN COMPU_PP ;
06421 --    DEBITS := DEBITS + D(13) + D(14) + D(15) ;
06422 --    PP_STATUS := D(15) + D(2) ;
06423 --    FOR I := 0 UNTIL 15
06424 --    DO CREDITS := CREDITS + C(I) ;
06425 --    IF DEBUG
06426 4-    THEN BEGIN
06427 --      I_W := 1 ;
06428 --      WRITE(N, "CRDB ", CREDITS, DEBITS, CREDIT(LEVEL)) ;
06429 --      FOR I := 0 UNTIL 15
06430 --      DO WRITEON(C(I), D(I)) ;
06431 --      WRITEON(PASS_PAWN, KSQ, SQ_K, CLEARPAWN(-K), PP_STATUS, NODEBIT) ;
06432 --      I_W := 5 ;
06433 -4    END ;
06434 --    CREDITS := CREDITS + GOODCASTLE + DEBITS ;
06435 --            COMMENT IF LEVEL > 2 AND CREDITS > LEVEL
06436 --                    THEN CREDITS := CREDITS - LEVEL DIV 2 ;
06437 --    CREDIT(LEVEL) := CREDIT(LEVEL) + CREDITS
06438 --                      -(IF FINAL
06439 --                        THEN D(13) + D(14) + D(15) + C(15) + C(14)
06440 --                        ELSE 0) ;
06441 --                          COMMENT   moving piece ;
06442 --    REVERSIBLE := IF (M7 ~= 0) OR (M4 = PAWN) OR CASTLING
06443 --                  THEN FALSE
06444 --                  ELSE TRUE ;
06445 --                          COMMENT castling is also non-reversible ;
06446 --    IF (FINAL)
06447 --    THEN MAKEFINAL ;
06448 --    IF INCHECK
06449 --    THEN CHECK_SQRS(K) ;
06450 --    INFLUENCE(FINAL) ;
06451 -3  END OF_MAKEMOVE ;
06452 --  
06453 --  PROCEDURE GAMETREE (INTEGER VALUE ROOT, LEVEL, WIDTH) ;
06454 3-  BEGIN
06455 --    INTEGER NODE, LIMIT ;
06456 --  
06457 --    IF ROOT <= 0
06458 --    THEN WRITE("END-OF-LINE: bad pointer", ROOT)
06459 4-    ELSE BEGIN
06460 --      LIMIT := NODETO(ROOT,0) ;
06461 --      IF LIMIT > WIDTH
06462 --      THEN LIMIT := WIDTH ;
06463 --      IF LIMIT <= 0 OR LEVEL > 2
06464 --      THEN LIMIT := 1 ;
06465 --      FOR J := 1 UNTIL LIMIT
06466 5-      DO BEGIN
06467 --        RESTORESTATE(ROOT) ;
06468 --        PRINTLINE (TRY(J), LEVEL) ;
06469 --        NODE := NODETO(ROOT,J) ;
06470 --        WRITEON(ROOT, NODETO(ROOT,0)) ;
06471 --        IF (NODE >= 1) AND (NODE <= MAXTREE)
06472 6-        THEN BEGIN
06473 --          IF (ROOT ~= PARENT(NODE) REM packer)
06474 --             AND PARENT(NODE) <= PARENT(ROOT)
06475 --          THEN WRITEON("DUPLICATE", ROOT, PARENT(ROOT)) ;
06476 --          WRITEON(NODE, PARENT(NODE), NODETO(NODE,0)) ;
06477 --          if ROOT ~= NODE
06478 --          then
06479 --            GAMETREE(NODE, LEVEL+1, WIDTH)
06480 --          else write("Infinite loop avoided ", ROOT, "=", NODE, "or ",
06481 --                       PARENT(NODE), "~=", packer*LEVEL+ROOT) ;
06482 --          RESTORESTATE(ROOT) ;
06483 -6        END ;
06484 -5      END ;
06485 -4    END ;
06486 -3  END OF_GAMETREE ;
06487 --  
06488 --  COMMENT ************mobilityscore************ ;
06489 --  
06490 --  PROCEDURE MOBILITYSCORE (INTEGER RESULT BEST) ;
06491 --  COMMENT scores on mobility and defence.
06492 --          This whole chess program is poorly organized and inefficient.
06493 --          a complete re-writing is probably better than continued
06494 --          evolution.
06495 --          Too much reliance has been placed on global variables,
06496 --          in the interests of reduced parameter passing ;
06497 3-  BEGIN
06498 --    INTEGER ARRAY EPLIST(0::ELIMIT) ;
06499 --    INTEGER MV, SAMV, JJ, SQ, SVMV, REWARDN, PC, JN, I, II, GAINS,
06500 --            EPGAIN, EP, LAST_SQ, NEXTSQ, KINGSQU, CAPT, EPL, SPAR4, SPAR5,
06501 --            EPSQ, SQA, SAVEB, KINGATTACKER, SQJJ, TMP, J, ATTACKSCORE,
06502 --            DEFENCESCORE, N, KSQ, ENPR, MF, NN, MATER, K_FILE, K_PAWN,
06503 --            SSQA, PLACESCORE, SPARE3, IP, SPARE1, SPARE2 ;
06504 --    LOGICAL SACRIFICING, PIN, DISC_ATTA, LEGALMV, STOP, MADELEGAL,
06505 --            TRAPPED, KINGMOVING, FORCING, EXCHANGE, CAPT_CH, DUMMY2 ;
06506 --  
06507 --    PROCEDURE CHECKER ;
06508 4-    BEGIN
06509 --      INTEGER SQ, PC, SQA, I, SAVE_D, LOST_PC, VAL_ATTA, ATTA, DEFN ;
06510 --                               COMMENT does it mate? ;
06511 --      MATE := TRUE ;
06512 --      SQA := KINGATTACKER ;
06513 --      VAL_ATTA := VALUES(ABS(BRD(SQA))) ;
06514 --      IF DOUBLECH
06515 --      THEN GO TO DONE ;
06516 --                               COMMENT protect against rare mate by enpassant pawn ;
06517 --      IF (REWARDN = PFTWO)
06518 --      THEN IF (BRD(SQA-K_FILE) = ENPRIS*K)
06519 --           THEN SQA := SQA - K_FILE ;
06520 --      SAVE_D := BOTV(EDGE, OFFSET(SQA)-OFFSET(KSQ)) ;
06521 --      IF SAVE_D = 0
06522 --      THEN SAVE_D := KSQ - SQA ;
06523 --      ATTA := I := CON(-K,SQA) ;
06524 --      LOST_PC := KINGVAL ;
06525 --      WHILE (SQA ~= KSQ) AND MATE
06526 5-      DO BEGIN
06527 --                       COMMENT  is the defending or interposing piece pinned? ;
06528 --        DEFN := CON(K,SQA) ;
06529 --        WHILE MATE AND (I ~= 0)
06530 6-        DO BEGIN
06531 --                       COMMENT try each blocker for SQ to SQA ;
06532 --          SQ := CONTROL(SQA,I) ;
06533 --          PC := -K*BRD(SQ) ;
06534 --          IF PC > 0 THEN
06535 --          IF SQA = KINGATTACKER
06536 --          THEN MATE := FALSE
06537 --          ELSE IF PC < KING AND PC > PAWN
06538 --               THEN IF ABS(ATTA) - 1 > ABS(DEFN)
06539 --                    THEN MATE := FALSE
06540 --                    ELSE IF ABS(ATTA) = 2
06541 --                    THEN MATE := HIDDEN(KSQ, SQA, TMP, K, FALSE)
06542 --                    ELSE IF PC > KNIGHT
06543 --                         THEN MATE := FALSE ;
06544 --          IF ~ MATE
06545 --          THEN IF (KSQ = SQ) AND (DEFN ~= 0)
06546 --               THEN MATE := TRUE
06547 --               ELSE IF SQA ~= KINGATTACKER
06548 7-                    THEN BEGIN
06549 --                      PC := VALUES(PC) ;
06550 --                      IF ABS(ATTA) ~= 1
06551 --                      THEN PC := PC - VAL_ATTA ;
06552 --                      IF PC < LOST_PC
06553 --                      THEN LOST_PC := PC ;
06554 --                      MATE := TRUE ;
06555 --                                 COMMENT probable mate ;
06556 -7          END ;
06557 --          IF DEBUG
06558 --          THEN WRITE("MAT", MATE, LOST_PC, PC, I, KSQ, SQ, SQA, BRD(SQ),
06559 --                      TMP, BRD(TMP), SAVE_D, K) ;
06560 --          I := I + K ;
06561 -6        END ;
06562 --                       COMMENT is there an interposing pawn move? ;
06563 --        SQA := SQA + SAVE_D ;
06564 6-        if SQA ~= KSQ then begin
06565 --          I := CON(-K,SQA) ;
06566 --          PC := BRD(SQA + K_FILE) ;
06567 --          IF (PC = -K_PAWN) OR ( (PC = NIL) and (SQA >= 41 and SQA <= 58)
06568 --              AND (BRD(SQA + 2*K_FILE) = -K_PAWN) )
06569 7-          THEN BEGIN
06570 --            I := I - K ;
06571 --                          COMMENT note con(k,sqa) is not changed ;
06572 --            CONTROL(SQA,I) := SQA + K_FILE*(IF (PC = NIL)
06573 --                                            THEN 2
06574 --                                            ELSE 1) ;
06575 --            MATE := false ;
06576 -7          END ;
06577 -6        end;
06578 -5      END ;
06579 --      IF MATE AND LOST_PC < KINGVAL
06580 5-      THEN BEGIN
06581 --        MATE := FALSE ;
06582 --        IF LOST_PC > 0
06583 6-        THEN BEGIN
06584 --          GAINS := GAINS + LOST_PC ;
06585 --          BACKROW := BACKROW + (IF GAINS < -REALVAL
06586 --                                THEN -(REALVAL + GAINS) + DELTA
06587 --                                ELSE 4) ;
06588 -6        END ;
06589 -5      END ;
06590 --  DONE:
06591 --      IF DEBUG
06592 --      THEN WRITE("MATE =", MATE, KSQ, KINGATTACKER, SQA, LOST_PC, GAINS) ;
06593 --      IF MATE
06594 --      THEN REWARD(N) := REWARDN + 5*CHECKING ;
06595 -4    END OF_CHECKER ;
06596 --  
06597 --    PROCEDURE COLLECTDATA ;
06598 4-    BEGIN
06599 --      INTEGER T ;
06600 --  
06601 --      JN := 4*(2*N - K) ;
06602 --      STORE(JN) := EPGAIN ;
06603 --      STORE(JN+1) := SAMV ;
06604 --      STORE(JN+2) := SVMV ;
06605 --      STORE(JN+3) := MV ;
06606 --      STORE(JN+4) := GAINS + CREDIT(LEVEL) + BACKROW ;
06607 --      STORE(JN+5) := ENPR ;
06608 --      STORE(JN+6) := ATTACKSCORE ;
06609 --      STORE(JN+7) := IF ~EARLY
06610 --                     THEN DEFENCESCORE
06611 --                     ELSE PLACESCORE ;
06612 --      IF DEBUG
06613 5-      THEN BEGIN
06614 --        WRITE("COL", N, OCON, CCON, ONUM, CNUM, "#") ;
06615 --        FOR JJ := 1 UNTIL EPLIST(0)
06616 --        DO WRITEON(SQUARE(EPLIST(JJ))) ;
06617 --        WRITEON("#", EPSQ, "#") ;
06618 --        FOR JJ := EPLIST(ELIMIT) UNTIL ELIMIT-1
06619 --        DO WRITEON(SQUARE(EPLIST(JJ))) ;
06620 -5      END ;
06621 --      T := IF (EPGAIN < 0) AND (EPGAIN > -PVAL)
06622 --           THEN 0
06623 --           ELSE EPGAIN ;
06624 --      TMP := IF GIVINGCH
06625 --             THEN T
06626 --             ELSE 0 ;
06627 --      IF GIVINGCH
06628 --      THEN T := 0 ;
06629 --      IF TEST AND EXAMINE
06630 --      THEN WRITE(N, OCON, CCON, ONUM, CNUM, ONEVAL, GOODCASTLE, ATTACKSCORE,
06631 --                 DEFENCESCORE, EP, GAINS, SAMV, ENPR, T, TMP, SVMV, MV+SAMV) ;
06632 -4    END OF_COLLECTDATA ;
06633 --  
06634 --    PROCEDURE ENPRISLIST ;
06635 4-    BEGIN
06636 --      INTEGER ARRAY OLDLOSS(0::ELIMIT) ;
06637 --      INTEGER T, TOP, SQ3, SQH, PCH, J ;
06638 --  
06639 --      TOP := LOSS(0) ;
06640 --      EPL := 1 ;
06641 --      EPLIST(1) := TOP ;
06642 --      T := LOSS(ELIMIT) ;
06643 --      IF PC >= BISHOP AND PC <= QUEEN
06644 --      THEN FOR I := POSITION(SQ,LIM) UNTIL LIM-1
06645 5-           DO BEGIN
06646 --                               COMMENT hidden attack on otherwise safe piece? ;
06647 --             SQH := POSITION(SQ,I) ;
06648 --             PCH := ABS(BRD(SQH)) ;
06649 --             IF PCH ~= QUEEN AND PCH ~= PC
06650 --             THEN SQ3 := HOLE
06651 --             ELSE IF HIDDEN(SQ, SQH, SQ3, 0, FALSE)
06652 --                  THEN ;  comment hidden sets SQ3 ;
06653 --             IF SQ3 ~= HOLE AND K*BRD(SQ3) < 0
06654 6-             THEN BEGIN
06655 --               T := T - 1 ;
06656 --               SQUARE(T) := SQ3 ;
06657 -6             END ;
06658 -5      END ;
06659 --      FOR JJ := 1 UNTIL TOP
06660 5-      DO BEGIN
06661 --        OLDLOSS(JJ) := LOSS(JJ) ;
06662 --                            COMMENT order of FOR loop is important ;
06663 --        SQJJ := SQUARE(JJ) ;
06664 --        IF SQJJ < WQRSQ OR SQJJ > BKRSQ or BRD(SQJJ) = EDGE
06665 --        THEN WRITE("enprisLIST error", SQUARE(0), LOSS(0), I, TOP, SQJJ)
06666 --        ELSE IF (BRD(SQJJ) ~= EMPTY)
06667 6-             THEN BEGIN
06668 --               IF ~SACRIFICE(SQJJ, DEBUG)
06669 --               THEN IF (LOSSES < -SEVENS) AND (SQJJ ~= KINGATTACKER)
06670 --                    THEN GO TO NEXTJJ ;
06671 --                               COMMENT piece unlikely to be captured ;
06672 --               EP := LOSSES ;
06673 -6             END ELSE
06674 --                 IF GIVINGCH OR CON(-K,SQJJ) = 0
06675 --                 THEN GO TO NEXTJJ
06676 6-                 ELSE BEGIN
06677 --                   EP := LOSS(JJ) - VALUES(ABS(BRD(SQ))) ;
06678 --                   IF DEBUG
06679 --                   THEN WRITE("EMPTY", SQJJ, EP, LOSS(JJ)) ;
06680 --                               COMMENT may be better to defend forked piece ;
06681 --                   IF (EP < PVAL) OR (ABS(BRD(SQ)) ~= PAWN) OR SQJJ = CLEARPAWN(K)
06682 --                   THEN GO TO NEXTJJ ;
06683 --                   ATTASQRS(0) := 0 ;
06684 -6                 END ;
06685 --        FOR I := 1 UNTIL ATTASQRS(0)
06686 6-        DO BEGIN
06687 --          FOR J := T UNTIL ELIMIT-1
06688 --          DO IF SQUARE(J) = ATTASQRS(I)
06689 --             THEN GOTO NEXTI ;
06690 --          T := T - 1 ;
06691 --          SQUARE(T) := ATTASQRS(I) ;
06692 --                            COMMENT consider all counter attacks ;
06693 --  NEXTI:
06694 -6        END ;
06695 --        I := 0 ;
06696 --        WHILE (I < EPL)
06697 6-        DO BEGIN
06698 --          I := I + 1 ;
06699 --          IF (EP >= LOSS(EPLIST(I)))
06700 7-          THEN BEGIN
06701 --            FOR J := EPL STEP -1 UNTIL I
06702 --            DO EPLIST(J+1) := EPLIST(J) ;
06703 --            EPLIST(I) := JJ ;
06704 --            LOSS(JJ) := EP ;
06705 --            I := EPL ; comment to force loop exit ;
06706 -7          END ;
06707 -6        END ;
06708 --        EPL := EPL + 1 ;
06709 --  NEXTJJ:
06710 -5      END ;
06711 --      EPLIST(0) := EPL := EPL - 1 ;
06712 --      TOP := LOSS(0) ;
06713 --          comment only requirement is T > TOP.  Here finding smallest difference ;
06714 --      IF T - TOP < 4
06715 5-      THEN BEGIN
06716 --        WRITE("ENPRIS LIST ERROR", BASE, SQ, T, TOP, LOSS(ELIMIT)) ;
06717 --        FOR J := 0 UNTIL ELIMIT
06718 --        DO WRITEON(SQUARE(J)) ;
06719 --        PUNCHBRD(TRUE, HISTORY) ;
06720 --        WRITE(HISTORY(0|114)) ;
06721 --        TRACER(2, "?P9") ;
06722 -5      END ;
06723 --      LOSS(ELIMIT) := T ;
06724 --      IF (EPL = 0)
06725 --      THEN EPL := 1 ;
06726 --      ENPR := LOSS(EPLIST(1)) ;
06727 --      EPLIST(ELIMIT) := ELIMIT ;
06728 --      EPSQ := SQUARE(EPLIST(1)) ;
06729 --      EPGAIN := IF FALSE AND INCHECK AND (EPLIST(0) = 0)
06730 --                THEN 0
06731 --                ELSE EP_SCORE(EPSQ, ENPR) ;
06732 --      SACRIFICING := IF (ENPR > 0)
06733 --                     THEN TRUE
06734 --                     ELSE FALSE ;
06735 --      IF (ENPR <= -PVAL)
06736 --      THEN ENPR := 0 ;
06737 --      IF (EPGAIN >= ENPR)
06738 --      THEN SACRIFICING := FALSE ;
06739 --      FOR JJ := 1 UNTIL TOP
06740 --      DO LOSS(JJ) := OLDLOSS(JJ) ;
06741 -4    END OF_ENPRISLIST ;
06742 --  
06743 --    PROCEDURE PARTIAL_ORDER ;
06744 4-    BEGIN
06745 --      INTEGER R, II, RR, LL, TMP, PC ;
06746 --  
06747 --      LL := 0 ;
06748 --      RR := TOTAL + 1 ;
06749 --      FOR N := K STEP K UNTIL NUMBER(K)
06750 5-      DO BEGIN
06751 --        R := REWARD(N) ;
06752 --        IF R ~= 0 AND ABS(R) ~= PFTWO
06753 --        THEN II := RR := RR - 1
06754 6-        ELSE BEGIN
06755 --          PC := ABS(BRD(MOVEFROM(N))) ;
06756 --          TMP := K*CHECK_S(K,MOVETO(N)) ;
06757 --          IF TMP > 0 AND CHEC(TMP, PC)
06758 --          THEN II := RR := RR - 1
06759 --          ELSE II := LL := LL + 1 ;
06760 -6        END ;
06761 --        USE(II) := N ;
06762 -5      END ;
06763 --      LL := LL + 1 ;
06764 --      FOR I := RR UNTIL TOTAL
06765 --      DO USE(LL+I-RR) := USE(I) ;
06766 --      USE(0) := 0 ;
06767 -4    END OF_PARTIAL_ORDER ;
06768 --  
06769 --    LOGICAL PROCEDURE KINGDEFENDER (INTEGER VALUE SQ ; INTEGER VALUE RESULT EPS) ;
06770 4-    BEGIN
06771 --      INTEGER SQ1, SQ3 ;
06772 --      LOGICAL TRAPPED ;
06773 --  
06774 --      TRAPPED := FALSE ;
06775 --      FOR I := POSITION(SQ,LIM) UNTIL LIM - 1
06776 --      DO IF ~TRAPPED
06777 5-         THEN BEGIN
06778 --                             COMMENT does any piece rely on this defender? ;
06779 --           SQ1 := POSITION(SQ,I) ;
06780 --           IF CON(0,SQ1) = 0 AND BRD(SQ)*BRD(SQ1) > 0
06781 6-           THEN BEGIN
06782 --             TRAPPED := TRUE ;
06783 --             FOR J := 1 UNTIL POS(SQ)
06784 --             DO IF TRAPPED
06785 7-                THEN BEGIN
06786 --                  SQ3 := POSITION(SQ,J) ;
06787 --                  IF ABS(BOTV(KING, OFFSET(SQ1) -OFFSET(SQ3))) = 1
06788 --                  THEN TRAPPED := FALSE ;
06789 -7             END ;
06790 --             IF TRAPPED
06791 --             THEN EPS := VALUES(ABS(BRD(SQ1))) ;
06792 -6           END ;
06793 --           IF DEBUG
06794 --           THEN WRITE("KINGDEF", SQ, SQ1, I, EPS, SQ3, TRAPPED) ;
06795 -5      END ;
06796 --      TRAPPED
06797 -4    END OF_KINGDEFENDER ;
06798 --  
06799 --  COMMENT ***********ep_score****************** ;
06800 --  
06801 --  INTEGER PROCEDURE EP_SCORE (INTEGER VALUE RESULT EPSQR, ENPR) ;
06802 --  COMMENT find the second largest piece (largest if sacrificing) ;
06803 4-  BEGIN
06804 --    INTEGER I, II, J, SQA, SCR, EPSCORE, VALSQT, VALSQA, TOP, PCA,
06805 --            COST, EP, SQ, SAVE_D, KSQ, SQTDEF, MINDEF, TEMP, TT, SQAA,
06806 --            SQ1, PC1, SQ3, PC3, VALSQ3, ATTA, PC, STAT_SQ3, ENPSEC, SC, ENP,
06807 --            LOST, SQT, SQD, SQJ, DECOY, SQSAVE, NA, ND, NEW, OLD, PCAA,
06808 --            PPCA, KK, L, SQS, SMALL_ATTA, SQT_ATT, MAX_CAPT, TMP, PCASAVE,
06809 --            SQA_ATT, PCT, LOSERS, FIRST, SECOND, THIRD, OFF3, SQI, PCI,
06810 --            G1, G2, G3, LOSS3, SEC_EP, EPSQ2 ;
06811 --    COMMENT INTEGER ARRAY ASQRS(ELIMIT-10::ELIMIT) ;
06812 --    INTEGER ARRAY ASQRS(0::ELIMIT) ;
06813 --    LOGICAL T, KINGATTA, DUMMY1, NORMAL, CAPTURE, SQT_CAPT, RELEVANT,
06814 --            SPECIAL, CHK, SQA_CAPT, CH_CAPT, ADD, E1, E2, E3, E4, E5 ;
06815 --    INTEGER ARRAY SQAXSQT(16::ELIMIT-1, 1::15) ;
06816 --    INTEGER ARRAY SQTXSQA(1::15, 16::ELIMIT-1) ;
06817 --    LOGICAL PIN, VALID, FRESH, EXTRALOSS, SACR_CAPT, SAFE, PASS1,
06818 --            DEFEND, V_A, S_A, RECAPT_CH ;
06819 --    INTEGER ARRAY HOLD(-16::16) ;
06820 --    INTEGER SMALL_DEF, MAJOR, OFFSSQA ;
06821 --  
06822 --    PROCEDURE DEFENCE ;
06823 5-    BEGIN
06824 --      COMMENT seek pawn defence ;
06825 --      I := SSQA + FILES(K) ;
06826 --      TMP := KK*PAWN ;
06827 --      IF ~ GIVINGCH
06828 --      THEN FOR L := I+1, I-1
06829 --      DO IF TRAPPED
06830 6-         THEN BEGIN
06831 --           J := L ;
06832 --           WHILE BRD(J) = 0
06833 --           DO J := J + FILES(K) ;
06834 --           IF BRD(J) =TMP AND (ABS(J-L) = 10 OR ABS(J-L) = 20
06835 --               AND PAWNS(J) = K AND BRD(L+1) ~= -TMP AND BRD(L-1) ~= -TMP)
06836 7-           THEN BEGIN
06837 --             TRAPPED := FALSE ;
06838 --             IF DEBUG
06839 --             THEN WRITEON("PAWN", J) ;
06840 --             EPSCORE := IF ENPR < LOST
06841 --                        THEN LOST
06842 --                        ELSE IF EPSCORE > ENPR
06843 --                             THEN ENPR
06844 --                             ELSE EPSCORE ;
06845 -7           END ;
06846 -6      END ;
06847 --      L := K*SEC(0,SSQA) ;
06848 --      SQI := IF CON(-K,SSQA) = 0
06849 --             THEN HOLE
06850 --             ELSE CONTROL(SSQA,-K) ;
06851 --      OFFSSQA := OFFSET(SSQA) ;
06852 --      RELEVANT := ~GIVINGCH OR BOTV(KING,OFFSSQA-OFFSET(KSQ)) = 2 ;
06853 --      IF TRAPPED AND RELEVANT THEN
06854 --      IF L <= 1 THEN
06855 --      FOR I := 1, -1, 10, -10, 9, -9, 11, -11
06856 6-      DO BEGIN
06857 --                              COMMENT seek Q, R, B, or K defence ;
06858 --         SQ := SSQA + I ;
06859 --         WHILE TRAPPED AND BRD(SQ) = 0
06860 --             OR SQI ~= 0 AND BRD(SQ) ~= EDGE AND K*BRD(SQ) < 0
06861 --             AND BOTV(ABS(BRD(SQ)), OFFSET(SQ)-OFFSSQA) = 1
06862 7-         DO BEGIN
06863 --           IF K*CON(K, SQ) <= 0 AND BRD(SQ) = 0
06864 --           THEN FOR J := CON(-K,SQ) STEP K UNTIL -K
06865 8-                DO BEGIN
06866 --                  SQ3 := CONTROL(SQ,J) ;
06867 --                  PC3 := ABS(BRD(SQ3)) ;
06868 --                  IF DEBUG THEN WRITE("DEF", SSQA, SQ, SQ3, PC3) ;
06869 --                  OFF3 := OFFSET(SQ3) - OFFSSQA ;
06870 --                  TMP := OFFSET(SQ) - OFFSSQA ;
06871 --                  IF SQ3 ~= SQI AND SSQA ~= SQ3 AND (PC3 >= BISHOP
06872 --                       AND PC3 <= QUEEN AND BOTV(EDGE,OFF3) ~= BOTV(EDGE,TMP)
06873 --                       AND ~GIVINGCH OR PC3 = KING AND SQ = SSQA + I
06874 --                       AND BOTV(KING,OFF3) = 2) AND (PASS1 OR MAJOR = SQ3)
06875 9-                  THEN BEGIN
06876 --                    PC := IF (PC3 = ROOK OR PC3 = BISHOP)
06877 --                          THEN BOTV(PC3, TMP)
06878 --                          ELSE 0 ;
06879 --                    IF DEBUG THEN WRITEON(PC, L, SMALL_ATTA, SQI) ;
06880 --                    IF PC3 = QUEEN OR PC = 1 OR PC3 = KING
06881 --                    THEN IF L = 1 OR VALUES(PC3) < VALUES(SMALL_ATTA) + DELTA
06882 --                         THEN IF PC3 < QUEEN OR SQI = HOLE
06883 --                                  OR ABS(BRD(SQI)) < QUEEN
06884 --                                        COMMENT avoid having both King
06885 --                                                and Queen as defenders ;
06886 10-                   THEN BEGIN
06887 --                      IF DEBUG
06888 --                      THEN WRITE("DEFN", SSQA, SQ, SQ3, PC3, SQI, PC, ENPR, LOST) ;
06889 --                      TRAPPED := FALSE ;
06890 --                              COMMENT ensure this is not a decoy situation in which
06891 --                                      the piece on SQ3 is the sole defender of
06892 --                                      one that it cannot defend from SQ ;
06893 --                      FOR I := POSITION(SQ3,LIM) UNTIL LIM-1
06894 11-                     DO BEGIN
06895 --                               COMMENT is potential defender committed elsewhere ;
06896 --                        SQ1 := POSITION(SQ3,I) ;
06897 --                        IF BRD(SQ1) ~= 0 AND K*SEC(0,SQ1) >= 0
06898 --                        THEN IF BOTV(PC3, OFFSET(SQ)-OFFSET(SQ1)) ~= 1
06899 --                             THEN TRAPPED := TRUE ;
06900 -11                     END ;
06901 --                      IF ~TRAPPED
06902 --                      THEN EPSCORE := IF PASS1 AND ENPR < LOST
06903 --                                      THEN LOST
06904 --                                      ELSE IF EPSCORE > ENPR
06905 --                                           THEN ENPR
06906 --                                           ELSE EPSCORE ;
06907 --                      IF ~TRAPPED
06908 --                      THEN GOTO OK ;
06909 -10                   END ELSE
06910 10-                   BEGIN
06911 --                      IF PASS1
06912 --                      THEN EPSCORE := EPSCORE DIV 2 ;
06913 --                      DEFEND := TRUE ;
06914 --                      GOTO OK ;
06915 -10                   END ;
06916 -9                  END ;
06917 -8                END ;
06918 --                SQ := SQ + I ;
06919 -7        END ;
06920 -6      END ;
06921 --  OK:
06922 --      IF DEBUG
06923 --      THEN WRITEON(TRAPPED, EPSCORE, SQI, L) ;
06924 --                    COMMENT seek knight defence ;
06925 --      PC3 := KK*KNIGHT ;
06926 --      T := PC3 ~= BRD(SSQA) ;
06927 --      IF TRAPPED AND ~GIVINGCH
06928 --      THEN IF L <= 1 AND PIECES(PC3) ~= 0
06929 --           THEN FOR I := 1 UNTIL 8
06930 6-                DO BEGIN
06931 --                  SQ3 := SSQA + S(I) ;
06932 --                  IF BRD(SQ3) = 0 AND CON(K,SQ3) = 0 AND CON(-K,SQ3) ~= 0
06933 --                  THEN FOR J := 1 UNTIL 8
06934 --                       DO IF T OR SQ3 + S(J) ~= SSQA
06935 --                          THEN IF BRD(SQ3+S(J)) = PC3
06936 7-                               THEN BEGIN
06937 --                                        COMMENT  Knight must not defend itself ;
06938 --                                 TRAPPED := FALSE ;
06939 --                                 IF DEBUG
06940 --                                 THEN WRITEON("KNIGHT", SQ3) ;
06941 --                                 EPSCORE := IF ENPR < LOST
06942 --                                            THEN LOST
06943 --                                            ELSE IF EPSCORE > ENPR
06944 --                                                 THEN ENPR
06945 --                                                 ELSE EPSCORE ;
06946 -7                               END ;
06947 -6                END ;
06948 -5    END OF_DEFENCE ;
06949 --  
06950 --    PROCEDURE PINTRAP ;
06951 5-    BEGIN
06952 --      IF DEBUG
06953 --      THEN WRITE("EPSR", SCR, EPSCORE) ;
06954 --      PIN := FALSE ;
06955 --      PASS1 := SCR > EPSCORE -DELTA ;
06956 --      LOST := EPSCORE ;
06957 --    LOOP:
06958 --      IF ~PASS1 AND EPSQR ~= HOLE AND SSQA ~= HOLE AND SCR > -DELTA
06959 --        AND (CON(-K,SSQA) = 0
06960 --        OR VALUES(ABS(BRD(EPSQR))) < VALUES(ABS(BRD(SSQA))) + DELTA)
06961 --      THEN FOR I := CON(K,SSQA) STEP -K UNTIL K
06962 --           DO IF CONTROL(SSQA,I) = EPSQR
06963 --              THEN ENPR := 0 ;
06964 --      IF ~GIVINGCH OR (SSQA ~= KSQ)
06965 --      THEN IF GIVINGCH OR EPSCORE > SCR OR SCR > -ENPR AND ENPR > 0
06966 --              OR ~CAPTURE_CH(EPSQR) AND CAPTURE_CH(SSQA)
06967 6-           THEN BEGIN
06968 --             SCR := SCR + ENPR ;
06969 --             EPSCORE := SCR ;
06970 -6      END ;
06971 --      IF DEBUG
06972 --      THEN WRITEON(SSQA, SCR, EPSCORE, EPSQR, ENPR) ;
06973 --      IF EPSQR = HOLE AND CON(K,SSQA) = 0
06974 6-      THEN BEGIN
06975 --        TRAPPED := TRUE ;
06976 --        EPSCORE := SCR ;
06977 --        IF DEBUG
06978 --        THEN WRITEON("EH", K, SSQA) ;
06979 -6      END ELSE IF SCR > -DELTA OR EPSCORE > 0
06980 6-               THEN BEGIN
06981 --                 TRAPPED := IF (SSQA ~= KSQ) AND (SCR > 0 OR POS(SSQA) > 0
06982 --                                AND SCR > -DELTA)
06983 --                            THEN TRUE
06984 --                            ELSE FALSE ;
06985 --                 PC := ABS(BRD(SSQA)) ;
06986 --                 VALSQA := VALUES(PC) ;
06987 --                 MAX_CAPT := 0 ;
06988 --                 FOR I := 1 UNTIL POS(SSQA)
06989 --                 DO IF TRAPPED
06990 7-                    THEN BEGIN
06991 --                      SQ := POSITION(SSQA,I) ;
06992 --                      VALSQ3 := VALUES(ABS(BRD(SQ))) ;
06993 --                      IF MAX_CAPT < VALSQ3
06994 --                      THEN MAX_CAPT := VALSQ3 ;
06995 --                      VALID := VALSQ3 < VALUES(PC) - DELTA ;
06996 --                      NA := CON(-KK,SQ) ;
06997 --                      ND := ABS(CON(KK,SQ))
06998 --                               - (IF PC = PAWN AND ABS(SQ-SSQA) REM FILE = 0
06999 --                                  THEN 0
07000 --                                  ELSE 1) ;
07001 --                            COMMENT can the piece on SSQA move to a square
07002 --                                    which is not attacked, or to a square which is
07003 --                                    defended but attacked by a "greater" piece? ;
07004 --                      TRAPPED := FALSE ;
07005 --                      IF VALID AND HIDDEN(SQ, SSQA, SQ3, -KK, FALSE)
07006 8-                      THEN BEGIN
07007 --                        NA := NA - KK ;
07008 --                        CONTROL(SQ, NA) := SQ3 ;
07009 -8                      END ;
07010 --                      IF VALID
07011 --                      THEN FOR L := NA STEP KK UNTIL -KK
07012 --                           DO IF VALUES(ABS(BRD(CONTROL(SQ,L)))) < VALUES(PC) -DELTA
07013 --                              THEN TRAPPED := TRUE ;
07014 --                      NA := ABS(NA) ;
07015 --                      IF VALID AND ~TRAPPED AND (NA >= ND)
07016 --                          AND (NA > ND + (IF HIDDEN(SQ, SSQA, SQ3, KK, FALSE)
07017 --                                           THEN 1
07018 --                                           ELSE 0))
07019 --                      THEN TRAPPED := TRUE ;
07020 --                                        COMMENT note pawn might not defend the
07021 --                                                move-to square ;
07022 --                      IF ~TRAPPED AND PC = PAWN AND PAWNS(SQ) = 0
07023 8-                      THEN BEGIN
07024 --                        EPSCORE := 0 ;
07025 --                        SQS := SSQA ;
07026 -8                      END ;
07027 --                                        COMMENT no epscore if opponent can promote ;
07028 -7                 END ;
07029 --                                        COMMENT if not trapped, guaranteed escape ;
07030 --                                        COMMENT does not check whether SSQA can
07031 --                                                simply be defended ;
07032 --                 IF TRAPPED
07033 --                 THEN IF (ABS(CON(-KK,SSQA)) = 1)
07034 --                          AND (CONTROL(SSQA, -KK) = EPSQR) AND (ENPR < -DELTA)
07035 --                      THEN TRAPPED := FALSE ;
07036 --                          COMMENT IF DEBUG AND TRAPPED
07037 --                                  THEN WRITE("TRAP", SSQA, SCR, EPSCORE, TRAPPED,
07038 --                                           KK, SQ, MAX_CAPT, CON(KK,SQ), NA, ND) ;
07039 --                          COMMENT MAX_CAPT is the largest piece SSQA can capture ;
07040 --                          COMMENT MAX_CAPT is the largest man PC can capture ;
07041 --                 IF TRAPPED AND VALSQA-SCR > -DELTA
07042 --                            AND VALSQA-SCR < MAX_CAPT
07043 --                 THEN SCR := VALSQA - MAX_CAPT ;
07044 --                 IF TRAPPED
07045 --                 THEN EPSCORE := SCR -(IF GIVINGCH OR LEVEL <= 2
07046 --                                       THEN 0
07047 --                                       ELSE IF LEVEL > 4
07048 --                                            THEN 2
07049 --                                            ELSE 1) ;
07050 --                 IF TRAPPED AND ~GIVINGCH
07051 --                 THEN EPSCORE := EPSCORE
07052 --                          + (IF EPSCORE <= PVAL + PAWNVAL(2) OR PC = PAWN
07053 --                              THEN 0
07054 --                              ELSE LOSERS - (IF ENPR > 0 OR CON(K,EPSQ) = 0
07055 --                                                OR EPSCORE < VALUES(ROOK)
07056 --                                             THEN 5
07057 --                                             ELSE 8)) ;
07058 --                             COMMENT determine if the "largest" piece under attack
07059 --                                     is pinned, hence change EPSCORE value ;
07060 --                 IF DEBUG
07061 --                 THEN WRITEON(EPSCORE, LOSERS) ;
07062 --                 SMALL_ATTA := KING ;
07063 --                 IF (SCR > DELTA OR EPSCORE > DELTA)
07064 --                 THEN HIDETRAP ;
07065 --                 IF GIVINGCH AND EPSCORE > 0 AND SSQA ~= KSQ
07066 --                      AND ~TRAPPED AND EPSQR >= WQRSQ and EPSQR <= BKRSQ
07067 7-                 THEN BEGIN
07068 --                   TRAPPED := TRUE ;
07069 --                   FOR I := CON(-K,EPSQR) STEP K UNTIL -K
07070 --                   DO IF EPSQR = KINGATTACKER AND SSQA = CONTROL(EPSQR,I)
07071 --                      THEN TRAPPED := FALSE ;
07072 -7                 END ;
07073 --                 DEFEND := FALSE ;
07074 --                             COMMENT is there a potential defence for a trapped piece ;
07075 --                 IF SSQA = KSQ
07076 --                 THEN TRAPPED := TRAPPED OR KINGDEFENDER(SSQA, EPSCORE)
07077 --                 ELSE IF ENPR <= EPSCORE AND TRAPPED
07078 --                         AND VALUES(SMALL_ATTA) > VALSQA - DELTA
07079 --                      THEN DEFENCE ;
07080 --                 L := K*SEC(0,SSQA) ;
07081 --                 IF ~GIVINGCH OR SSQA = KSQ
07082 7-                 THEN begin
07083 --                      IF TRAPPED AND L <= 1
07084 --                      THEN FOR J := CON(-KK,SSQA) STEP KK UNTIL -KK
07085 8-                      DO BEGIN
07086 --                                    COMMENT can attack path be blocked ;
07087 --                        SQ3 := CONTROL(SSQA,J) ;
07088 --                        DIR := BOTV(EDGE, OFFSET(SSQA)-OFFSET(SQ3)) ;
07089 --                        IF DIR ~= 0
07090 --                        THEN FOR I := SSQA+DIR STEP DIR UNTIL SQ3-DIR
07091 9-                             DO BEGIN
07092 --                               II := SEC(0,I)*KK ;
07093 --                               VALID := II >= 0 AND BRD(I-FILES(KK)) = KK*PAWN ;
07094 --                               IF II > 0 OR VALID
07095 --                               THEN IF VALID
07096 10-                              THEN BEGIN
07097 --                                  TRAPPED := FALSE ;
07098 --                                  IF DEBUG
07099 --                                  THEN WRITEON("P BLOCK", I, SQ3, EPSCORE, SSQA,
07100 --                                                KSQ, FILES(KK)) ;
07101 --                                  EPSCORE := IF ENPR < LOST
07102 --                                             THEN LOST
07103 --                                             ELSE IF EPSCORE > ENPR
07104 --                                                  THEN ENPR
07105 --                                                  ELSE EPSCORE ;
07106 -10                              END ELSE
07107 10-                              BEGIN
07108 --                                 COMMENT need concept of safe block ;
07109 --                                 IF ~PIN AND ~DEFEND
07110 --                                 THEN EPSCORE := EPSCORE DIV 2 ;
07111 -10                              END ;
07112 -9                        END ;
07113 -8                      end ;
07114 -7                 END ;
07115 -6      END ;
07116 --      IF (PASS1 OR ~GIVINGCH) AND SQS ~= SSQA AND ~TRAPPED
07117 --          AND LOST > -DELTA AND SQS >= WQRSQ AND SQS <= BKRSQ
07118 6-      THEN BEGIN
07119 --        IF DEBUG
07120 --        THEN WRITE("PASS", SCR, ENPR, SEC_EP, CAPTURE_CH(EPSQR),
07121 --                   CAPTURE_CH(EPSQ2), EPSQR, EPSQ2) ;
07122 --        IF ~CAPTURE_CH(EPSQR) AND ~CAPTURE_CH(EPSQ2)
07123 --            AND SCR > ENPR + DELTA AND SCR > SEC_EP + DELTA
07124 --        THEN ENPR := 0
07125 --        ELSE IF SEC_EP >= 0
07126 --             THEN ENPR := SEC_EP ;
07127 --        MAJOR := SSQA ;
07128 --        SSQA := SQS ;
07129 --        PASS1 := FALSE ;
07130 --        EPSQR := EPSQ2 ;
07131 --        SCR := EPSCORE := LOST ;
07132 --        GO TO LOOP ;
07133 -6      END ;
07134 --      IF PASS1 AND ~TRAPPED AND ~PIN AND ENPR < EPSCORE
07135 --      THEN EPSCORE := ENPR ;
07136 --      IF CAPT_CH AND ~TRAPPED
07137 --      THEN EPSCORE := -1 ;
07138 --      IF DEBUG THEN
07139 --         WRITE("ENPSEC ", EXTRALOSS, ENPR, CON(K,EPSQR), EPSQR, THIRD) ;
07140 --      ENPSEC := IF ~EXTRALOSS
07141 --                THEN 0
07142 --                ELSE IF ENPR > 0 AND (CON(K,EPSQR) = 0 OR LOST + ENPR < -DELTA)
07143 --                     THEN THIRD
07144 --                     ELSE IF EPSQR = SQUARE(EPLIST(1)) OR GIVINGCH
07145 --                          THEN SECOND
07146 --                          ELSE FIRST ;
07147 --      IF ENPSEC < 0
07148 --      THEN ENPSEC := 0 ;
07149 --      IF ENPSEC > 0 AND EPSQR >= WQRSQ and EPSQR <= BKRSQ
07150 6-      THEN BEGIN
07151 --                          COMMENT no secondary loss if piece involved in exchange ;
07152 --        SQ := IF ENPSEC = FIRST AND SQUARE(EPLIST(1)) ~= EPSQR
07153 --              THEN 1
07154 --              ELSE IF ENPSEC = SECOND AND SQUARE(EPLIST(2)) ~= EPSQR
07155 --                   THEN 2
07156 --                   ELSE 3 ;
07157 --        SQ := SQUARE(EPLIST(SQ)) ;
07158 --                            COMMENT  does EPSQR defend SQ ;
07159 --        FOR I := CON(K,EPSQR) STEP -K UNTIL K
07160 --        DO IF SQ = CONTROL(EPSQR,I)
07161 --           THEN ENPSEC := 0 ;
07162 --                            COMMENT does SSQA attack SQ ;
07163 --        IF EPSCORE > 0
07164 --        THEN FOR I := CON(-K,SQ) STEP K UNTIL -K
07165 --             DO IF ENPSEC > 0
07166 7-                THEN BEGIN
07167 --                  IF SSQA = CONTROL(SQ,I)
07168 --                  THEN ENPSEC := 0
07169 --                  ELSE FOR J := CON(-K, EPSQR) STEP K UNTIL -K
07170 --                  DO IF CONTROL(EPSQR,J) = CONTROL(SQ,I)
07171 --                     THEN ENPSEC := 0 ;
07172 -7                END ;
07173 -6      END ;
07174 --      IF GIVINGCH AND ENPSEC > PVAL
07175 --      THEN ENPSEC := ENPSEC DIV 2 ;
07176 -5    END OF_PINTRAP ;
07177 --  
07178 --    PROCEDURE HIDETRAP ;
07179 5-    BEGIN
07180 --      INTEGER SQTO ;
07181 --  
07182 --      FOR J := CON(-KK,SSQA) STEP KK UNTIL -KK
07183 --      DO IF ~PIN
07184 6-         THEN BEGIN
07185 --           ATTA := CONTROL(SSQA,J) ;
07186 --           PCA := ABS(BRD(ATTA)) ;
07187 --           IF SMALL_ATTA > PCA
07188 --           THEN SMALL_ATTA := PCA ;
07189 --           IF PCA >= BISHOP AND PCA <= QUEEN
07190 --           THEN T := HIDDEN(ATTA, SSQA, SQ3, -KK, FALSE)
07191 --           ELSE SQ3 := HOLE ;
07192 --           PC3 := KK*BRD(SQ3) ;
07193 --           IF (SQ3 ~= HOLE) AND (PC3 > 0)
07194 7-           THEN BEGIN
07195 --             VALSQ3 := VALUES(PC3) ;
07196 --             STAT_SQ3 := KK*SEC(0,SQ3) ;
07197 --             IF BISHOP <= PC AND PC <= QUEEN
07198 --                AND BOTV(PC, OFFSET(SSQA)-OFFSET(SQ3)) = 1
07199 --             THEN STAT_SQ3 := STAT_SQ3 - 1 ;
07200 --                        COMMENT cannot handle xray-double pins properly.
07201 --                                Also, not clear that inline pins handled correctly ;
07202 --             IF ((STAT_SQ3 <= 0) OR (PCA <= PC3)) AND (ENPR < DELTA
07203 --                 OR VALSQ3 > VALUES(ABS(BRD(EPSQR))) -DELTA)
07204 8-             THEN BEGIN
07205 --               IF (PC3 = KING)
07206 --               THEN PIN := TRUE ;
07207 --               IF DEBUG
07208 --               THEN WRITE("PIN", PIN, ATTA, KK, J, PCA, SSQA, SQ3, PC3, SCR,
07209 --                           EPSCORE, EPSQR, VALSQ3, ENPR, STAT_SQ3) ;
07210 --               IF ~PIN
07211 9-               THEN BEGIN
07212 --                                   COMMENT is SQ3 overdefended, and hence safe ;
07213 --                 IF STAT_SQ3 > 0
07214 --                 THEN VALSQ3 := VALSQ3 - VALUES(PCA) ;
07215 --                 IF VALSQ3 > VALSQA
07216 10-                THEN BEGIN
07217 --                   IF SACRIFICE(SSQA, DEBUG)
07218 --                   THEN VALSQ3 := LOSSES ;
07219 --                   TRAPPED := TRUE ;
07220 -10                END ;
07221 --                 IF SCR > VALSQ3
07222 --                 THEN SCR := VALSQ3 ;
07223 -9               END ;
07224 --                                     COMMENT  piece on SSQA not attack PCA ;
07225 --               IF (EPSCORE < SCR)
07226 --               THEN EPSCORE := SCR - (IF EPSQR = ATTA
07227 --                                      THEN ENPR
07228 --                                      ELSE 0) ;
07229 --               IF PIN OR EPSCORE > DELTA
07230 --               THEN TRAPPED := TRUE ;
07231 --                                  COMMENT can movement of SSQA defend SQ3 ;
07232 --               IF TRAPPED AND ~PIN
07233 --               THEN IF PC = KNIGHT AND KN_DEFENCE(SSQA, SQ3, K)
07234 --                       OR PC = QUEEN
07235 --                       OR PC > KNIGHT AND BOTV(PC, OFFSET(SSQA)-OFFSET(SQ3)) = 2
07236 9-                    THEN BEGIN
07237 --                      IF PC = KNIGHT THEN TRAPPED := FALSE
07238 --                      ELSE FOR I := 1 UNTIL POS(SSQA)
07239 10-                          DO IF TRAPPED THEN BEGIN
07240 --                                SQTO := POSITION(SSQA,I) ;
07241 --                                IF CON(K,SQTO) = 0
07242 --                                   AND BOTV(PC, OFFSET(SQTO)-OFFSET(SQ3)) = 1
07243 --                                   AND CLEAR(SSQA, SQTO, SQ3)
07244 --                                THEN TRAPPED := FALSE ;
07245 -10                          END ;
07246 --                      IF ~TRAPPED THEN
07247 --                      EPSCORE := IF ENPR < LOST
07248 --                                 THEN LOST
07249 --                                 ELSE IF EPSCORE > ENPR
07250 --                                      THEN ENPR
07251 --                                      ELSE EPSCORE ;
07252 -9               END ;
07253 --               IF DEBUG
07254 --               THEN WRITE("PPIN", TRAPPED, PIN, EPSCORE, VALSQ3, PC,
07255 --                          POS(SSQA)) ;
07256 --               IF TRAPPED AND ~PIN AND PC > PAWN
07257 --                          AND BOTV(PC, OFFSET(SSQA)-OFFSET(KINGSQ(K))) = 2
07258 --               THEN FOR I := 1 UNTIL POS(SSQA)
07259 9-                    DO BEGIN
07260 --                      IF TRAPPED
07261 10-                     THEN BEGIN
07262 --                        SQ := POSITION(SSQA,I) ;
07263 --                                  COMMENT can we give check from a safe
07264 --                                                square ;
07265 --                        IF CON(K,SQ) = 0
07266 11-                       THEN BEGIN
07267 --                          TMP := KK*CHECK_S(KK,SQ) ;
07268 --                          IF DEBUG
07269 --                          THEN WRITEON(SQ, TMP) ;
07270 --                          IF TMP > 0 AND CHEC(TMP, PC)
07271 --                             OR BOTV(PC, OFFSET(SQ)-OFFSET(KINGSQ(K))) = 1
07272 --                             AND CLEAR(ATTA, SQ, KINGSQ(K))
07273 --                          THEN TRAPPED := FALSE ;
07274 --                          IF ~TRAPPED
07275 12-                         THEN BEGIN
07276 --                            EPSCORE := IF ENPR < LOST
07277 --                                       THEN LOST
07278 --                                       ELSE IF EPSCORE > ENPR
07279 --                                            THEN ENPR
07280 --                                            ELSE EPSCORE ;
07281 --                            IF DEBUG
07282 --                            THEN WRITEON("MOVE", SQ, ENPR, LOST, EPSCORE) ;
07283 -12                         END ;
07284 -11                       END ;
07285 -10                     END ;
07286 -9               END ;
07287 --               IF TRAPPED
07288 --               THEN PIN := TRUE ;
07289 -8             END ;
07290 -7           END ;
07291 -6      END ;
07292 --      PC := ABS(BRD(SSQA)) ;
07293 --      IF ~CAPT_CH AND ~TRAPPED AND SCR > DELTA
07294 --      THEN FOR I := POSITION(SSQA,LIM) UNTIL LIM-1
07295 6-           DO BEGIN
07296 --             SQ3 := POSITION(SSQA,I) ;
07297 --             SAFE := FALSE ;
07298 --             OFF3 := OFFSET(SQ3) ;
07299 --                   COMMENT is movement of SSQA impossible,
07300 --                           because tied to defence of SQ3? ;
07301 --             IF CON(-KK,SQ3) ~= 0 AND SEC(KK,SQ3) = KK AND KK*BRD(SQ3) > 0
07302 7-             THEN BEGIN
07303 --               IF PC >= BISHOP
07304 --               THEN FOR J := 1 UNTIL POS(SSQA)
07305 --                    DO IF ~SAFE
07306 8-                       THEN BEGIN
07307 --                         SQD := POSITION(SSQA,J) ;
07308 --                         IF CON(K,SQD) = 0 AND BOTV(PC, OFF3-OFFSET(SQD)) = 1
07309 --                         THEN SAFE := TRUE ;
07310 -8                    END ;
07311 --               VALSQ3 := VALUES(ABS(BRD(SQ3))) ;
07312 --               IF SAFE
07313 --               THEN VALSQ3 := VALSQ3 - VALUES(ABS(BRD(CONTROL(SQ3,-KK)))) ;
07314 --               IF VALSQ3 > 0 AND EPSQR ~= HOLE
07315 8-               THEN BEGIN
07316 --                                   COMMENT epscore := max( min(valsq3,scr), enpr) ;
07317 --                 V_A := BOTV(ABS(BRD(SQ3)), OFFSET(SQ3) -OFFSET(EPSQR)) = 1 ;
07318 --                 S_A := BOTV(ABS(BRD(SSQA)), OFFSET(SSQA) -OFFSET(EPSQR)) = 1 ;
07319 --                 IF V_A
07320 9-                 THEN BEGIN
07321 --                   V_A := FALSE ;
07322 --                   FOR I := SEC(KK,EPSQR) STEP -KK UNTIL KK
07323 --                   DO IF SECRET(EPSQR,I) = SQ3
07324 --                      THEN V_A := TRUE ;
07325 -9                 END ;
07326 --                 IF S_A
07327 9-                 THEN BEGIN
07328 --                   S_A := FALSE ;
07329 --                   FOR I := SEC(KK,EPSQR) STEP -KK UNTIL KK
07330 --                   DO IF SECRET(EPSQR,I) = SSQA
07331 --                      THEN S_A := TRUE ;
07332 -9                 END ;
07333 --                 IF VALSQ3 > SCR
07334 9-                 THEN BEGIN
07335 --                   EPSCORE := SCR ;
07336 --                   IF ENPR > 0 AND ~V_A
07337 --                   THEN IF ~S_A OR VALSQ3 -ENPR > SCR
07338 --                        THEN ENPR := 0
07339 --                        ELSE EPSCORE := VALSQ3 ;
07340 -9                 END ELSE
07341 9-                 BEGIN
07342 --                                           COMMENT  valsq3 < scr ;
07343 --                   EPSCORE := VALSQ3 ;
07344 --                   IF ENPR > 0 AND ~S_A AND SCR -ENPR > -DELTA
07345 --                   THEN IF ~V_A OR SCR -ENPR < VALSQ3
07346 --                        THEN ENPR := 0
07347 --                        ELSE EPSCORE := SCR ;
07348 -9                 END ;
07349 --                 TRAPPED := TRUE ;
07350 --                 IF PC = KING
07351 --                 THEN EPSCORE := EPSCORE + 2 ;
07352 --                                                 COMMENT capture in vicinity of King ;
07353 -8               END ;
07354 --                              COMMENT IF DEBUG
07355 --                              THEN WRITE("DECOY/TRAP ", PC, SSQA, SQ3,
07356 --                                         SCR, EPSCORE, VALSQ3, SAFE, V_A, S_A, EPSQR) ;
07357 -7             END ;
07358 -6      END ;
07359 -5    END OF_HIDETRAP ;
07360 --  
07361 --    PROCEDURE DECOYED ;
07362 5-    BEGIN
07363 --      INTEGER AT3, SQM, PCM, SQ, ENP_VAL ;
07364 --      LOGICAL T, DISCOVER ;
07365 --  
07366 --      SQD := SQA ;
07367 --      LOST := -1 ;
07368 --                COMMENT is SQA pinned? ;
07369 --      PIN := SACR_CAPT := FALSE ;
07370 --      SQA_ATT := CON(-KK,SQA) ;
07371 --      FOR II := SQA_ATT STEP KK UNTIL -KK
07372 --      DO IF ~PIN
07373 6-         THEN BEGIN
07374 --                COMMENT is SQA pinned against King, or other inadequately
07375 --                        defended piece? ;
07376 --           SQ1 := CONTROL(SQA,II) ;
07377 --           PC1 := ABS(BRD(SQ1)) ;
07378 --           IF (SQ1 ~= SQT) AND (PC1 >= BISHOP) AND (PC1 <= QUEEN)
07379 7-           THEN BEGIN
07380 --             IF HIDDEN(SQ1, SQA, SQ3, KK, FALSE)
07381 --             THEN ;
07382 --             PC3 := KK*BRD(SQ3) ;
07383 --             IF (SQ3 ~= HOLE)
07384 --             THEN IF (PC3 > 0)
07385 --                  THEN IF (PC3 = KING)
07386 --                       THEN PIN := TRUE
07387 8-                  ELSE BEGIN
07388 --                    AT3 := K*SEC(0,SQ3) + 1 ;
07389 --                    IF AT3 = 0 AND PCA > PAWN
07390 --                         AND BOTV(PCA, OFFSET(SQA)-OFFSET(SQ3)) = 1
07391 --                         AND BOTV(PCA, OFFSET(SQT)-OFFSET(SQ3)) ~= 1
07392 --                    THEN AT3 := 1 ;
07393 --                      IF DEBUG
07394 --                      THEN WRITEON("DECO", SQ1, SQ3, AT3 ) ;
07395 --                    IF AT3 = 1 AND CONTROL(SQ3,K) = SQT
07396 --                    THEN AT3 := 0 ;
07397 --                    IF (AT3 > 0) OR (PC1 < PC3)
07398 9-                    THEN BEGIN
07399 --                      DECOY := VALUES(PC3) ;
07400 --                      ENP := VALSQT ;
07401 --                      TMP := K*CHECK_S(-K,SQ3) ;
07402 --                        IF DEBUG
07403 --                        THEN WRITE("DECO ", SQ1, SQ3, TMP, K,
07404 --                                       CHECK_S(K,SQ3), CHEC(ABS(TMP), PC1)) ;
07405 --                      IF TMP > 0 AND CHEC(TMP,PC1)
07406 --                      THEN ENP := 0
07407 --                      ELSE
07408 --                      IF CON(K,SQT) ~= 0
07409 --                      THEN IF VALSQA > DECOY + DELTA OR CAPTURE_CH(SQT)
07410 10-                          THEN BEGIN
07411 --                             ENP := ENP - VALSQA ;
07412 --                             DECOY := 0 ;
07413 -10                     END ;
07414 --                                 COMMENT see XRAY pin ;
07415 --                      IF AT3 <= 0 AND DECOY > 0
07416 --                      THEN DECOY := DECOY - VALUES(PC1) ;
07417 --                      IF DEBUG THEN WRITEON(DECOY, LOST, ENP, TMP) ;
07418 --                      IF (LOST < DECOY)
07419 10-                     THEN BEGIN
07420 --                        SQD := SQ3 ;
07421 --                        LOST := DECOY ;
07422 -10                     END ;
07423 --                      IF CAPTURE_CH(SQD)
07424 --                      THEN LOST := LOST + 1 ;
07425 -9                    END ;
07426 -8             END ;
07427 -7           END ;
07428 -6      END ;
07429 --      IF PIN
07430 --      THEN LOST := LOSSES
07431 6-      ELSE BEGIN
07432 --        RELEVANT := SQT_CAPT := TRUE ;
07433 --        CH_CAPT := FALSE ;
07434 --        TMP := IF M4 = KING AND ~INCHECK
07435 --               THEN 0
07436 --               ELSE KK*CHECK_S(K,SQT) ;
07437 --          IF DEBUG
07438 --          THEN WRITEON(TMP, ENP) ;
07439 --        DISCOVER := FALSE ;
07440 --        FOR I := -K STEP -K UNTIL CON(-K,SQA)
07441 7-        DO BEGIN
07442 --                 COMMENT possible discovered attack on us when opponent captures ;
07443 --          SQ1 := CONTROL(SQA,I) ;
07444 --          PC1 := ABS(BRD(SQ1)) ;
07445 --          IF PC1 >= BISHOP AND PC1 <= QUEEN
07446 8-          THEN BEGIN
07447 --            T := HIDDEN(SQ1, SQA, SQ3, K, FALSE) ;
07448 --                       COMMENT but not an inline capture SQ3 ~= SQT,
07449 --                               and SQ3 cannot recapture on SQT ;
07450 --            IF SQ3 ~= HOLE AND SQ3 ~= SQT
07451 --               AND BOTV(ABS(BRD(SQ3)), OFFSET(SQT)-OFFSET(SQ3)) ~= 1
07452 --            THEN IF K*BRD(SQ3) > 0 AND CON(K,SQ3) = 0
07453 9-                 THEN BEGIN
07454 --                   DISCOVER := TRUE ;
07455 --                   ENP := ENP + VALUES(ABS(BRD(SQ3))) ;
07456 -9                 END ;
07457 --            IF DEBUG
07458 --            THEN WRITEON(SQ1, SQ3, ENP) ;
07459 -8          END ;
07460 -7        END ;
07461 --        IF ENP <= -DELTA
07462 --        THEN TMP := 0
07463 --        ELSE IF M4 = KING AND ABS(SQT-M3) <= 11
07464 --             THEN FOR I := K_SQRS(-KK) STEP KK UNTIL -KK
07465 --                  DO IF SQT = KSQRS(I)
07466 7-                     THEN BEGIN
07467 --                       TMP := KK*(M3-SQT) ;
07468 --                       TMP := IF ABS(TMP) = 10 OR ABS(TMP) = 1
07469 --                              THEN 5
07470 --                              ELSE IF TMP < 0
07471 --                                   THEN 4
07472 --                                   ELSE 1 ;
07473 -7        END ;
07474 --        IF TMP > 0 AND CHEC(TMP, PCA) and BRD(SQT) ~= 0
07475 7-        THEN BEGIN
07476 --                    COMMENT if PCA is a Q, R or B and capture of SQT yields
07477 --                            a check, then set NORMAL false and SEC <= 0 ;
07478 --            IF DEBUG OR ~KINGMOVING AND ~CAPTURE_CH(SQT)
07479 8-            THEN begin
07480 --              WRITE("CHECK CAPT. ON", SQT, PCA, KK, CHECK_S(K,SQT), N,
07481 --                        TMP, CHEC(TMP,PCA)) ;
07482 --              TRACER(1, "?P") ;
07483 -8            end ;
07484 --          NORMAL := FALSE ;
07485 --          CH_CAPT := CAPTURE_CH(SQT) := TRUE ;
07486 --          PCA := TMP ;
07487 --                    COMMENT determine potential safety of the capture with check ;
07488 --          SQD := SQA ;
07489 --          LOST := -1 ;
07490 -7        END ;
07491 --        IF (~GIVINGCH OR ~DOUBLECH AND (SQT = KINGATTACKER)
07492 --                OR SQTDEF = 0 AND SQA = KSQ)
07493 --              AND LOST < VALSQT + DELTA
07494 --              AND (SQTDEF = 0 OR VALSQA < VALSQT + DELTA
07495 --                OR VALSQA -MINDEF < VALSQT + DELTA AND K*SEC(0,SQT) < 0)
07496 --              OR DISCOVER AND ENP > -DELTA
07497 7-        THEN BEGIN
07498 --          IF DEBUG
07499 --          THEN WRITE("YECAP", MINDEF, VALSQT, VALSQA, SQTDEF,
07500 --                     SQT_ATT, SQA_ATT, LOST, ENP, "'") ;
07501 --          IF ~CH_CAPT
07502 8-          THEN BEGIN
07503 --                 COMMENT can the major piece on SQA be decoyed from the back rank,
07504 --                         and hence be open to a back rank mate? ;
07505 --            IF ABS(PCA) = ROOK OR ABS(PCA) = QUEEN
07506 --            THEN IF ROWS(KSQ) = ROWS(SQA) AND ROWS(SQT) ~= ROWS(SQA)
07507 --                    AND KING_HELD(-K)
07508 9-            THEN BEGIN
07509 --                                COMMENT King held on back rank ;
07510 --              SQ := IF K = 1 THEN BKRSQ - 7 ELSE WQRSQ ;
07511 --              FOR I := 0 UNTIL 7
07512 10-             DO BEGIN
07513 --                IF SQ ~= KSQ AND ABS(CON(-K,SQ)) <= 1
07514 --                             AND CON(K,SQ) ~= 0
07515 --                THEN FOR J := CON(K,SQ) STEP -K UNTIL K
07516 11-               DO BEGIN
07517 --                  SQM := CONTROL(SQ,J) ;
07518 --                  PCM := ABS(BRD(SQM)) ;
07519 --                  IF (PCM = ROOK OR PCM = QUEEN)
07520 --                      AND SQT ~= SQM AND ROWS(SQM) ~= ROWS(SQA)
07521 12-                 THEN BEGIN
07522 --                            COMMENT Q or R may go to back row - do they give check? ;
07523 --                    T := CHECK_S(-K,SQ) ~= 0 ;
07524 13-                   IF ~T THEN BEGIN
07525 --                      T := HIDDEN(SQ, SQA, SQ3, -K, TRUE) ;
07526 --                      T := SQ3 = KSQ ;
07527 -13                   END ;
07528 --                    IF DEBUG THEN
07529 --                    WRITE("MATE?", T, SQM, SQ) ;
07530 13-                   IF T THEN BEGIN
07531 --                      LOST := VALUES(ABS(BRD(SQ))) ;
07532 --                      IF CON(-K,SQA) = 0
07533 --                      THEN LOST := LOST + VALSQA
07534 --                      ELSE IF LOST = 0 OR ABS(CON(-K,SQA)) > 1
07535 --                           THEN LOST := LOST + VALSQA - VALUES(ABS(PCM))
07536 --                           ELSE LOST := LOST + VALSQA ;
07537 --                      IF LOST > ENP
07538 --                      THEN LOST := ENP
07539 --                      ELSE IF LOST < 0
07540 --                           THEN LOST := 0 ;
07541 --                      SQD := SQ ;
07542 --                      DECOYS(SQT) := LOST ;
07543 -13                   END ;
07544 -12                 END ;
07545 -11               END ;
07546 --                SQ := SQ + 1 ;
07547 -10             END ;
07548 -9            END ;
07549 --                      COMMENT are there decoy possibilities, in which SQA captures
07550 --                              SQT, but leaves a piece on SQD enprise? ;
07551 --            FOR J := POSITION(SQA,LIM) UNTIL LIM-1
07552 9-            DO BEGIN
07553 --              SQJ := POSITION(SQA,J) ;
07554 --              IF (BRD(SQJ)*KK > NIL)
07555 --              THEN IF ABS(CON(KK,SQJ)) = 1 AND CON(-KK,SQJ) ~= 0
07556 --                      AND (CONTROL(SQJ,-KK) ~= SQT OR ABS(CON(-KK,SQJ)) > 1)
07557 10-                  THEN BEGIN
07558 --                     TMP := K*CHECK_S(K,SQJ) ;
07559 --                     IF TMP > 0
07560 --                     THEN FOR I := CON(K,SQJ) STEP -K UNTIL K
07561 11-                         DO BEGIN
07562 --                            PC1 := K*BRD(CONTROL(SQJ,I)) ;
07563 --                            IF CHEC(TMP, PC1)
07564 --                            THEN RECAPT_CH := TRUE ;
07565 -11                    END ;
07566 --                     IF DEBUG
07567 --                     THEN WRITEON(SQJ, BRD(SQJ), RECAPT_CH) ;
07568 --                     SQI := SQT ;
07569 --                     OFF3 := OFFSET(SQT) - OFFSET(SQJ) ;
07570 --                     SAVE_D := IF PCA > KNIGHT AND BOTV(PCA,OFF3) = 1
07571 --                               THEN BOTV(EDGE, OFF3)
07572 --                               ELSE 0 ;
07573 --                     IF SAVE_D ~= 0
07574 --                     THEN IF PCA = KING
07575 11-                         THEN BEGIN
07576 --                            IF BOTV(KING, OFF3) = 1
07577 --                            THEN SQI := SQJ ;
07578 -11                    END ELSE
07579 11-                    BEGIN
07580 --                       SQI := SQI + SAVE_D ;
07581 --                       WHILE BRD(SQI) = 0
07582 --                       DO SQI := SQI + SAVE_D ;
07583 --                       IF SQI = SQA
07584 --                       THEN SQI := SQJ ;
07585 --                       IF DEBUG
07586 --                       THEN WRITEON("*", PCA, SQI, SAVE_D, SQJ) ;
07587 --                           COMMENT does PCA defend SQJ from SQT? ;
07588 -11                    END ;
07589 --                     IF (SQI ~= SQJ)
07590 11-                    THEN BEGIN
07591 --                           COMMENT SQA sole defender of SQD, and SQT not sole
07592 --                                   attacker, and SQT, SQA, SQJ not inline ;
07593 --                       PC1 := ABS(BRD(SQJ)) ;
07594 --                       DECOY := VALUES(PC1) ;
07595 --                       IF (PC1 = PAWN)
07596 12-                      THEN BEGIN
07597 --                         IF ENDGAME
07598 --                         THEN DECOY := DECOY + PASSEDPAWN(SQJ,KK) ;
07599 --                         IF (RANKS(ROWS(SQJ)) = KK)
07600 --                         THEN DECOY := DECOY + PAWNVAL(ROWS(SQJ)) ;
07601 -12                      END ;
07602 --                       IF (LOST < DECOY)
07603 12-                      THEN BEGIN
07604 --                         LOST := DECOY ;
07605 --                         SQD := SQJ ;
07606 --                         SPECIAL := FALSE ;
07607 --                         DECOYS(SQT) := LOST ;
07608 -12                      END ;
07609 -11                    END ;
07610 -10             END ;
07611 -9            END ;
07612 --                           COMMENT if SQA x SQT then does the recapture by SQ1
07613 --                                   lead to a decoy loss on SQ3? ;
07614 --            ENP_VAL := 0 ;
07615 --            FOR I := K STEP K UNTIL CON(K,SQT)
07616 9-            DO BEGIN
07617 --              SQ1 := CONTROL(SQT,I) ;
07618 --              ENP_VAL := 0 ;
07619 --              FOR J := POSITION(SQ1,LIM) UNTIL LIM-1
07620 10-             DO BEGIN
07621 --                SQ3 := POSITION(SQ1,J) ;
07622 --                IF SQ3 ~= SQT
07623 --                THEN IF ABS(CON(K,SQ3)) = 1 AND CON(-K,SQ3) ~= 0
07624 11-                    THEN BEGIN
07625 --                       VALSQ3 := VALUES(ABS(BRD(SQ3))) ;
07626 --                       IF VALSQ3 < VALSQA - DELTA
07627 --                       THEN ENP_VAL := ENP_VAL + VALSQ3
07628 --                       ELSE ENP_VAL := ENP_VAL + VALSQA ;
07629 --                       IF DEBUG THEN WRITEON(ENP_VAL) ;
07630 -11               END ;
07631 -10             END ;
07632 --              IF ENP_VAL = 0 THEN GOTO OK ;
07633 -9            END ;
07634 --            ENP := ENP + ENP_VAL ;
07635 --  OK:
07636 --            NORMAL := TRUE ;
07637 --            IF (LOST ~= -1)
07638 --            THEN IF LOST > LOSSES AND (VALSQT < LOST - DELTA)
07639 9-                 THEN BEGIN
07640 --                   IF DEBUG AND ABS(SQT_ATT) = 1
07641 --                   THEN WRITEON(LOST, SQD) ;
07642 --                   SQD := SQA ;
07643 --                   LOST := LOSSES ;
07644 --                   IF ABS(SQT_ATT) = 1
07645 --                   THEN ENP := LOSS(EPLIST(JJ)) := 0 ;
07646 -9            END ;
07647 -8          END ;
07648 -7        END ELSE
07649 7-        BEGIN
07650 --          IF DEBUG
07651 --          THEN WRITE("NOCAP", MINDEF, VALSQT, VALSQA, SQTDEF,
07652 --                     SQT_ATT, SQA_ATT, ENP) ;
07653 --          CH_CAPT := FALSE ;
07654 --          SQT_CAPT := FALSE ;
07655 --          SQD := SQA ;
07656 --          LOST := IF LOSSES < -SEVENS OR LOSSES > -DELTA
07657 --                  THEN LOSSES
07658 --                  ELSE 0 ;
07659 --          IF ENP <= -PVAL AND -ENP < LOST AND VALSQT - VALSQA-ENP > -DELTA
07660 8-          THEN BEGIN
07661 --            SACR_CAPT := TRUE ;
07662 --            SQT_CAPT := TRUE ;
07663 --            LOST := -ENP ;
07664 --            ENP := 0 ;
07665 -8          END ELSE IF (CONTROL(SQA, SQA_ATT) = SQT AND ENP > DELTA)
07666 --                   THEN LOST := VALSQT - VALSQA ;
07667 -7        END ;
07668 --        SQA := SQD ;
07669 -6      END ;
07670 --      IF LOST = -1 AND ENP < -DELTA
07671 --      THEN LOST := LOSSES ;
07672 --      IF DEBUG
07673 --      THEN WRITEON(LOST) ;
07674 -5    END OF_DECOYED ;
07675 --  
07676 --    PROCEDURE BIGGER_LOSS ;
07677 5-    BEGIN
07678 --      LOGICAL SQ3_ATTA, SQ3_DEF ;
07679 --  
07680 --      FOR LL := TT UNTIL ELIMIT-1
07681 6-      DO BEGIN
07682 --                          COMMENT even though SQA captures SQT, an alternative
07683 --                                  loss may exist ;
07684 --        L := EPLIST(LL) ;
07685 --        SQ3 := SQUARE(L) ;
07686 --        IF SQA = SQ3 OR SQT_CAPT AND SQ3 = SQSAVE
07687 --        THEN GOTO U ;
07688 --        IF (SQ3 = KSQ)
07689 --        THEN GO TO U ;
07690 --        LOSS3 := LOSS(L) ;
07691 --        PC3 := ABS(BRD(SQ3)) ;
07692 --        VALSQ3 := VALUES(PC3) ;
07693 --                        COMMENT if SQAxSQT and recapture requred on SQT,
07694 --                                no more loss unless capture on SQ3 is with check ;
07695 --        IF CON(K,SQT) ~= 0 THEN
07696 --        IF SQT_CAPT AND VALSQA > VALSQ3 - DELTA AND VALSQT > ENP + DELTA
07697 --             AND ~CAPTURE_CH(SQ3)
07698 --           OR CH_CAPT AND (ABS(CON(-K,SQ3)) > 1 OR CONTROL(SQ3,K) ~= KINGSQ(K))
07699 --        THEN GO TO U ;
07700 --        IF (LOST < LOSS3 AND (LOST ~= -77 OR LOSS3 > 0))
07701 --            OR LOST = LOSS3 AND POS(SQA) > POS(SQ3)
07702 7-        THEN BEGIN
07703 --          OFF3 := OFFSET(SQT) -OFFSET(SQ3) ;
07704 --  
07705 --                          COMMENT Will the capture by SQI on SQT save SQ3
07706 --                                  1. By removing SQT as an attacker,
07707 --                                  2. By adding a NEW defender at SQT.
07708 --                              In either case see if it actually makes difference ;
07709 --  
07710 --          SAVE_D := BOTV(EDGE, OFF3) ;
07711 --                        COMMENT is SQT the only attacker of SQ3
07712 --                                is SQ3 the only attacker of SQT ;
07713 --          IF (CON(K,SQ3) = K AND CONTROL(SQ3,K) = SQT)
07714 --                 AND ENP > -DELTA
07715 --          THEN GOTO U
07716 --          ELSE
07717 --          IF ENP >= -LOSS3
07718 --          THEN
07719 --          IF CON(-K,SQT) = -K AND CONTROL(SQT,-K) = SQ3
07720 --          THEN GOTO U
07721 --          ELSE
07722 --          IF (LOST ~= -1 OR LOSSES < LOSS3 + DELTA)
07723 --          THEN FOR II := CON(KK,SQT) STEP -KK UNTIL KK
07724 8-          DO BEGIN
07725 --                                 COMMENT consider SQI, each attacker of SQT ;
07726 --            SQI := CONTROL(SQT,II) ;
07727 --            PCI := ABS(BRD(SQI)) ;
07728 --  
07729 --                             COMMENT removing P attacker, or adding P, K defence ;
07730 --            IF SAVE_D ~= 0 AND (PCI = PAWN AND ABS(SQ3 -SQT -FILES(-K)) = 1
07731 --                  OR PCT = PAWN AND ABS(SQ3 -SQT -FILES(K)) = 1)
07732 --                AND (PCI = PAWN OR PCT = PAWN OR PCI = KING)
07733 --                AND SQT + SAVE_D = SQ3
07734 --                AND VALUES(ABS(BRD(CONTROL(SQ3,K)))) >= VALSQ3 -DELTA
07735 --            THEN GOTO U ;
07736 --  
07737 --                            COMMENT adding Knight defender or
07738 --                                    removing Knight attacker ;
07739 --            E1 := BOTV(KNIGHT, OFF3) = 1 ;
07740 --            IF E1 AND ASQRS(L) ~= 0
07741 9-            THEN BEGIN
07742 --              IF DEBUG
07743 --              THEN WRITE("KNIGHT", PCI, SQI, PC3, SQ3, PCT, SQT, ASQRS(L),
07744 --                         K, SEC(0,SQ3)) ;
07745 --  
07746 --                            COMMENT are we removing a Knight defender? ;
07747 --              IF PCI = KNIGHT AND SQI ~= SQ3
07748 --              THEN IF VALUES(ABS(BRD(ABS(ASQRS(L))))) > LOSS3-DELTA
07749 --                   THEN GOTO U ;
07750 --  
07751 --                            COMMENT are we removing a small Knight attacker? ;
07752 --              IF PCT = KNIGHT
07753 --              THEN IF ABS(ASQRS(L)) ~= SQT
07754 --                   THEN GOTO UUU
07755 --                   ELSE IF K*SEC(0,SQ3) <= 0
07756 --                        THEN GOTO U
07757 --                        ELSE IF SECRET(SQ3,K) ~= SQT
07758 --                             THEN GOTO UUU
07759 --                             ELSE IF ABS(SEC(0,SQ3)) > 1
07760 --                                  THEN GOTO UUU
07761 10-                                 ELSE BEGIN
07762 --                                    FOR I := K+K STEP K UNTIL CON(K,SQ3)
07763 --                                    DO IF VALUES(ABS(BRD(CONTROL(SQ3,I))))
07764 --                                          < VALSQ3 - DELTA
07765 --                                       THEN GOTO UUU ;
07766 --                                    GOTO U ;
07767 -10                                 END ;
07768 -9            END ;
07769 --  
07770 --                               COMMENT removing B, R, Q attacker,
07771 --                                       or adding B, R, Q, K defence ;
07772 --            SQ3_ATTA := PCT > KNIGHT AND BOTV(PCT, OFF3) = 1 ;
07773 --            SQ3_DEF := SQI ~= SQ3 AND PCI > KNIGHT AND BOTV(PCI, OFF3) = 1
07774 --                              AND (CON(K,SQT) = 0 OR VALSQ3 > VALUES(PCI) + DELTA) ;
07775 --            IF SAVE_D ~= 0 AND (SQ3_ATTA OR SQ3_DEF)
07776 9-            THEN BEGIN
07777 --              SQ1 := SQT ;
07778 --  LOOP:
07779 --              SQ1 := SQ1 + SAVE_D ;
07780 --              WHILE BRD(SQ1) = 0
07781 --              DO SQ1 := SQ1 + SAVE_D ;
07782 --              PC1 := ABS(BRD(SQ1)) ;
07783 --              IF DEBUG
07784 --              THEN WRITE("BIGG ", PCI, SQI, PCT, SQT, SQ3, PC1, SQ1, LOSS3,
07785 --                          LOSS(I), LOSSES, CON(K,SQ3), CONTROL(SQ3,K), SQ3_ATTA, SQ3_DEF) ;
07786 --              IF SQ1 ~= SQ3 AND PC1 > KNIGHT AND PC1 < KING
07787 --                 AND BOTV(PC1,OFFSET(SQ1)-OFFSET(SQ3)) = 1
07788 --              THEN GOTO LOOP ;
07789 --  
07790 --                                     COMMENT  indirect attack/defence ;
07791 --              E1 := FALSE ;
07792 --              IF DEBUG
07793 --              THEN WRITEON(CON(K,SQT), CON(-K,SQ3), CONTROL(SQ3,-K)) ;
07794 --              IF SQ1 = SQ3 AND (~GIVINGCH OR SQT = KINGATTACKER)
07795 --              THEN IF CON(K,SQT) = 0 AND PC3 > KNIGHT AND BOTV(PC3,OFF3) = 1
07796 10-                  THEN BEGIN
07797 --                                 COMMENT PC3 may capture on SQT ;
07798 --                     IF ~SQT_CAPT OR LOST >= DELTA
07799 --                     THEN GOTO U
07800 --                     ELSE LOST := LOSS3 := (IF LOSS3 < LOSSES
07801 --                                            THEN LOSS3
07802 --                                            ELSE LOSSES) ;
07803 -10             END ELSE IF CON(K,SQT) = 0
07804 --                       THEN E1 := TRUE
07805 10-             ELSE BEGIN
07806 --                IF DEBUG
07807 --                THEN WRITE("BIG ", PCT, BOTV(PCT, OFF3), BOTV(PCI, OFF3)) ;
07808 --                IF CLEAR(SQT, SQT, SQ3) AND ENP > -DELTA
07809 --                   AND (SQ3_ATTA AND (SQ3_DEF OR ABS(CON(K,SQ3)) = 1
07810 --                   OR CON(-K,SQ3) ~= 0 AND CONTROL(SQ3,-K) ~= SQI)
07811 --                   OR SQ3_DEF AND (~CLEAR(SQI, SQI, SQ3)
07812 --                                OR BOTV(PCI, OFFSET(SQ3)-OFFSET(SQI)) ~= 1))
07813 11-               THEN BEGIN
07814 --                                COMMENT capture of SQT by SQI makes SQ3 safe if
07815 --                                        a. SQT attacks SQ3 and defence of SQ3 not reduced.
07816 --                                        b. Defence of SQ3 increases.
07817 --                                           Otherwise reduce LOSS3 if appropriate ;
07818 --                  GOTO U ;
07819 -11               END ELSE IF VALSQ3 - VALSQT < LOSS3 - DELTA
07820 11-                        THEN BEGIN
07821 --                           LOSS3 := VALSQ3 - VALSQT ;
07822 -11               END ;
07823 --                COMMENT IF CON(K,SQ3) = K
07824 --                THEN LOSS3 := LOSS3 - VALUES(ABS(BRD(CONTROL(SQ3,K)))) ;
07825 -10             END ;
07826 --              IF E1
07827 --              THEN IF VALSQT < VALSQ3 + DELTA OR CON(K,SQ3) = K
07828 --                      OR VALSQT > VALSQ3 - DELTA AND K*SEC(0,SQ3) <= 1
07829 --                        AND (CON(-K,SQ3) ~= -K OR CONTROL(SQ3,-K) ~= SQI
07830 --                          OR BOTV(PCI, OFF3) = 1)
07831 --                   THEN LOSS3 := -VALSQT ;
07832 --              IF DEBUG
07833 --              THEN WRITEON(LOSS3, E1, K*SEC(0,SQ3)) ;
07834 -9            END ;
07835 --  UUU:
07836 -8          END ;
07837 --  
07838 --          SMALL_ATTA := MAXINTEGER ;
07839 --          E1 := FALSE ;
07840 --                         COMMENT is there a pin or decoy relationship in effect ;
07841 --          IF ~GIVINGCH OR SQT = KINGATTACKER
07842 --          THEN IF (ENP ~= -77) AND (~SQT_CAPT OR LOSS(I) < DELTA)
07843 --               THEN FOR J := CON(KK,SQT) STEP -KK UNTIL KK
07844 --                    DO IF (SQ3 = CONTROL(SQT,J))
07845 --                       THEN IF (CON(-KK,SQT)  = 0 OR LOSS3 < DELTA
07846 --                               OR VALSQ3 < VALSQT + DELTA)
07847 --                            THEN GO TO U
07848 --                            ELSE E1 := TRUE ;
07849 --          IF E1
07850 --          THEN IF SEC(0,SQT)*KK < 0
07851 --               THEN E1 := FALSE
07852 --               ELSE FOR J := CON(-KK,SQT) STEP KK UNTIL -KK
07853 8-          DO BEGIN
07854 --            PC1 := VALUES(ABS(BRD(CONTROL(SQT,J)))) ;
07855 --            IF SMALL_ATTA > PC1
07856 --            THEN SMALL_ATTA := PC1 ;
07857 -8          END ;
07858 --          IF E1 AND SMALL_ATTA > VALSQ3 -DELTA
07859 --          THEN GO TO U ;
07860 --          IF ENP ~= -77 AND ENP < VALSQT -DELTA
07861 --          THEN IF (~SQT_CAPT AND LOSS3 > VALSQ3 - DELTA
07862 --                    OR SQT_CAPT AND VALSQA < VALSQ3 + DELTA)
07863 --               THEN IF -ENP >= LOSS3 AND LOST ~= -77
07864 --                    THEN GOTO U
07865 --                    ELSE IF ~CAPTURE_CH(SQ3) AND G2 < VALSQT - DELTA
07866 --                            AND G2 > -DELTA
07867 8-                         THEN BEGIN
07868 --                           IF DEBUG THEN
07869 --                             WRITEON("New_enp", VALSQT, G2, ENP,
07870 --                                     E1, SQ3, LOSS3, LOST) ;
07871 --                           ENP := VALSQT ;
07872 -8                         END ;
07873 --                          COMMENT capture SQT, since no recapture on SQ3 ;
07874 --          LOST := LOSS3 ;
07875 --          IF LOSS3 ~= LOSS(L) AND LOSS3 > -DELTA
07876 --          THEN ENP := 0 ;
07877 --          SQA := SQ3 ;
07878 --          PCA := ABS(BRD(SQA)) ;
07879 --          VALSQA := VALUES(PCA) ;
07880 --          SQA_CAPT := FALSE ;
07881 --          SQT_CAPT := IF ENP < -DELTA
07882 --                      THEN FALSE
07883 --                      ELSE SQT_CAPT
07884 --                           OR BOTV(ABS(BRD(SQA)), OFFSET(SQA)-OFFSET(SQT)) = 1 ;
07885 -7        END ;
07886 --  U:
07887 -6      END ;
07888 -5    END OF_BIGGER_LOSS ;
07889 --  
07890 --    PROCEDURE ANALYSE ;
07891 --    WHILE (JJ < EPL)
07892 5-    DO BEGIN
07893 --      JJ := JJ + 1 ;
07894 --      SQT := SQUARE(EPLIST(JJ)) ;
07895 --                       COMMENT SQT contains mover piece.
07896 --                               If EPLIST(0) = 0 then mover not under attack,
07897 --                               therefore ENPR = 0 ;
07898 --      LOST := LOSSES ;
07899 --      SQA_CAPT := SQT_CAPT := FALSE ;
07900 --      DECOY := 0 ;
07901 --      SQA := SQSAVE ;
07902 --      PCA := PCASAVE ;
07903 --      VALSQA := VALUES(PCA) ;
07904 --      if DEBUG and (I < 16 or I > 30 or JJ < 1 or JJ > 15) then
07905 --         write("DEBUG error in ANALYSE ", I, JJ, EPLIST(I), EPLIST(JJ)) ;
07906 --      IF DEBUG
07907 --      THEN SQAXSQT(I,JJ) := +99 ;
07908 --      IF DEBUG
07909 --      THEN SQTXSQA(JJ,I) := -99 ;
07910 --      SQT_ATT := CON(KK,SQT) ;
07911 --      SQTDEF := CON(-KK,SQT) ;
07912 --      MINDEF := IF (SQTDEF = 0)
07913 --                THEN 0
07914 --                ELSE KING ;
07915 --      FOR J := SQTDEF STEP KK UNTIL -KK
07916 6-      DO BEGIN
07917 --        PC := ABS(BRD(CONTROL(SQT,J))) ;
07918 --        IF (MINDEF > PC)
07919 --        THEN MINDEF := PC ;
07920 -6      END ;
07921 --      SQTDEF := ABS(SQTDEF) ;
07922 --      MINDEF := VALUES(MINDEF) ;
07923 --      ENP := LOSS(EPLIST(JJ)) ;
07924 --      IF DEBUG
07925 --      THEN WRITE("EPS", SQA, SQT, EPSQR, ENPR, SCR, EPSCORE, LOST, ENP) ;
07926 --      KINGATTA := FALSE ;
07927 --      IF GIVINGCH AND (SQTDEF = 0)
07928 --      THEN FOR J := SQT_ATT STEP -KK UNTIL KK
07929 --           DO IF (KSQ = CONTROL(SQT,J))
07930 --              THEN KINGATTA := TRUE ;
07931 --                                COMMENT can the king capture on SQT? ;
07932 --      IF (ENP < -SEVENS) OR GIVINGCH AND (SQA ~= KSQ)
07933 --          AND ((SQT ~= KINGATTACKER) OR DOUBLECH) AND ~KINGATTA
07934 --      THEN ENP := -77 ;
07935 --      PCT := ABS(BRD(SQT)) ;
07936 --      VALSQT := VALUES(PCT) ;
07937 --      NORMAL := CH_CAPT := FALSE ;
07938 --      IF (VALSQT < ENP)
07939 --      THEN VALSQT := ENP ;
07940 --      RELEVANT := FALSE ;
07941 --        COMMENT   does sqa attack sqt, if so, then SQA may be pinned, or
07942 --        enprise piece might be required in the current exchange, if sqt
07943 --        undefended, or sqt worth more than sqa, or sqt defended by a major
07944 --        piece ;
07945 --      RECAPT_CH := FALSE ;
07946 --      IF (ENP ~= -77) AND (SQA ~= KSQ OR SQTDEF = 0)
07947 --      THEN FOR J := SQT_ATT STEP -KK UNTIL KK
07948 --           DO IF (SQSAVE = CONTROL(SQT,J))
07949 --              THEN DECOYED ;
07950 --      IF DEBUG AND SQT_CAPT
07951 6-      THEN BEGIN
07952 --        SQAXSQT(I,JJ) := IF LOST < -SEVENS
07953 --                         THEN -ENP
07954 --                         ELSE LOST - ENP ;
07955 --        SQTXSQA(JJ,I) := (IF CH_CAPT
07956 --                          THEN 200
07957 --                          ELSE 0) + (IF VALSQT > ENP
07958 --                                     THEN 100
07959 --                                     ELSE 0) ;
07960 -6      END ;
07961 --                      COMMENT if lost = -1 then sqa can successfully capture sqt ;
07962 --      IF GIVINGCH AND (LOST < -SEVENS) AND (ENP = -77)
07963 --         OR (PCA ~= PAWN AND PCT = ENPRIS)
07964 --      THEN GO TO OMIT ;
07965 --                    COMMENT can the King capture on SQT? ;
07966 --                    COMMENT does SQT attack SQA.  If so does the capture on SQT
07967 --                                save the piece on SQA? ;
07968 --      SQA_ATT := CON(-KK,SQA) ;
07969 --      IF GIVINGCH AND ~KINGATTA AND (SQT ~= KINGATTACKER)
07970 --      THEN ENP := -77 ;
07971 --      IF LOSS(I) > DELTA OR SQA ~= SQSAVE
07972 --      THEN FOR J := SEC(-KK,SQA) STEP KK UNTIL -KK
07973 --      DO IF (SQT = CONTROL(SQA,J))
07974 --         THEN
07975 --         IF ~HIDDEN(KINGSQ(-KK), SQT, SQ3, KK,TRUE)
07976 6-         THEN BEGIN
07977 --                            COMMENT   SQ3 ~= SQA ;
07978 --           IF DEBUG
07979 --           THEN SQTXSQA(JJ,I) := IF ~SQT_CAPT
07980 --                                  THEN LOST
07981 --                                  ELSE IF CON(KK,SQA) ~= 0
07982 --                                       THEN VALSQA - VALSQT
07983 --                                       ELSE VALSQA ;
07984 --            IF EPLIST(0) > 0
07985 7-            THEN BEGIN
07986 --              SQA_CAPT := TRUE ;
07987 --              IF ENP ~= -77 AND (NORMAL OR CH_CAPT OR ~RELEVANT)
07988 --              THEN
07989 --              IF LOST ~= -1
07990 --              THEN IF DECOY ~= 0
07991 --                   THEN SQA_CAPT := FALSE
07992 --                   ELSE
07993 --                   IF (ABS(SQA_ATT) = 1)
07994 8-                   THEN BEGIN
07995 --                                      COMMENT sqt only attacker ;
07996 --                             COMMENT SQA not safe if only a losing capture on SQT ;
07997 --                      IF LOST > -DELTA
07998 --                      THEN
07999 --                      IF (ENP < 0)
08000 9-                      THEN BEGIN
08001 --                        IF -ENP < LOST
08002 10-                       THEN BEGIN
08003 --                          LOST := -ENP ;
08004 --                          ENP := 0 ;
08005 -10                       END ELSE ENP := 0 ;
08006 -9                      END ELSE IF SQT = EPSQR
08007 --                               THEN LOST := -2
08008 --                               ELSE LOST := -3 ;
08009 --                    COMMENT when LOST is -2 it usually means that KK (opponent) has
08010 --                            two pieces of the same value enpris, but it is the other
08011 --                            one (not on EPSQR) which it considers sacrificed.
08012 --                            No epgain should be credited ;
08013 -8                    END
08014 --                    ELSE IF ABS(J) <= ABS(SQA_ATT)
08015 8-                         THEN BEGIN
08016 --                                         COMMENT is SQT the smallest of several
08017 --                                                 attackers and SQA defended? ;
08018 --                           SQ3 := ASQRS(I) ;
08019 --                           VALSQA := VALUES(ABS(BRD(SQA))) ;
08020 --                           IF SQ3 >= WQRSQ and SQ3 <= BKRSQ AND LOST + ENP > -DELTA
08021 9-                           THEN BEGIN
08022 --                             FOR I := SEC(-1,SQA) UNTIL SEC(1,SQA)
08023 --                             DO HOLD(I) := CONTROL(SQA,I) ;
08024 --                             FOR I := -1 UNTIL 1
08025 --                             DO HOLD(16*I) := SEC(I,SQA) ;
08026 --                             CONTROL(SQA,J) := CONTROL(SQA, SQA_ATT) ;
08027 --                             CON(-KK,SQA) := SQA_ATT + KK ;
08028 --                                            COMMENT protect against SQA -- SQD decoy ;
08029 --                             LOST := IF SACRIFICE(SQA, DEBUG)
08030 --                                     THEN IF LOSSES >= 0
08031 --                                          THEN LOSSES
08032 --                                          ELSE -3
08033 --                                     ELSE -3 ;
08034 --                             FOR I := -1 UNTIL 1
08035 --                             DO SEC(I,SQA) := HOLD(16*I) ;
08036 --                             FOR I := SEC(-1,SQA) UNTIL SEC(1,SQA)
08037 --                             DO CONTROL(SQA,I) := HOLD(I) ;
08038 --                             CON(-KK,SQA) := SQA_ATT ;
08039 -9                           END ;
08040 --                           COMMENT IF DEBUG
08041 --                                   THEN WRITE("SQTXSQA", SQ3, SQT,
08042 --                                      SQA, CON(KK,SQA), SQA_ATT, LOST) ;
08043 -8                    END ;
08044 -7            END ;
08045 --            RELEVANT := TRUE ;
08046 -6       END ;
08047 --  
08048 --                        COMMENT if (lost < 0) then capture of sqt
08049 --                        makes sqa safe ;
08050 --      IF (LOST < -3) AND ~CH_CAPT AND ~SQA_CAPT
08051 --      THEN LOST := -77 ;
08052 --      IF (LOST > ENP AND ~SQA_CAPT OR ENP = -77 OR LOST = -77
08053 --          OR CH_CAPT OR SQA_CAPT AND ENP < -DELTA) AND ~GIVINGCH
08054 --                                 AND ~RECAPT_CH
08055 --      THEN FOR II := 1 UNTIL EPL
08056 6-           DO BEGIN
08057 --                         COMMENT assume we will actually make largest capture ;
08058 --             L := EPLIST(II) ;
08059 --             SQ3 := SQUARE(L) ;
08060 --             IF (SQ3 = SQT)
08061 --             THEN GO TO UU ;
08062 --             PC3 := ABS(BRD(SQ3)) ;
08063 --             VALSQ3 := VALUES(PC3) ;
08064 --             IF SQT_CAPT AND CON(-KK,SQ3) ~= 0
08065 --             THEN FOR J := CON(KK,SQ3) STEP -KK UNTIL KK
08066 --                  DO IF (SQA = CONTROL(SQ3,J)) AND VALSQA > VALSQ3 + DELTA
08067 --                     THEN GO TO UU ;
08068 --                                COMMENT when SQAxSQT will SQA then defend SQ3? ;
08069 --             IF SQT_CAPT AND CON(K,SQ3) = 0
08070 --                   AND BOTV(PCA, OFFSET(SQT)-OFFSET(SQ3)) = 1
08071 --             THEN IF (ABS(PCA) <= KNIGHT OR ABS(PCA) = KING)
08072 --                  THEN GOTO UU ;
08073 --                                COMMENT if SQT is attacked, ensure SQ3 is not
08074 --                                        a defender of SQT ;
08075 --             IF CON(KK,SQT) ~= 0
08076 --             THEN FOR J := CON(-KK,SQT) STEP KK UNTIL -KK
08077 --                  DO IF (SQ3 = CONTROL(SQT,J))
08078 --                     THEN GO TO UU ;
08079 --                                   COMMENT falacy: does not account for decoy losses ;
08080 --             IF DECOYS(SQ3) > LOSS(L) - DELTA
08081 --             THEN GOTO UU ;
08082 --             IF (ENP < LOSS(L) -DELTA)
08083 7-             THEN BEGIN
08084 --               ENP := LOSS(L) ;
08085 --               SQT_CAPT := CH_CAPT ;
08086 --               IF LOST = -1 AND ~CH_CAPT
08087 --               THEN LOST := LOSSES ;
08088 --                         COMMENT  WRITE("UU ", SQ3, SQT, SQA, KK, CON(KK,SQ3)) ;
08089 --               SQT := SQ3 ;
08090 --               PCT := PC3 ;
08091 --               FOR J := CON(KK,SQT) STEP -KK UNTIL KK
08092 --               DO IF SQA = CONTROL(SQT,J)
08093 8-                  THEN BEGIN
08094 --                    COMMENT RELEVANT := TRUE ;
08095 --                    SQT_CAPT := TRUE ;
08096 --                    IF VALSQA < VALSQ3 + DELTA
08097 --                    THEN LOST := -1 ;
08098 -8               END ;
08099 --               VALSQT := VALSQ3 ;
08100 -7             END ;
08101 --  UU:
08102 -6      END ;
08103 --      IF ENP > 0
08104 --      THEN CH_CAPT := CAPTURE_CH(SQT) ;
08105 --      IF DEBUG
08106 --      THEN WRITE(RELEVANT, LOST, ENP, SQT_CAPT, SQA_CAPT, CON(-KK,SQT), VALSQA) ;
08107 --      IF ~CH_CAPT AND (~RELEVANT OR LOST < -3)
08108 --         OR (SQT_CAPT AND ~SACR_CAPT AND (~CH_CAPT OR CON(-KK,SQT) ~= 0
08109 --         AND VALSQT <= VALSQA-DELTA) OR LOST < -1 AND SQA_CAPT AND ~SQT_CAPT)
08110 --      THEN BIGGER_LOSS ;
08111 --      IF DEBUG
08112 --      THEN WRITE(LOST, ENP) ;
08113 --      IF ~RELEVANT AND LOST > DELTA AND ENP > 0 AND VALSQT - ENP > DELTA
08114 --      THEN IF VALSQT -ENP >= VALSQA + DELTA
08115 --           THEN LOST := 0
08116 --           ELSE IF ~CAPTURE_CH(SQA)
08117 --                THEN ENP := VALSQT ;
08118 --                                COMMENT is SQA a "primary" attacker of SQT? ;
08119 --      IF (LOST = -1)
08120 --      THEN LOST := IF ENP < VALSQT
08121 --                   THEN -1
08122 --                   ELSE -EIGHTS ;
08123 --      IF ~RELEVANT AND LOST = -1
08124 --      THEN LOST := 0 ;
08125 --      VALID := RELEVANT OR LOST ~= -77 OR ENP > -DELTA ;
08126 --      IF ENP < -DELTA AND ~GIVINGCH
08127 --      THEN SQT := HOLE ;
08128 --      IF DEBUG
08129 --      THEN WRITEON(LOST, ENP, SQA_CAPT, SQA, SQT, VALID) ;
08130 --      IF ENP = -77 OR SQT = HOLE
08131 --      THEN ENP := 0 ;
08132 --                      COMMENT is there a hidden defence of SQA via a capture of SQT ;
08133 --      IF ENP < 0
08134 --      THEN IF LOST = -77 OR LOST >= 0 OR ~SQT_CAPT AND ENP <= -DELTA
08135 --           THEN ENP := 0
08136 --           ELSE IF (ENP > -DELTA) AND RELEVANT AND ~SQT_CAPT
08137 --                   AND CON(-KK,SQT) = 0 AND (LOST > 0)
08138 --                   AND HIDDEN(SQA, SQT, SQ3, KK, TRUE)
08139 --                THEN LOST := -3 ;
08140 --      IF SQT = HOLE
08141 --      THEN SQT_CAPT := FALSE ;
08142 --      SC := (IF LOST = -77 OR LOST < -SEVENS OR LOST < -DELTA
08143 --             THEN 0
08144 --             ELSE LOST) -ENP ;
08145 --      IF VALID
08146 --      THEN IF (SC < COST) OR ABS(SC-COST) < DELTA AND RELEVANT
08147 6-           THEN BEGIN
08148 --                         COMMENT update SPAR1 if capture of SQT forces a recapture ;
08149 --             EP := ENP ;
08150 --             SQAA := IF LOST > -PVAL AND SC + ENP ~= 0
08151 --                     THEN SQA
08152 --                     ELSE HOLE ;
08153 --             PCAA := PCA ;
08154 --             SQ := SQT ;
08155 --             T := KINGATTA ;
08156 --             CHK := ~NORMAL OR RELEVANT ;
08157 --             ADD := CH_CAPT OR LOST < -SEVENS AND ENP > 0 ;
08158 --             CAPTURE := SQT_CAPT ;
08159 --             COST := SC ;
08160 --             IF DEBUG
08161 --             THEN WRITEON(SQ, CAPTURE_CH(SQA), CAPTURE_CH(SQT)) ;
08162 -6      END ;
08163 --      IF DEBUG
08164 --      THEN WRITEON(SQT_CAPT, SQD, NORMAL, KINGATTACKER, DECOY, EP, SC) ;
08165 --  OMIT:
08166 -5    END OF_ANALYSE ;
08167 --  
08168 --  @TITLE, "EP_SCORE"
08169 --  
08170 --         COMMENT purge duplicated squares from enpris list ;
08171 --    TOP := LOSS(ELIMIT) ;
08172 --    FOR I := TOP UNTIL SQUARE(ELIMIT)-1
08173 5-    DO BEGIN
08174 --      J := I + 1 ;
08175 --      WHILE (J < ELIMIT)
08176 --      DO IF (SQUARE(J) = SQUARE(I))
08177 6-         THEN BEGIN
08178 --           IF (I >= ESAVE)
08179 7-           THEN BEGIN
08180 --             SQUARE(I) := SQUARE(ESAVE) ;
08181 --             SQUARE(ESAVE) := SQUARE(TOP) ;
08182 --             ESAVE := ESAVE + 1 ;
08183 -7           END ELSE SQUARE(I) := SQUARE(TOP) ;
08184 --           J := ELIMIT ;
08185 --           TOP := TOP + 1 ;
08186 -6      END ELSE J := J + 1 ;
08187 -5    END ;
08188 --    LOSS(ELIMIT) := TOP ;
08189 --    KK := -K ;
08190 --    KSQ := KINGSQ(KK) ;
08191 --    SQS := SSQA := SQD := HOLE ;
08192 --    EPSCORE := -NINES ;
08193 --    PASS1 := TRUE ;
08194 --    SCR := -NINES ;
08195 --    SEC_EP := ENPSEC := TEMP := LOSERS := 0 ;
08196 --    G1 := G2 := G3 := -NINES ;
08197 --    PPCA := EDGE ;
08198 --    JJ := LOSS(0) ;
08199 --    SPECIAL := TRUE ;
08200 --    TT := ELIMIT ;
08201 --    FOR I := TOP UNTIL ELIMIT-1
08202 5-    DO BEGIN
08203 --      SQA := SQUARE(I) ;
08204 --      ASQRS(I) := 0 ;
08205 --      IF (KK*BRD(SQA) > 0)
08206 6-      THEN BEGIN
08207 --        TT := TT - 1 ;
08208 --        EPLIST(TT) := I ;
08209 --        IF (CON(-KK,SQA) ~= 0)
08210 7-        THEN BEGIN
08211 --                      COMMENT not just captured, not duplicated, not king square ;
08212 --          IF SACRIFICE(SQA, DEBUG)
08213 --          THEN LOSERS := LOSERS + 1 ;
08214 --          IF LOSSES > G2
08215 8-          THEN BEGIN
08216 --            G3 := G2 ;
08217 --            IF LOSSES > G1
08218 9-            THEN BEGIN
08219 --              G2 := G1 ;
08220 --              G1 := LOSSES ;
08221 -9            END ELSE G2 := LOSSES ;
08222 -8          END ELSE IF LOSSES > G3
08223 --                   THEN G3 := LOSSES ;
08224 --          TEMP := ATTASQRS(0) ;
08225 --          SPECIAL := FALSE ;
08226 --          FOR L := 1 UNTIL TEMP
08227 8-          DO BEGIN
08228 --            ADD := TRUE ;
08229 --            SQT := ATTASQRS(L) ;
08230 --            FOR J := 1 UNTIL EPL
08231 --            DO IF ADD AND SQT = SQUARE(EPLIST(J))
08232 --               THEN ADD := FALSE ;
08233 --            IF ADD
08234 9-            THEN BEGIN
08235 --              EPL := EPL + 1 ;
08236 --              JJ := JJ + 1 ;
08237 --              SQUARE(JJ) := SQT ;
08238 --              EPLIST(EPL) := JJ ;
08239 -9            END ;
08240 -8          END ;
08241 --          VALSQA := VALUES(ABS(BRD(SQA))) ;
08242 --          SQT := IF TEMP = 0
08243 --                 THEN 0
08244 --                 ELSE -ATTASQRS(1) ;
08245 --          IF SQT ~= 0
08246 --          THEN IF (TEMP = 1)
08247 --                  OR (VALUES(ABS(BRD(ATTASQRS(2)))) > VALSQA -DELTA)
08248 --               THEN SQT := -SQT ;
08249 --                  COMMENT SQT is -ve if it is one of many small attackers of SQA ;
08250 --          ASQRS(I) := SQT ;
08251 -7        END ELSE LOSSES := -NINES ;
08252 --        J := TT + 1 ;
08253 --        WHILE J < ELIMIT AND LOSSES > LOSS(EPLIST(J))
08254 7-        DO BEGIN
08255 --          EPLIST(J-1) := EPLIST(J) ;
08256 --          J := J + 1 ;
08257 -7        END ;
08258 --        EPLIST(J-1) := I ;
08259 -6      END ;
08260 --      LOSS(I) := LOSSES ;
08261 -5    END ;
08262 --    FOR L := LOSS(0)+1 UNTIL JJ
08263 5-    do begin
08264 --      if SACRIFICE(SQUARE(L), DEBUG) then ;
08265 --      LOSS(L) := LOSSES ;
08266 -5    end ;
08267 --    IF SPECIAL
08268 5-    THEN BEGIN
08269 --      TOP := ELIMIT - 1 ;
08270 --      LOSS(TOP) := -NINES - 1 ;
08271 -5    END ELSE EPLIST(ELIMIT) := TT ;
08272 --    CAPT_CH := FALSE ;
08273 --    FIRST := LOSS(EPLIST(1)) ;
08274 --    SECOND := IF EPL > 1
08275 --              THEN LOSS(EPLIST(2))
08276 --              ELSE 0 ;
08277 --    THIRD := IF EPL > 2
08278 --             THEN LOSS(EPLIST(3))
08279 --             ELSE 0 ;
08280 --    EXTRALOSS := EPL > 1 AND SECOND > 0 AND FIRST > 0 ;
08281 --    IF TT < ELIMIT - 1
08282 --    THEN SSQA := SQUARE(EPLIST(ELIMIT-2)) ;
08283 --    IF CON(K,SSQA) = 0
08284 --    THEN SSQA := HOLE ;
08285 --    II := TT ;
08286 --    WHILE II < ELIMIT
08287 5-    DO BEGIN
08288 --      I := EPLIST(II) ;
08289 --      II := II + 1 ;
08290 --                          COMMENT SQA contains opponent piece.  If SPECIAL, no
08291 --                                  opponent losses.  therefore EPSCORE = 0 ;
08292 --      SQAA := SQA := SQSAVE := SQUARE(I) ;
08293 --      LOSSES := LOSS(I) ;
08294 --      IF LOSSES = -1
08295 --      THEN LOSSES := 0 ;
08296 --                          COMMENT still enprise ;
08297 --  
08298 --      PCASAVE := PCA := ABS(BRD(SQA)) ;
08299 --      COST := NINES ;
08300 --      JJ := 0 ;
08301 --      EP := THIRD ;
08302 --      IF (EP < DELTA)
08303 --      THEN EP := 0 ;
08304 --      SQ := EPSQR ;
08305 --      ADD := CHK := CAPTURE := T := FALSE ;
08306 --      ANALYSE ;
08307 --      SC := COST + EP ;
08308 --      NEW := COST ;
08309 --      OLD := SCR ;
08310 --      FRESH := SQ ~= EPSQR AND EP > 0 OR SSQA ~= SQAA AND SC > 0
08311 --                OR SQAA = HOLE ;
08312 --      IF DEBUG
08313 --      THEN WRITE("COST", SC, EP, ENPR, SEC_EP, SQ, COST, CAPT_CH,
08314 --                 ADD, SQAA, SSQA, SQS, NEW, OLD, CHK, CAPTURE, PCAA) ;
08315 --      E1 := ~CAPTURE OR SQ ~= EPSQR OR EP <= 0 OR SCR < -SEVENS
08316 --               OR ABS(NEW - OLD) >= DELTA OR SQAA = HOLE ;
08317 --      E2 := E1 AND COST < NINES AND (~GIVINGCH OR SCR < -SEVENS
08318 --                 OR GIVINGCH AND SQ ~= KINGATTACKER OR SQAA = KSQ OR EP < 0
08319 --                 OR T OR ~DOUBLECH AND SQ = KINGATTACKER) ;
08320 --      E3 := E2 AND ~CAPT_CH AND NEW >= OLD + DELTA AND (SCR = -NINES
08321 --               OR SSQA ~= SQAA OR SSQA ~= HOLE AND SQ ~= HOLE
08322 --               AND (SQ ~= EPSQR OR ABS(CON(KK,SQ)) <= 1 OR ABS(SEC(0,SQ)) = 1
08323 --               AND (ABS(BRD(CONTROL(SQ,KK))) = KING
08324 --                  OR ABS(BRD(CONTROL(SQ,KK+KK))) = KING))) ;
08325 --      E4 := E2 AND FRESH AND ~CAPT_CH AND ABS(NEW-OLD) < DELTA
08326 --               AND (EP < ENPR OR CHK OR COST = -EIGHTS) ;
08327 --      E5 := E2 AND NEW <= OLD-DELTA AND (ADD OR CAPTURE
08328 --               AND (SSQA ~= SQAA AND SQAA ~= HOLE OR SQ ~= EPSQR
08329 --               AND EPSQR = HOLE AND SSQA = SQAA)) ;
08330 --      IF E2 AND DEBUG
08331 --      THEN WRITEON(E3, E4, E5) ;
08332 --                     COMMENT ensure that better capture on SQT not already found ;
08333 --      IF EPSCORE = -NINES
08334 --      THEN SQS := SSQA ;
08335 --                   COMMENT if (sc = -eights) then opponent has a safe recapture
08336 --                           without loss. If scr > -nines then this is not the
08337 --                           first exchange by the opponent.
08338 --                           if (enpr < ep) better exchange perhaps? ;
08339 --      IF E1 AND E2
08340 --      THEN IF E3 OR E4 OR E5
08341 6-           THEN BEGIN
08342 --             IF GIVINGCH OR SQAA ~= SSQA
08343 7-             THEN BEGIN
08344 --               EPSCORE := SCR ;
08345 --               EPSQ2 := IF PASS1
08346 --                        THEN SQ
08347 --                        ELSE EPSQR ;
08348 --               SQS := SSQA ;
08349 --               IF ~PASS1
08350 --               THEN SEC_EP := ENPR ;
08351 -7             END ;
08352 --             PASS1 := FALSE ;
08353 --             IF ADD
08354 --             THEN CAPT_CH := TRUE ;
08355 --             SCR := COST ;
08356 --             IF E5 OR SQAA ~= HOLE
08357 --             THEN SSQA := SQAA ;
08358 --             PPCA := IF CAPTURE
08359 --                     THEN PCAA
08360 --                     ELSE EDGE ;
08361 --             ENPR := EP ;
08362 --                        COMMENT ENPSEC := SPAR1 ;
08363 --             EPSQR := SQ ;
08364 --                        COMMENT IF DEBUG THEN WRITEON(PPCA, SCR, SPAR1) ;
08365 -6      END ELSE IF (COST > EPSCORE) AND FRESH
08366 6-               THEN BEGIN
08367 --                 EPSCORE := COST ;
08368 --                 EPSQ2 := EPSQR ;
08369 --                 SEC_EP := EP ;
08370 --              IF SQAA ~= SSQA THEN
08371 --                 SQS := SQAA ;
08372 -6      END ;
08373 --      IF DEBUG THEN WRITEON(SSQA, SQS) ;
08374 -5    END ;
08375 --    IF SPECIAL OR SSQA = HOLE
08376 --    THEN EPSCORE := 0
08377 --    ELSE IF SSQA < WQRSQ OR SSQA > BKRSQ or brd(ssqa) = edge
08378 --         THEN WRITE("WHAT", SSQA, SQAA, SCR, EPSCORE, EPSQR, ENPR)
08379 --         ELSE PINTRAP ;
08380 --    TMP := IF EPSQR = HOLE
08381 --           THEN 0
08382 --           ELSE KK*CHECK_S(KK,EPSQR) ;
08383 --    IF ~TRAPPED AND EPSCORE > 0 AND (M4 ~= KING) AND (TMP > 0)
08384 --    THEN FOR I := CON(-K,EPSQR) STEP K UNTIL -K
08385 5-         DO BEGIN
08386 --           PC := ABS(BRD(CONTROL(EPSQR,I))) ;
08387 --           IF CHEC(TMP, PC)
08388 --           THEN EPSCORE := EPSCORE DIV 2 ;
08389 -5    END ;
08390 --              COMMENT if material is recaptured with check, do not count epscore ;
08391 --    IF EPSCORE < -DELTA
08392 --    THEN EPSCORE := EPSCORE + ENPR ;
08393 --    IF (EPSCORE <= - DELTA)
08394 --    THEN EPSCORE := 0 ;
08395 --    IF EPSCORE >= PVAL OR GIVINGCH
08396 --    THEN EPSCORE := EPSCORE -ENPSEC ;
08397 --    IF DEBUG
08398 --    THEN WRITE(EPLIST(0)) ;
08399 --    IF DEBUG
08400 --    THEN FOR J := 1 UNTIL EPL
08401 --         DO WRITEON("   ", BOX(SQUARE(EPLIST(J)))) ;
08402 --    IF DEBUG
08403 --    THEN FOR II := TT UNTIL ELIMIT-1
08404 5-         DO BEGIN
08405 --           IOCONTROL(2) ;
08406 --           I := EPLIST(II) ;
08407 --           WRITE("  ", BOX(SQUARE(I)), "  ") ;
08408 --           FOR J := 1 UNTIL EPL
08409 --           DO WRITEON(SQAXSQT(I,J)) ;
08410 --           FOR J := 1 UNTIL EPL
08411 --           DO WRITEON(SQTXSQA(J,I)) ;
08412 -5    END ;
08413 --    IF ~TRAPPED AND ENPR > 0 AND EPSCORE >= ENPR AND G2 > DELTA
08414 5-    THEN BEGIN
08415 --      TRAPPED := TRUE ;
08416 --      EPSCORE := IF ENPR > G2
08417 --                 THEN ENPR
08418 --                 ELSE G2 ;
08419 -5    END ;
08420 --    IF EPSCORE < DELTA AND G3 > DELTA
08421 --    THEN EPSCORE := EPSCORE + G3 ;
08422 --           COMMENT really dealing with a generalized fork, in which the opponent
08423 --                   has two or more pieces under attack. A defence is to move one
08424 --                  piece to block the attack on another (typically to blockcheck) ;
08425 --           COMMENT What about enpris loss?  For example, if ENPR loss exists
08426 --                  and EPGAIN is possible, then should make move which produces the
08427 --                  loss and see if a subsequent loss is likely. If so, mark the
08428 --                  position as highly non-quiescent ;
08429 --    IF DEBUG
08430 --    THEN WRITE(".", EPSQR, ENPR, SQ, TRAPPED, PIN, PPCA, EXTRALOSS,
08431 --               ENPSEC, EPSCORE, G1, G2, G3, FIRST, SECOND, THIRD) ;
08432 --    FOR I := 1 UNTIL EPL
08433 --    DO IF ~FORCING AND LOSS(EPLIST(I)) > 0
08434 5-       THEN begin
08435 --         FORCING := CAPTURE_CH(SQUARE(EPLIST(I))) ;
08436 -5    end ;
08437 --    EXCHANGE := FIRST > -DELTA ; comment is approx. equal exchange possible? ;
08438 --    IF ~FORCING AND G2 > DELTA AND EXCHANGE
08439 --    THEN FORCING := TRUE ;
08440 --    EPSCORE
08441 -4  END OF_EP_SCORE ;
08442 --  
08443 --  PROCEDURE SCOREMOVE ;
08444 --  COMMENT   generates ocon, ccon, onum, cnum etc as output ;
08445 4-  BEGIN
08446 --    INTEGER I, J, PC, KK, VAL, PC3, SQ3, SQA, PCA, INC, NA, ND, K1 ;
08447 --    INTEGER SAC_SQ, OLD_ATTA, ATTA_SQ, SQ2, PK, KSQ, K_SQ ;
08448 --    LOGICAL OPPOSITION ;
08449 --  
08450 --    INTEGER PROCEDURE MATE_POT (INTEGER VALUE KK, K, PK, SQA) ;
08451 5-    BEGIN
08452 --      INTEGER S, PC, TMP, SQ3, PCA ;
08453 --  
08454 --      S := 0 ;
08455 --      IF PK <= 3
08456 --      THEN
08457 --      IF PIECES(K*QUEEN) > 0 OR PK < 3 AND PIECES(K*ROOK) > 0
08458 6-      THEN BEGIN
08459 --        PCA := K*BRD(SQA) ;
08460 --        TMP := K*CHECK_S(-K,SQA) ;
08461 --        IF GIVINGCH AND KK = 0 AND PCA > 0
08462 --        THEN KK := 1 ;
08463 --        FOR I := K STEP K UNTIL CON(K,SQA)
08464 7-        DO BEGIN
08465 --          SQ3 := CONTROL(SQA,I) ;
08466 --          PC := ABS(BRD(SQ3)) ;
08467 --                     COMMENT WRITE("MATE_P ", SQA, PCA, TMP, K, SQ3, SAC_SQ,KK) ;
08468 --          IF SQ3 ~= SAC_SQ
08469 --          THEN IF KK > 0 OR GIVINGCH AND KK = 0 OR PC > BISHOP
08470 --                   AND HIDDEN(SQA, SQ3, SQ3, K, FALSE)
08471 --               THEN IF TMP > 0 AND CHEC(TMP, PC) OR GIVINGCH AND PCA >= ROOK
08472 --                    THEN S := S + (IF PK = 0 AND (KK > 0 OR ~GIVINGCH)
08473 --                                   THEN 3
08474 --                                   ELSE IF PK <= 1
08475 --                                        THEN IF GIVINGCH AND KK = 0
08476 --                                             THEN (IF PCA = 0
08477 --                                                   THEN 2
08478 --                                                   ELSE 1)
08479 --                                             ELSE IF PC = QUEEN
08480 --                                                  THEN 3
08481 --                                                  ELSE IF PCA >= ROOK
08482 --                                                       THEN 4
08483 --                                                       ELSE 2
08484 --                                         ELSE IF PC = QUEEN
08485 --                                              THEN 2
08486 --                                              ELSE 1) ;
08487 --          IF DEBUG AND S > 0
08488 --          THEN WRITE("MATE_POT", S, PK, SQ3, SQA, TMP, PC, PCA) ;
08489 -7        END ;
08490 -6      END ;
08491 --      S
08492 -5    END OF_MATE_POT ;
08493 --  
08494 --  @TITLE, "SCOREMOVE"
08495 --  
08496 --    IF EXCHANGE AND ENPR > -DELTA AND (EPGAIN < ENPR + DELTA)
08497 --    THEN SAC_SQ := IF (ABS(BRD(EPSQ)) = ENPRIS)
08498 --                   THEN EPSQ + K_FILE
08499 --                   ELSE EPSQ
08500 --    ELSE SAC_SQ := ATTA_SQ := HOLE ;
08501 --    IF SAC_SQ ~= HOLE
08502 5-    THEN BEGIN
08503 --      PC := KING ; ATTA_SQ := HOLE ;
08504 --      FOR I := -K STEP -K UNTIL CON(-K,SAC_SQ)
08505 6-      DO BEGIN
08506 --        SQ3 := CONTROL(SAC_SQ,I) ;
08507 --        IF PC > ABS(BRD(SQ3))
08508 7-        THEN BEGIN
08509 --          PC := ABS(BRD(SQ3)) ;
08510 --          ATTA_SQ := SQ3 ;
08511 -7        END ;
08512 -6      END ;
08513 -5    END
08514 --    ELSE IF TRAPPED
08515 --         THEN ATTA_SQ := SSQA ;
08516 --    ASCORE := DSCORE := PSCORE := 0 ;
08517 --    PONENT := IF PIECES(-K*QUEEN) = 0
08518 --              THEN 0
08519 --              ELSE 1 ;
08520 --    DISC_ATTA := FALSE ;
08521 --    IF (DEBUG)
08522 --    THEN WRITE("ATTA", SAC_SQ, ATTA_SQ, EPSQ, BRD(EPSQ)) ;
08523 --    OCON := CCON := CNUM := 1 ;
08524 --    ONUM := ABS(PONENT-1) ;
08525 --    FOR CSQ := WQRSQ UNTIL BKRSQ
08526 --    DO IF BRD(CSQ) ~= EDGE
08527 5-       THEN BEGIN
08528 --                     COMMENT in endgame, only give credit for control of contested
08529 --                             squares ;
08530 --         KK := K*SEC(0,CSQ) ;
08531 --         IF KK ~= 0
08532 --         THEN KK := IF KK > 0
08533 --                    THEN 1
08534 --                    ELSE -1 ;
08535 --         NA := CON(K,CSQ) ;
08536 --         ND := CON(-K,CSQ) ;
08537 --                 COMMENT IF ~ENDGAME
08538 --                         THEN PSCORE := PSCORE + KK*ABS(PAWNS(CSQ)) ;
08539 --         IF (NA ~= 0)
08540 --         THEN CCON := CCON + (IF ND ~= 0
08541 --                              THEN IF KK > 0
08542 --                                   THEN 2
08543 --                                   ELSE 1
08544 --                              ELSE IF ENDGAME
08545 --                                   THEN 0
08546 --                                   ELSE 1) ;
08547 --                       COMMENT extra credit for absolute control of contested square,
08548 --                               no credit in endgame for uncontested square ;
08549 --         IF (ND ~= 0)
08550 --         THEN OCON := OCON + (IF NA ~= 0
08551 --                              THEN IF KK < 0
08552 --                                   THEN 2
08553 --                                   ELSE 1
08554 --                              ELSE IF ENDGAME
08555 --                                   THEN 0
08556 --                                   ELSE 1) ;
08557 --         PC := BRD(CSQ) ;
08558 --         IF (PC ~= EMPTY)
08559 6-         THEN BEGIN
08560 --           OLD_ATTA := ASCORE ;
08561 --           KK := IF (PC > 0)
08562 --                 THEN 1
08563 --                 ELSE -1 ;
08564 --           IF ~ENDGAME
08565 --           THEN PSCORE := PSCORE + KK*ABS(PAWNS(CSQ)) ;
08566 --           PC := ABS(PC) ;
08567 --           VAL := A_VAL(PC) ;
08568 --           IF (PC = PAWN)
08569 7-           THEN BEGIN
08570 --             IF (RANKS(ROWS(CSQ)) = KK)
08571 --             THEN VAL := VAL + PAWNVAL(ROWS(CSQ)) ;
08572 --             IF VAL > PVAL
08573 --             THEN VAL := VAL + PASSEDPAWN(CSQ,KK) ;
08574 -7           END ;
08575 --           IF K = KK
08576 7-           THEN BEGIN
08577 --             J := NA ;
08578 --             NA := ND ;
08579 --             ND := J ;
08580 --             IF NA ~= 0
08581 --             THEN IF ABS(NA)<= ABS(ND) AND CONTROL(CSQ,NA) = KINGSQ(-K)
08582 --                  THEN NA := NA + K
08583 --                  ELSE IF ABS(ND) = 1 AND ~GIVINGCH
08584 8-                       THEN BEGIN
08585 --                         PC3 := BRD(CONTROL(CSQ,ND)) ;
08586 --                         IF (ABS(PC3) = PAWN) AND (PC3 = BRD(CSQ+K_FILE)
08587 --                              OR PC3 = BRD(SQ-K_FILE))
08588 --                            AND VAL > A_VAL(ABS(BRD(CONTROL(CSQ,NA)))) -DELTA
08589 --                         THEN GAINS := GAINS - 1 ;
08590 --                              COMMENT penalty for leaving double
08591 --                                          pawn potential ;
08592 -8             END ;
08593 -7           END ;
08594 --           IF ABS(NA) > ABS(ND) + 1
08595 --           THEN NA := -ND - KK ;
08596 --           IF (PC ~= KING) AND (NA ~= 0)
08597 --           THEN DSCORE := DSCORE + (IF (ABS(ND) > ABS(NA))
08598 --                                    THEN -NA
08599 --                                    ELSE ND)*VAL ;
08600 --                          COMMENT no credit for defending king or un-attacked
08601 --                                      piece ;
08602 --           INC := IF ENDGAME
08603 --                  THEN LIM-POSITION(CSQ,LIM)
08604 --                  ELSE 0 ;
08605 --                                COMMENT do not expose Queen to early danger ;
08606 --                          COMMENT IF EARLY AND PC = QUEEN AND KK = K AND NA ~= 0
08607 --                                  THEN PSCORE := PSCORE - K*SCALE ;
08608 --           IF (PC ~= QUEEN)
08609 --           THEN IF (KK = K)
08610 --                THEN CNUM := CNUM + POS(CSQ) + INC
08611 7-                ELSE BEGIN
08612 --                  ONUM := ONUM + INC ;
08613 --                  PONENT := PONENT + POS(CSQ) ;
08614 -7                END ;
08615 --                          COMMENT do not credit single King attack on defended piece ;
08616 --           IF (CSQ ~= ATTA_SQ) AND NA ~= 0
08617 --           THEN ASCORE := ASCORE
08618 --                            - (IF ABS(ND) >= ABS(NA)
08619 --                               THEN KK
08620 --                               ELSE
08621 --                               IF ABS(NA) > 1
08622 --                               THEN KK + KK
08623 --                               ELSE
08624 --                               IF ND = 0 OR KINGSQ(-KK) ~= CONTROL(CSQ,NA)
08625 --                                    OR K ~= KK AND (~INCHECK OR ~GIVINGCH)
08626 --                               THEN KK
08627 --                               ELSE 0)*VAL ;
08628 --           FOR J := CON(-1,CSQ) UNTIL CON(1,CSQ)
08629 --           DO IF J ~= 0
08630 7-              THEN BEGIN
08631 --                K1 := IF J > 0
08632 --                      THEN 1
08633 --                      ELSE -1 ;
08634 --                IF (~GIVINGCH OR (K = K1))
08635 8-                THEN BEGIN
08636 --                              COMMENT try to give credit for the attacking value
08637 --                                            of a pin ;
08638 --                              COMMENT no credit for hidden counter- attack when in check ;
08639 --                  SQA := CONTROL(CSQ,J) ;
08640 --                  PCA := BRD(SQA) ;
08641 --                  IF (ABS(PCA) > KNIGHT) AND (ABS(PCA) < KING)
08642 9-                  THEN BEGIN
08643 --                    DIR := BOTV(EDGE, OFFSET(SQA)-OFFSET(CSQ)) ;
08644 --                    SQ3 := CSQ + DIR ;
08645 --                    WHILE (BRD(SQ3) = 0)
08646 --                    DO SQ3 := SQ3 + DIR ;
08647 --                    PC3 := BRD(SQ3) ;
08648 --                    IF (PC3 ~= EDGE) AND SQ3 ~= ATTA_SQ
08649 --                        AND (PC3*PCA < 0)
08650 10-                   THEN BEGIN
08651 --                      PC3 := ABS(PC3) ;
08652 --                      SQ2 := CSQ + FILES(KK) ;
08653 --                      IND_ATTA := PC ~= PAWN OR ABS(DIR) ~= FILE AND BRD(SQ2) = 0
08654 --                                  OR ABS(DIR) = FILE
08655 --                                   AND (BRD(SQ2+1)*KK < 0 AND BRD(SQ2+1) ~= EDGE
08656 --                                   OR BRD(SQ2-1)*KK < 0 AND BRD(SQ2-1) ~= EDGE) ;
08657 --                      IF IND_ATTA AND PC3 = KING AND KK ~= K
08658 --                      THEN IF K1 = KK
08659 --                           THEN DISC_ATTA := TRUE ;
08660 --                      IF (PC3 = KING) AND (PC ~= QUEEN) AND (KK ~= K)
08661 --                      THEN PONENT := PONENT - POS(CSQ) DIV 2 ;
08662 --                      SQ2 := CSQ + FILES(KK) ;
08663 --                      ASCORE := ASCORE
08664 --                                 + K1* (IF IND_ATTA
08665 --                                        THEN (IF PC3 = KING
08666 --                                              THEN IF K ~= K1
08667 --                                                   THEN IF KK ~= K1
08668 --                                                        THEN 15
08669 --                                                        ELSE 50
08670 --                                                   ELSE IF KK ~= K1
08671 --                                                        THEN 10
08672 --                                                        ELSE 25
08673 --                                              ELSE A_VAL(PC3) DIV 2)
08674 --                                        ELSE IF PC3 ~= KING OR K1 = KK
08675 --                                             THEN 0
08676 --                                             ELSE A_VAL(PAWN)) ;
08677 -10                   END ;
08678 -9                  END ;
08679 --                  PCA := ABS(PCA) ;
08680 --                  IF (K1 ~= KK) AND (PC ~= KING) AND (PCA ~= KING
08681 --                      OR ND = 0) AND (CSQ ~= SAC_SQ) AND (A_VAL(PCA) <= VAL-DELTA
08682 --                      OR ND = 0 AND ~HIDDEN(CSQ, SQA, SQ3, KK, FALSE))
08683 --                  THEN ASCORE := ASCORE - KK*(IF ND = 0
08684 --                        THEN VAL DIV 2
08685 --                        ELSE VAL-A_VAL(PCA)) ;
08686 --                               COMMENT give extra credit for attacking greater
08687 --                                       or undefended piece ;
08688 -8                END ;
08689 -7           END ;
08690 --           IF (DEBUG) AND OLD_ATTA ~= ASCORE
08691 --           THEN WRITEON(CSQ, ASCORE, DSCORE, PSCORE) ;
08692 -6         END ;
08693 --                  COMMENT   THEN WRITE("OCON CCON ", CSQ, OCON, CCON, ONUM, CNUM, PONENT) ;
08694 -5    END ;
08695 --    ONUM := ONUM + PONENT ;
08696 --    MATE_P(1) := MATE_P(-1) := 0 ;
08697 --    K_SQ := KINGSQ(K) ;
08698 --    PK := POS(K_SQ) ;
08699 --    FOR J := K_SQRS(K) STEP -K UNTIL K
08700 5-    DO BEGIN
08701 --      SQA := KSQRS(J) ;
08702 --      KK := K*SEC(0,SQA) ;
08703 --      IF CON(-K,SQA) = 0
08704 --      THEN CCON := CCON + (IF ~ENDGAME OR BRD(SQA) = 0
08705 --                           THEN 1 ELSE 0)
08706 6-      ELSE IF ENDGAME THEN BEGIN
08707 --         IF KK <= 0
08708 --         THEN CCON := CCON + (IF KK = 0 THEN 2 ELSE 1) ;
08709 --                          COMMENT in endgame, make King aggressive. Encourage
08710 --                                  opposition and use King as an attacking piece ;
08711 --         OCON := OCON - (IF KK < 0 THEN 2 ELSE 1) ;
08712 -6      END ELSE IF (KK < 0 OR INCHECK AND KK = 0)
08713 --               THEN CCON := CCON - 1 ;
08714 --                       COMMENT  above undoes OCON credits assigned earlier ;
08715 --      IF ~GIVINGCH AND KK < 0 AND ABS(CON(K,SQA)) = 1
08716 --      THEN MATE_P(-K) := MATE_P(-K) - MATE_POT(-KK, -K, PK, SQA) ;
08717 --                 COMMENT  THEN WRITE("OCON CCON ", SQA, OCON, CCON, ONUM, CNUM) ;
08718 -5    END ;
08719 --    KSQ := KINGSQ(-K) ;
08720 --    PK := POS(KSQ) ;
08721 --    OPPOSITION := BOTV(KING, OFFSET(K_SQ)-OFFSET(KSQ)) = 2 ;
08722 --    FOR J := K_SQRS(-K) STEP K UNTIL -K
08723 5-    DO BEGIN
08724 --      SQA := KSQRS(J) ;
08725 --      KK := K*SEC(0,SQA) ;
08726 --      IF CON(K,SQA) = 0
08727 --      THEN OCON := OCON + (IF ENDGAME AND BRD(SQA) ~= 0
08728 --                           THEN 0
08729 --                           ELSE 1)
08730 --      ELSE IF ENDGAME AND KK = 0
08731 --           THEN OCON := OCON + 1
08732 --           ELSE IF ~OPPOSITION OR
08733 --                   BOTV(KING, OFFSET(K_SQ)-OFFSET(SQA)) ~= 1
08734 --                THEN IF (KK > 0 OR KK = 0 AND GIVINGCH)
08735 --                     THEN OCON := OCON - 1 ;
08736 --                          COMMENT in the above engame mode, OCON not decremented
08737 --                                  in region of overlapping King domains (since done) ;
08738 --                      COMMENT WRITE("SCORE ", KK, PK, SQA, CON(-K,SQA), CON(K,SQA)) ;
08739 --      IF ~INCHECK AND KK > 0 AND ABS(CON(-K,SQA)) = 1
08740 --      THEN MATE_P(K) := MATE_P(K) + MATE_POT(KK, K, PK, SQA) ;
08741 --                      COMMENT  THEN WRITE("OCON CCON ", SQA, OCON, CCON, ONUM, CNUM) ;
08742 -5    END ;
08743 --                       COMMENT compute King opposition credit ;
08744 --                       COMMENT or passed pawn blockage credit ;
08745 --    SQ3 := IF CLEARPAWN(-K) ~= KSQ
08746 --           THEN IF K_SQ = CLEARPAWN(-K)
08747 --                THEN K_SQ
08748 --                ELSE CLEARPAWN(-K) - FILES(K)
08749 --           ELSE IF BASE ~= CLEARPAWN(K)
08750 --                THEN CLEARPAWN(K)
08751 --                ELSE KSQ ;
08752 --    CCON := CCON + (IF ~KINGMOVING
08753 --                    THEN CLEARPAWN(0)
08754 --                    ELSE POTENTIAL(K_SQ, SQ3, K_SQ = CLEARPAWN(-K))) ;
08755 --                 COMMENT  THEN WRITE("OCON CCON ", SQA, OCON, CCON, ONUM, CNUM) ;
08756 --    IF SAC_SQ ~= HOLE
08757 5-    THEN BEGIN
08758 --                        COMMENT no attackscore for sacrificed piece ;
08759 --      IF ENPR > DELTA AND (ABS(BRD(SAC_SQ)) ~= QUEEN)
08760 --      THEN CNUM := CNUM - POS(SAC_SQ) ;
08761 --      J := POS(SAC_SQ) ;
08762 --                          COMMENT Note SAC_SQ may contain a Pawn, but not King ;
08763 --      FOR IX := 1 UNTIL J
08764 --      DO CHECKLIST(IX) := POSITION(SAC_SQ,IX) ;
08765 --      FOR IX := POSITION(SAC_SQ,LIM) UNTIL LIM-1
08766 6-      DO BEGIN
08767 --        J := J + 1 ;
08768 --        CHECKLIST(J) := POSITION(SAC_SQ,IX) ;
08769 -6      END ;
08770 --      FOR IX := 1 UNTIL J
08771 6-      DO BEGIN
08772 --        I := CHECKLIST(IX) ;
08773 --        IF ENPR > DELTA
08774 --        THEN IF (SEC(0,I) = K) AND (~ENDGAME OR (CON(-K,I) ~= 0))
08775 --             THEN CCON := CCON - 1
08776 --             ELSE IF (SEC(0,I) = 0)
08777 --                  THEN OCON := OCON + 1 ;
08778 --        PC := BRD(I) ;
08779 --        IF (PC*K < 0)
08780 --        THEN ASCORE := ASCORE - K*A_VAL(ABS(PC)) ;
08781 --                       COMMENT ignore defended squares ;
08782 --                  COMMENT WRITE("OCON CCON ", I, OCON, CCON, ONUM, CNUM) ;
08783 -6      END ;
08784 --      ASCORE := ASCORE - (-K)*A_VAL(ABS(BRD(SAC_SQ))) ;
08785 -5    END ;
08786 --                  COMMENT WRITE("OCON CCON ", SAC_SQ, OCON, CCON, ONUM, CNUM) ;
08787 --    IF DISC_ATTA
08788 --    THEN GAINS := GAINS - 2 ;
08789 --    IF ONUM <= 0 OR OCON <= 0 OR CNUM <= 0 OR CCON <= 0
08790 5-    THEN BEGIN
08791 --      WRITE("PROBLEMS", ONUM, OCON, CNUM, CCON) ;
08792 --      TRACER(1, "?P") ;
08793 --    IF OCON < 1 THEN OCON := 1 ;
08794 -5    END ;
08795 -4  END OF_SCOREMOVE ;
08796 --  
08797 --  PROCEDURE TRYTHEM ;
08798 4-  BEGIN
08799 --    LOGICAL NOWIN ;
08800 --  
08801 --    NOWIN := LATE_END AND (MEN(K) = 1 OR MEN(K) = 2
08802 --               AND PIECES(KNIGHT*K) + PIECES(BISHOP*K) = 1) ;
08803 --    IP := NN ;
08804 --    WHILE IP ~= 0
08805 5-    DO BEGIN
08806 --      N := USE(ABS(IP)) ;
08807 --      SQ := MOVETO(N) ;
08808 --      LEGALMV := FORCING := FALSE ;
08809 --      IF ~ INCHECK
08810 --      THEN LEGALMV := TRUE
08811 --      ELSE IF ~ DBLCHECK
08812 --           THEN FOR JJ := KINGSQU+SAVEB STEP SAVEB UNTIL CHECKSQ
08813 --                DO IF (SQ = JJ)
08814 --                   THEN LEGALMV := TRUE ;
08815 --      MF := MOVEFROM(N) ;
08816 --      IF REMEMBER
08817 6-      THEN BEGIN
08818 --        LSAVE := SQUARE(0) ;
08819 --        ESAVE := SQUARE(ELIMIT) ;
08820 -6      END ;
08821 --      REWARDN := ABS(REWARD(N)) ;
08822 --      IF ~LEGALMV AND (REWARDN = ENPRIS)
08823 --      THEN IF (SQ = CHECKSQ + K_FILE)
08824 --           THEN LEGALMV := TRUE ;
08825 --      IF (TERMINAL)
08826 --      THEN BASE := MF
08827 --      ELSE MOVEFROM(N) := LAST_SQ ;
08828 --      NEXTSQ := MOVEFROM(USE(ABS(IP-K))) ;
08829 --      IF ~ INCHECK
08830 --      THEN TERMINAL := IF (BASE ~= NEXTSQ) OR (REWARDN ~= 0)
08831 --                       THEN TRUE
08832 --                       ELSE FALSE ;
08833 --      HIDDENLOSS(N, LSAVE, ESAVE) ;
08834 --                             COMMENT add hidden pieces to enprise list ;
08835 --      IF (BASE ~= NEXTSQ)
08836 --      THEN PPIN := FALSE ;
08837 --      IF (LEGALMV AND ~ PINNED) OR (ABS(BRD(LAST_SQ)) = KING)
08838 6-      THEN BEGIN
08839 --                          COMMENT no illegal king moves are generated ;
08840 --        LAST_SQ := SQ ;
08841 --        MADELEGAL := TRUE ;
08842 --        remember := terminal := true ;
08843 --        comment REMEMBER := TRUE ;
08844 --        MAKEMOVE(N, FALSE) ;
08845 --        MV := 0 ;
08846 --        KSQ := KINGSQ(-K) ;
08847 --        MATE := FALSE ;
08848 --        KINGATTACKER := IF ~GIVINGCH
08849 --                        THEN HOLE
08850 --                        ELSE CONTROL(KINGSQ(-K), K) ;
08851 --        PC := REWARDN ;
08852 --        IF (PC >= ENPRIS)
08853 --        THEN PC := PC -PROMOTE ;
08854 --        GAINS := IF (REWARDN > PFTWO)
08855 --                 THEN (IF PC = ROOK OR PC = BISHOP
08856 --                       THEN 0
08857 --                       ELSE VALUES(PC)) -PVAL - PVAL
08858 --                       ELSE IF (PC > NIL) AND (PC < KING)
08859 --                            THEN VALUES(PC)
08860 --                            ELSE 0 ;
08861 --        CAPT := GAINS ;
08862 --        IF (PROMCAPT > 0)
08863 --        THEN GAINS := GAINS + VALUES(PROMCAPT) ;
08864 --        PC := ABS(BRD(SQ)) ;
08865 --        KINGMOVING := IF (PC = KING)
08866 --                      THEN TRUE
08867 --                      ELSE FALSE ;
08868 --        MATE_P(1) := MATE_P(-1) := MATE_T(1) := MATE_T(-1) := 0 ;
08869 --        IF ~OPENING
08870 --        THEN MATE_THREAT ;
08871 --        TRAPPED := FALSE ;
08872 --        ENPRISLIST ;
08873 --        SCOREMOVE ;
08874 --        GAINS := GAINS + MATE_P(1) + MATE_P(-1) ;
08875 --        IF GIVINGCH AND (POS(KSQ) = 0)
08876 --        THEN CHECKER
08877 --        ELSE IF (PONENT = 0)
08878 --             THEN REWARD(N) := REWARDN + CHECKING ;
08879 --        IF (EPLIST(0) = 0)
08880 --        THEN EPSQ := HOLE ;
08881 --        IF (PC =PAWN) AND (PAWNS(SQ) = K)
08882 --        THEN CNUM := CNUM + 3*POS(SQ) ;
08883 --                          COMMENT promotion mobility credit ;
08884 --        SAMV := -DATUM + (DATUM*CNUM*CCON) DIV (ONUM*OCON) ;
08885 --        IF ENDGAME AND (SAMV > 450)
08886 --        THEN SAMV := 300 + SAMV DIV 4 ;
08887 --        IF (EPSQ = SQ) AND (PC = PAWN) AND (ENPR ~= PVAL)
08888 --        THEN ENPR := ENPR - 2 ;
08889 --        EP := IF ENPR > 0 AND GAINS + EPGAIN < ENPR + DELTA
08890 --                          AND LOSS(EPLIST(1)) > -DELTA
08891 --              THEN IF REALVAL < -DELTA
08892 --                   THEN IF REALVAL < -ENPR
08893 --                        THEN -ENPR DIV 4
08894 --                        ELSE REALVAL DIV 4
08895 --                   ELSE IF ONEVAL > DELTA
08896 --                        THEN IF ONEVAL > ENPR
08897 --                             THEN ENPR DIV 4
08898 --                             ELSE ONEVAL DIV 4
08899 --                        ELSE 0
08900 --              ELSE 0 ;
08901 --                      COMMENT penalize a sacrifice when down, encourage when ahead ;
08902 --        IF (ENPR = -1) AND ~TRAPPED AND ~GIVINGCH
08903 --        THEN IF (EPGAIN > 0)
08904 --             THEN EPGAIN := 0 ;
08905 --        IF (ENPR <= 0)
08906 --        THEN ENPR := 0 ;
08907 --        COMMENT
08908 --        ELSE IF ENPR = VALUES(BISHOP) AND EPGAIN < VALUES(BISHOP)
08909 --             THEN ENPR := VALUES(KNIGHT) ;
08910 --        SVMV := IF TRAPPED OR (ENPR < PVAL) OR REWARDN > PFTWO
08911 --                THEN ENPR
08912 --                ELSE IF CAPT = 0 AND CON(K,EPSQ) = 0
08913 --                     THEN ENPR - 1
08914 --                     ELSE ENPR - 2 ;
08915 --        TMP := IF SVMV > EPGAIN + DELTA OR PIN
08916 --               THEN EPGAIN
08917 --               ELSE IF ENPR <= 0 OR EPGAIN < ENPR -DELTA AND CAPT = 0
08918 --                    THEN (5*EPGAIN) DIV 7
08919 --                    ELSE IF EPGAIN < ENPR + DELTA AND CAPT = 0
08920 --                         THEN (9*ENPR) DIV 10
08921 --                         ELSE SVMV ;
08922 --                          COMMENT re-estimate epgain, preserve forks ;
08923 --        TMP := IF EPGAIN < -DELTA
08924 --               THEN 2*EPGAIN DIV 3
08925 --               ELSE
08926 --               IF EPGAIN < DELTA
08927 --               THEN 0
08928 --               ELSE IF GIVINGCH
08929 --                    THEN IF TRAPPED
08930 --                         THEN EPGAIN
08931 --                         ELSE (9*EPGAIN) DIV 10
08932 --                    ELSE IF TRAPPED
08933 --                         THEN IF (REWARDN > 0) AND (REWARDN ~= PFTWO)
08934 --                                  OR (EPGAIN - ENPR < VALUES(KNIGHT) -DELTA)
08935 --                              THEN EPGAIN
08936 --                              ELSE IF EPGAIN -ENPR > 40
08937 --                                   THEN 30
08938 --                                   ELSE EPGAIN - 2*PVAL DIV 3
08939 --                         ELSE IF (ENPR >= EPGAIN + DELTA)
08940 --                              THEN TMP
08941 --                              ELSE IF (ENPR ~= -1)
08942 --                                   THEN TMP
08943 --                                   ELSE IF (EPLIST(0) > 0)
08944 --                                        THEN EPGAIN DIV 3
08945 --                                        ELSE (2*EPGAIN) DIV 3 ;
08946 --        MATER := IF INCHECK AND (POS(KINGSQ(K)) = 0)
08947 --                     AND (GAINS < ENPR-DELTA)
08948 --                 THEN PVAL
08949 --                 ELSE 0 ;
08950 --        IF GIVINGCH AND ENPR = 0
08951 --        THEN IF POS(KINGSQ(-K)) <= 1
08952 --             THEN GAINS := GAINS + 1 ;
08953 --                            COMMENT forcing check ;
08954 --        IF DEBUG
08955 --        THEN WRITE("PARM", N, CAPT, CREDIT(LEVEL), GOODCASTLE, MV, GAINS, TMP, PC,
08956 --                   ONEVAL, EP, PROMCAPT, SVMV, MATER, BACKROW, MATE_P(1), MATE_T(1),
08957 --                   MATE_P(-1), MATE_T(-1), LAST_SQ, BASE, MF, NEXTSQ, SQ, DISC_ATTA)
08958 --         ;
08959 --                            COMMENT attempt to equalize losses if threatening mate ;
08960 --        IF MATE_P(K) >= 3 AND GAINS + TMP + BACKROW <= ENPR + MATER
08961 --            AND ~CAPT_CH
08962 --        THEN GAINS := SVMV + MATER - TMP - BACKROW + 2 ;
08963 --        SVMV := MV := SCALE*(MV+ GAINS + TMP + EP - SVMV + ONEVAL
08964 --                          - MATER + CREDIT(LEVEL) + BACKROW) ;
08965 --        ATTACKSCORE := K*ASCORE ;
08966 --        DEFENCESCORE := K*DSCORE ;
08967 --        PLACESCORE := K*PSCORE ;
08968 --        MV := MV + 4*ATTACKSCORE + 2*DEFENCESCORE + 3*PLACESCORE ;
08969 --        IF (DUMPP) OR TEST
08970 --        THEN COLLECTDATA ;
08971 --        MV := SAMV + MV ;
08972 --        IF REVERSIBLE
08973 --        THEN IF INCHECK OR GIVINGCH OR ENDGAME AND (PIECES(0) < 12)
08974 7-             THEN BEGIN
08975 --               HASH := -NEWHASH(BRD, K, KEY) ;
08976 --               TMP := 0 ;
08977 --               FOR J := 1 UNTIL ENDPLAY
08978 --               DO IF (HASH = REPEATS(J))
08979 --                  THEN TMP := TMP + 1 ;
08980 --               FOR J := 1 UNTIL LEVEL-1
08981 --               DO IF HASH = STACK_HASH(J)
08982 --                  THEN TMP := TMP + 1 ;
08983 --               IF TMP >= 1
08984 --               THEN MV := DRAW ;
08985 8-               IF TEST AND MV = DRAW THEN BEGIN
08986 --                 WRITE("CYCLE ", TMP, ENDPLAY, LEVEL, MV, HASH, K, ":" ) ;
08987 --                 FOR I := 1 UNTIL ENDPLAY
08988 --                 DO WRITEON(REPEATS(I)) ;
08989 --                 FOR I := 1 UNTIL LEVEL-1
08990 --                 DO WRITEON(STACK_HASH(I)) ;
08991 -8               END ;
08992 -7        END ;
08993 --        MV := IF (MV = BAD)
08994 --               THEN BAD + 2
08995 --               ELSE IF MATE
08996 --                    THEN NINES
08997 --                    ELSE IF ~GIVINGCH AND (PONENT = 0)
08998 --                         THEN DRAW
08999 --                         ELSE IF (MV > SEVENS)
09000 --                              THEN SEVENS - 7
09001 --                              ELSE MV ;
09002 --                    COMMENT if the moving piece does not capture, the concept of
09003 --                            an incremental move can be used to reduce the needless
09004 --                            referencing of takebackmove. ;
09005 --        IF (MV > BEST)
09006 --        THEN BEST := MV ;
09007 7-        IF NOWIN AND MV ~= DRAW THEN BEGIN
09008 --          MV := MV*DRAW DIV (IF BEST < DRAW THEN DRAW ELSE BEST) ;
09009 --          IF LEVEL > 1
09010 --          THEN MV := MV + CREDIT(LEVEL)*SCALE ;
09011 -7        END ;
09012 --        REWARDN := ABS(REWARD(N)) ;
09013 --        IF FALSE AND ~MATE AND ~CAPTURE_TREE
09014 --        THEN IF (REWARDN >= REALCHECK) AND (REWARDN < TWOCHECK)
09015 --             THEN IF (POS(KSQ) = 0) OR (ABS(CON(-K,EPSQ)) = 1)
09016 --                        AND (CONTROL(EPSQ,-K) = KSQ) AND ((CAPT > 0) OR (POS(KSQ) = 1))
09017 --                     OR GIVINGCH AND (POS(KSQ) <= 1)
09018 --                       AND (CON(-K,KINGATTACKER) = 0 OR (CONTROL(KINGATTACKER,-K) = KSQ
09019 --                       AND K*SEC(0,KINGATTACKER) >= 0) OR ~SACRIFICE(KINGATTACKER, FALSE))
09020 --                  THEN MV := -NINES-NINES +(MV DIV 10) ;
09021 --  
09022 --                    COMMENT two types of king check sacrifices are now detected.
09023 --                                (1).  King has no moves - common in back-rank mates.
09024 --                                (2).  King is forced to recapture (only move).
09025 --                                (3).  Cannot handle case in which loss occurs even if the
09026 --                                            King recaptures. ;
09027 --                    COMMENT forcing King to move, ignore blocks ;
09028 --  
09029 --        TMP := IF ABS(EPGAIN) > DELTA
09030 --                      AND (LEVEL < LENGTH OR ENPR > EPGAIN -DELTA OR TRAPPED OR PIN)
09031 --                  OR DISC_ATTA OR ABS(EPGAIN) > VALUES(BISHOP) OR FORCING
09032 --                  OR GIVINGCH
09033 --                     AND (DOUBLECH OR CON(K,KINGATTACKER) = 0
09034 --                     AND BOTV(KING, OFFSET(KINGSQ(-K))-OFFSET(KINGATTACKER)) = 2)
09035 --               THEN 6
09036 --               ELSE IF EPL > 1 AND LOSS(EPLIST(2)) > DELTA
09037 --                    THEN IF ENPR > -DELTA AND CAPT > DELTA
09038 --                         THEN 5
09039 --                         ELSE IF EPGAIN < -1
09040 --                              THEN 4
09041 --                              ELSE 3
09042 --                    ELSE IF POS(KINGSQ(K)) = 0
09043 --                         THEN 2
09044 --                         ELSE 0 ;
09045 --  
09046 --        IF DEBUG
09047 --        THEN WRITEON("*", TMP, CLEARPAWN(K), CLEARPAWN(-K), FORCING) ;
09048 --                          COMMENT later give special attention to disc. ch.
09049 --                                  and dbl. ch, and also to all forcing checks ;
09050 --        TMP := IF TMP > 4 OR ~OPENING AND BACKROW > 2
09051 --                  OR ABS(MATE_T(-K) + MATE_P(-K)) >= 3
09052 --                  OR GIVINGCH AND MATE_P(K) >= 3
09053 --               THEN 1
09054 --               ELSE 0 ;
09055 --        IF TMP > 0
09056 --        THEN REWARD(N) := IF (REWARDN = 0)
09057 --                          THEN -2
09058 --                          ELSE -REWARDN ;
09059 --                          COMMENT set reward(n) -ve to flag non-quiescent position ;
09060 -6      END ELSE
09061 6-      BEGIN
09062 --        MV := BAD ;
09063 --        NUM := NUM - 1 ;
09064 --        IF ~ MADELEGAL
09065 --        THEN LAST_SQ := MF ;
09066 --        TERMINAL := TRUE ;
09067 --        BASE := MF ;
09068 -6      END ;
09069 --      M2 := MOVEFROM(N) := MF ;
09070 --      SCORE(N) := MV ;
09071 --            COMMENT IF DUMPP THEN PRINTLINE(N, LEVEL) ;
09072 --            COMMENT IF DUMPP THEN WRITEON(GAINS, CREDIT(LEVEL), BACKROW) ;
09073 --      STOP := ~INCHECK AND TMP = 0 AND MV -LEVEL > UPPER
09074 --               AND MV ~= BAD AND PP_STATUS < 10 AND M14 = 0
09075 --               AND (~LATE_END OR REWARDN < CHECKING) AND 100*ABS(IP) > 5*ABS(NN) ;
09076 --      IF TERMINAL OR STOP
09077 6-      THEN BEGIN
09078 --                    COMMENT retract last legal move ;
09079 --        IF MADELEGAL
09080 7-        THEN BEGIN
09081 --          MADELEGAL := FALSE ;
09082 --          TAKEBACKMOVE(FALSE) ;
09083 -7        END ;
09084 --        REMEMBER := TRUE ;
09085 --        LAST_SQ := NEXTSQ ;
09086 -6      END ;
09087 --      IP := IP - K ;
09088 --      IF STOP
09089 6-      THEN BEGIN
09090 --        MV := NUM -ABS(IP) ;
09091 --        IP := 0 ;
09092 -6      END ;
09093 -5    END FORN ;
09094 -4  END OF_TRYTHEM ;
09095 --  
09096 --  @TITLE, "MOBILITY"
09097 --  
09098 --    I_W := 5 ;
09099 --             COMMENT PARTIAL_ORDER ;
09100 --    IF INCHECK
09101 4-    THEN BEGIN
09102 --      KINGSQU := KINGSQ(K) ;
09103 --      DIR := BOTV(EDGE, OFFSET(KINGSQU)-OFFSET(CHECKSQ)) ;
09104 --      SAVEB := IF (DIR = 0)
09105 --               THEN CHECKSQ - KINGSQU
09106 --               ELSE DIR ;
09107 --                               COMMENT knight attack ;
09108 --      IF DEBUG
09109 --      THEN WRITE("MOBI", KINGSQU, CHECKSQ, BRD(CHECKSQ), DIR, DBLCHECK) ;
09110 -4    END ;
09111 --              COMMENT IF ~INCHECK THEN CLEARPAWN(K) := KINGSQ(K) ;
09112 --    K_PAWN := K*PAWN ;
09113 --    K_FILE := FILES(K) ;
09114 --    KSQRS(0) := POTENTIAL(KINGSQ(K), KINGSQ(-K), FALSE) ;
09115 --    CLEARPAWN(0) := IF CLEARPAWN(-K) = KINGSQ(-K)
09116 --                    THEN KSQRS(0)
09117 --                    ELSE POTENTIAL(KINGSQ(K), CLEARPAWN(-K)-K_FILE,TRUE) ;
09118 --    MADELEGAL := PPIN := FALSE ;
09119 --    OLD_DIR := LASTDIR(LEVEL-2) ;
09120 --    OLD_DEST := LASTSQ(LEVEL-2) ;
09121 --    IF OLD_DIR = 0
09122 --    THEN OLD_DIR := -2 ;
09123 --    NN := NUMBER(K) ;
09124 --    TERMINAL := REMEMBER := TRUE ;
09125 --    MOVEFROM(0) := BASE := HOLE ;
09126 --    BEST := -NINES ;
09127 --    LAST_SQ := MOVEFROM(USE(ABS(NN))) ;
09128 --    IF TEST AND EXAMINE AND DUMPP
09129 --    THEN WRITE("    N   OCON   CCON   ONUM   CNUM ONEVAL GOODCA",
09130 --               " ATTACK DEFENCE    EP  GAINS  SAMV    ENPR EPGAIN  KINGCH  ",
09131 --               "SVMV  SCORE") ;
09132 --    TRYTHEM ;
09133 --    NEW := NEW + 1 ;
09134 --    BRAN := BRAN + NUM ;
09135 --    BRAN_S := BRAN_S + (IF STOP
09136 --                        THEN MV
09137 --                        ELSE NUM) ;
09138 --    NOD := NOD + 1 ;
09139 --    IF INCHECK
09140 --    THEN REMAKE(KINGSQ(K), KINGSQ(K)) ;
09141 --    IF UPPER ~= EIGHTS AND SCORE(USE(1)) ~= NOSCR
09142 --    THEN UPPER := EIGHTS ;
09143 -3  END OF_MOBILITYSCORE ;
09144 --  
09145 --  PROCEDURE RESTOREBACK (INTEGER VALUE LEVEL ; LOGICAL VALUE FLAG) ;
09146 --  
09147 3-  BEGIN
09148 --    INTEGER J, J1 ;
09149 --  
09150 --    IF FLAG
09151 4-    THEN BEGIN
09152 --      M2 := BACK(LEVEL,0) ;
09153 --      M3 := BACK(LEVEL,1) ;
09154 --      M7 := BACK(LEVEL,2) ;
09155 --      M8 := BACK(LEVEL,3) ;
09156 --      M9 := BACK(LEVEL,4) ;
09157 --      J := BACK(LEVEL,5) ;
09158 --      M14 := ABS(J) REM 100 ;
09159 --      M11 := ABS(J) DIV 100 ;
09160 --      IF J < 0
09161 --      THEN M14 := -M14 ;
09162 --      NUMB := BACK(LEVEL,6) ;
09163 --      M5 := BACK(LEVEL,7) ;
09164 --      J := 19 + NUMB ;
09165 --      FOR I := 0 UNTIL NUMB
09166 5-      DO BEGIN
09167 --        RLIST(I) := BACK(LEVEL,18+I) ;
09168 --        TLIST(I) := BACK(LEVEL,J+I) ;
09169 -5      END ;
09170 -4    END ;
09171 --    J := S_SIZE ;
09172 --    IF FLAG
09173 --    THEN FOR J1 := WQRSQ STEP FILE UNTIL BKRSQ
09174 --         DO FOR J2 := J1 UNTIL J1+7
09175 4-            DO BEGIN
09176 --              J := J + 1 ;
09177 --              BRD(J2) := BACK(LEVEL,J) ;
09178 -4    END ;
09179 --    J := 64 + S_SIZE ;
09180 --    KINGSQ(-K) := BACK(LEVEL,8) ;
09181 --    KINGSQ(K) := BACK(LEVEL,9) ;
09182 --    CLEARPAWN(-K) := BACK(LEVEL,10) ;
09183 --    CLEARPAWN(K) := BACK(LEVEL,11) ;
09184 --    DIFFVAL := BACK(LEVEL,12) ;
09185 --    ONEVAL := BACK(LEVEL,13) ;
09186 --    OLDSCR := BACK(LEVEL,14) ;
09187 --    PREVSCR := BACK(LEVEL,15) ;
09188 --    KTEST := BACK(LEVEL,16) ;
09189 --    NUM := BACK(LEVEL,17) ;
09190 --    INCHECK := IF (BACK(LEVEL,J+1) > 0)
09191 --               THEN TRUE
09192 --               ELSE FALSE ;
09193 --    CASTLE(K) := CASTLE(TWO(K)) := CASTLE(THREE(K)) := FALSE ;
09194 --    J1 := BACK(LEVEL,J+2) ;
09195 --    IF (J1 > 0)
09196 --    THEN CASE J1 OF
09197 4-    BEGIN
09198 --      CASTLE(K) := TRUE ;
09199 --      CASTLE(TWO(K)) := TRUE ;
09200 --      CASTLE(TWO(K)) := CASTLE(K) := TRUE ;
09201 --      CASTLE(THREE(K)) := TRUE ;
09202 -4    END ;
09203 --    J := J + 11 ;
09204 --           COMMENT j := j+2+9 ;
09205 --    FOR I := -8 UNTIL 8
09206 --    DO PIECES(I) := BACK(LEVEL,J+I) ;
09207 --    J := J + 9 ;
09208 --           COMMENT j := j+8+1 ;
09209 --    J1 := J + ELIMIT + 1 ;
09210 --    IF FLAG
09211 --    THEN FOR I := 0 UNTIL ELIMIT
09212 4-         DO BEGIN
09213 --           SQUARE(I) := BACK(LEVEL,J+I) ;
09214 --           LOSS(I) := BACK(LEVEL,J1+I) ;
09215 -4    END ;
09216 -3  END OF_RESTOREBACK ;
09217 --  
09218 --  PROCEDURE RESTORESTATE (INTEGER VALUE NODE) ;
09219 3-  BEGIN
09220 --    K := STATES(NODE,1) ;
09221 --    PLEX := STATES(NODE,2) ;
09222 --    CAPT_T := STATES(NODE,3) ;
09223 --    TOT_S := STATES(NODE,4) ; comment was TOT_S := NODETO(NODE,4) ;
09224 --    PART := STATES(NODE,5) ;
09225 --    A_SCR := STATES(NODE,6) ;
09226 --    UPPER := STATES(NODE,7) ;
09227 --    HASH := STATES(NODE,T_SIZE) ;
09228 --    RESTORE(NODE) ;
09229 --    if NODE < 0 then
09230 --       write("In RESTORESTATE node=-1", NODE, K, PLEX, TOT_S, PART) ;
09231 -3  END OF_RESTORESTATES ;
09232 --  
09233 --  PROCEDURE RESTORE (INTEGER VALUE NODE) ;
09234 3-  BEGIN
09235 --    INTEGER J, J1, J2, J3, J4, N, STATE ;
09236 --  
09237 --    TRY(0) := STATES(NODE,T_SIZE+1) ;
09238 --    TRY(WSIZE) := STATES(NODE,T_SIZE+2) REM 1000 ;
09239 --    NUM := STATES(NODE,T_SIZE+2) DIV 1000 ;
09240 --    FOR I := 1 UNTIL TRY(WSIZE)
09241 --    DO TRY(I) := (TOTAL-I)*K ;
09242 --    J := TRY(WSIZE) ;
09243 --    J1 := T_SIZE + 2 ;
09244 --    J2 := J1 + MAX_WID ;
09245 --    FOR I := 1 UNTIL J
09246 4-    DO BEGIN
09247 --      N := TRY(I) ;
09248 --      SCORE(N) := STATES(NODE,J1+I) ;
09249 --      STATE := STATES(NODE, J2+I) ;
09250 --      MOVEFROM(N) := ABS(STATE) REM 256 ;
09251 --      STATE := STATE DIV 256 ;
09252 --      MOVETO(N) := ABS(STATE) REM 256 ;
09253 --      STATE := STATE DIV 256 ;
09254 --      QUIES(N) := (ABS(STATE) REM 2) = 1 ;
09255 --      REWARD(N) := ABS(STATE) DIV 2 ;
09256 --      IF STATE < 0
09257 --      THEN REWARD(N) := -REWARD(N) ;
09258 --        COMMENT MOVEFROM(N) := STATES(NODE,J2+I) ;
09259 --        COMMENT MOVETO(N) := STATES(NODE,J3+I) ;
09260 --        COMMENT REWARD(N) := STATES(NODE,J4+I) ;
09261 -4    END ;
09262 -3  END OF_RESTORE ;
09263 --  
09264 --  PROCEDURE SAVEBACK (INTEGER VALUE LEVEL ; LOGICAL VALUE FLAG) ;
09265 3-  BEGIN
09266 --    INTEGER J, J1 ;
09267 --  
09268 --    IF FLAG
09269 4-    THEN BEGIN
09270 --      J := 100*M11 + ABS(M14) ;
09271 --      IF M14 < 0
09272 --      THEN J := -J ;
09273 --      FOR I := 1 UNTIL 8
09274 --      DO BACK(LEVEL,I-1) := CASE I OF (M2, M3, M7, M8, M9, J, NUMB, M5) ;
09275 --      J := 19 + NUMB ;
09276 --      FOR I := 0 UNTIL NUMB
09277 5-      DO BEGIN
09278 --        BACK(LEVEL,18+I) := RLIST(I) ;
09279 --        BACK(LEVEL,J+I) := TLIST(I) ;
09280 -5      END ;
09281 -4    END ;
09282 --    J := S_SIZE ;
09283 --    IF FLAG
09284 --    THEN FOR J1 := WQRSQ STEP FILE UNTIL BKRSQ
09285 --         DO FOR J2 := J1 UNTIL J1+7
09286 4-            DO BEGIN
09287 --              J := J + 1 ;
09288 --              BACK(LEVEL,J) := BRD(J2) ;
09289 -4    END ;
09290 --    IF ~FLAG
09291 --    THEN FOR I := 8 UNTIL 17
09292 --    DO BACK(LEVEL,I) := CASE I-7 OF (KINGSQ(-K), KINGSQ(K), CLEARPAWN(-K),
09293 --                        CLEARPAWN(K), DIFFVAL, ONEVAL, OLDSCR, PREVSCR, KTEST, NUM) ;
09294 --    J := S_SIZE + 64 ;
09295 --    IF ~FLAG
09296 --    THEN BACK(LEVEL,J+1) := IF INCHECK
09297 --                            THEN 1
09298 --                            ELSE 0 ;
09299 --    IF CASTLE(THREE(K))
09300 --    THEN J1 := 4
09301 4-    ELSE BEGIN
09302 --      J1 := 0 ;
09303 --      IF CASTLE(K)
09304 --      THEN J1 := J1 + 1 ;
09305 --      IF CASTLE(TWO(K))
09306 --      THEN J1 := J1 + 2 ;
09307 -4    END ;
09308 --    IF ~FLAG
09309 --    THEN BACK(LEVEL,J+2) := J1 ;
09310 --    J := J + 11 ;
09311 --                                COMMENT j := j+2+9 ;
09312 --    IF ~FLAG
09313 --    THEN FOR I := -8 UNTIL 8
09314 --         DO BACK(LEVEL,J+I) := PIECES(I) ;
09315 --    J := J + 9 ;
09316 --                                COMMENT j := j+8+1 ;
09317 --    J1 := J + ELIMIT + 1 ;
09318 --    IF FLAG
09319 --    THEN FOR I := 0 UNTIL ELIMIT
09320 4-         DO BEGIN
09321 --           BACK(LEVEL,J+I) := SQUARE(I) ;
09322 --           BACK(LEVEL,J1+I) := LOSS(I) ;
09323 -4    END ;
09324 -3  END OF_SAVEBACK ;
09325 --  
09326 --  PROCEDURE SAVESTATE (INTEGER VALUE NODE) ;
09327 3-  BEGIN
09328 --    if NODE < 0 then
09329 --       write("In SAVESTATE node=-1", NODE, K, PLEX, TOT_S, PART) ;
09330 --    STATES(NODE,1) := K ;
09331 --    STATES(NODE,2) := PLEX ;
09332 --    STATES(NODE,3) := CAPT_T ;
09333 --    STATES(NODE,4) := TOT_S ;
09334 --    STATES(NODE,5) := PART ;
09335 --    STATES(NODE,6) := A_SCR ;
09336 --    STATES(NODE,7) := UPPER ;
09337 --    STATES(NODE,T_SIZE) := HASH ;
09338 --          comment the above replaces the deleted code below (TAM 2008)
09339 --    FOR I := 1 UNTIL T_SIZE
09340 --    DO STATES(NODE,I) := CASE I OF (K, PLEX, CAPT_T, TOT_S, PART,
09341 --                                    A_SCR, UPPER, HASH) ;
09342 --    SAVE(NODE) ;
09343 -3  END OF_SAVESTATE ;
09344 --  
09345 --  PROCEDURE SAVE (INTEGER VALUE NODE) ;
09346 3-  BEGIN
09347 --    INTEGER J, J1, J2, J3, J4, N, STATE ;
09348 --  
09349 --    STATES(NODE,T_SIZE+1) := TRY(0) ;
09350 --    STATES(NODE,T_SIZE+2) := TRY(WSIZE) + NUM*1000 ;
09351 --    J := TRY(WSIZE) ;
09352 --    J1 := T_SIZE + 2 ;
09353 --    J2 := J1 + MAX_WID ;
09354 --    FOR I := 1 UNTIL J
09355 4-    DO BEGIN
09356 --      N := TRY(I) ;
09357 --      STATES(NODE,J1+I) := SCORE(N) ;
09358 --      STATE := MOVEFROM(N) + MOVETO(N)*256 + 131072*ABS(REWARD(N)) ;
09359 --      IF QUIES(N)
09360 --      THEN STATE := STATE + 65536 ;
09361 --      IF REWARD(N) < 0
09362 --      THEN STATE := -STATE ;
09363 --      STATES(NODE, J2+I) := STATE ;
09364 --        COMMENT STATES(NODE,J2+I) := MOVEFROM(N) ;
09365 --        COMMENT STATES(NODE,J3+I) := MOVETO(N) ;
09366 --        COMMENT STATES(NODE,J4+I) := REWARD(N) ;
09367 -4    END ;
09368 -3  END OF_SAVE ;
09369 --  
09370 --  PROCEDURE SEARCH ;
09371 --  COMMENT *********************search*********************** ;
09372 --   COMMENT   determines rtmv through look-ahead. ;
09373 3-  BEGIN
09374 --    INTEGER MOST, T_NODES, N, SIDE, DEEP, NEWLEVEL, NEWNODES, BRANCHES,
09375 --            NODE, Best_SCR, TOTALS, E_NUM, FINAL, EXPECT, LOST, MINDEPTH,
09376 --            MAXDEPTH, ID, REUSE, ALPHA, BETA ;
09377 --    INTEGER INCR, T_TIME, TYPE, PLY, EXPECTATION, FIRSTONE, NODECOUNT ;
09378 --    LOGICAL SMALL, SACR_ANAL, SECOND, REVERSE, MARK, FULLWIN, INTERIOR ;
09379 --    logical pass2 ;
09380 --    INTEGER ARRAY OLDSC(-1::E_Depth) ;
09381 --    INTEGER ARRAY MAXSC(-1::MAX_WID) ;
09382 --    INTEGER ARRAY AB(-1::E_Depth) ;
09383 --    INTEGER ARRAY MINTREE(1::E_Depth) ;
09384 --    INTEGER ARRAY LIST(0::ELIMIT) ;
09385 --  
09386 --    PROCEDURE COLLECT (INTEGER VALUE NODE, ROOT) ;
09387 --    COMMENT    collects nodes from discarded subtree. ;
09388 4-    BEGIN
09389 --      INTEGER L, ptr ;
09390 --      IF NODE > 0
09391 --      THEN IF NODE > MAXTREE
09392 --           THEN WRITE("ERROR COLLECT", NODE)
09393 --           ELSE IF (ROOT = PARENT(NODE) REM packer) and ROOT ~= NODE
09394 5-                THEN BEGIN
09395 --                           COMMENT retrieve least significant node of most extreme
09396 --                                   subtree ;
09397 --                                  COMMENT gametree not want PARENT(NODE) := 0 ;
09398 --                  L := NODETO(NODE,0) ;
09399 --                  FOR I := L STEP -1 UNTIL 1
09400 --                  DO COLLECT(NODETO(NODE,I), NODE) ;
09401 --                                  COMMENT display retrieved nodes ;
09402 --                  ptr := POINT ;
09403 --                  IF MAXL < MAXTREE THEN
09404 --                    ptr := MAXL := MAXL + 1
09405 --                  else if POINT > 0 then
09406 --                    POINT := POINT - 1
09407 6-                  else begin
09408 --                    WRITE("COLLect", ptr, POINT, MAXL, NODE, L, PARENT(NODE)) ;
09409 --                    DisplayLostNodes ;
09410 --                    iocontrol(2) ;
09411 7-                    for i := point+1 step 1 until maxl do begin
09412 --                      writeon(holding(i)) ;
09413 --                      if i rem 20 = 0 then iocontrol(2) ;
09414 -7                    end ;
09415 --                    iocontrol(2) ;
09416 --                    TRACER(2, "?9K") ;
09417 -6                  end ;
09418 --                  GETNODE(ptr) := NODE ;
09419 --                  REUSE := MAXL ;
09420 --                  STATES(NODE,4) := -ABS(STATES(NODE,4)) ;
09421 --                  PARENT(NODE) := packer*(PARENT(NODE) DIV packer) ;
09422 --                  NODETO(NODE,0) := IF L = 0
09423 --                                    THEN -FIVES
09424 --                                    ELSE -ABS(L) ;
09425 --                  COMMENT IF MONITOR THEN WRITEON(NODE, ROOT, PARENT(NODE)) ;
09426 -5                END
09427 5-                else begin
09428 --                  if warning
09429 --                  then write("Not stored. Parent mismatch root/parent(node)/node",
09430 --                              root, parent(node), node) ;
09431 --                    comment potential infinite loop ;
09432 -5                end ;
09433 -4    END OF_COLLECT ;
09434 --  
09435 --    LOGICAL PROCEDURE MARKTREE (INTEGER VALUE NODE, ROOT, DEPTH, TAG) ;
09436 4-    BEGIN
09437 --      LOGICAL MARK ;
09438 --                     COMMENT check for severe error, impossible node value ;
09439 --      MARK := FALSE ;
09440 --      IF (NODE > 0) THEN
09441 --      IF NODE > MAXTREE
09442 --      THEN WRITE("ERROR RECOVERY ", ROOT, NODE, DEPTH, TAG)
09443 5-      ELSE BEGIN
09444 --                            COMMENT display marked nodes ;
09445 --        IF TEST THEN WRITE("MA", NODE, PARENT(NODE), DEPTH,
09446 --                                      NODETO(NODE,0), "root =", ROOT) ;
09447 --        IF TEST THEN FOR I := 1 UNTIL NODETO(NODE,0)
09448 --                     DO WRITEON(NODETO(NODE,I)) ;
09449 --        if ROOT ~= PARENT(NODE) rem packer
09450 6-        then begin
09451 --          if warning then
09452 --            write("Inconsistent root ~= parent node/root/parent(node)/depth",
09453 --                    NODE, ROOT, PARENT(NODE), DEPTH) ;
09454 --          Reclaim_Node(NODE, "MARK-1") ;
09455 --  if TEST then write("Mark-1 root/nodeto(root,0)", root, nodeto(root,0)) ;
09456 --  if TEST then for i := 1 until nodeto(root,0) do writeon(nodeto(root,i)) ;
09457 --  if TEST then write("Mark-1 node/nodeto(node,0)", node, nodeto(node,0)) ;
09458 --  if TEST then for i := 1 until nodeto(node,0) do writeon(nodeto(node,i)) ;
09459 --          for i := 1 until NODETO(ROOT,0)
09460 --          do if NODETO(ROOT,i) = NODE
09461 --             then NODETO(ROOT,i) := 0 ;
09462 -6        end ;
09463 --        IF PARENT(NODE) > DEPTH and PARENT(NODE) rem packer > 0
09464 6-        THEN BEGIN
09465 --          NODECOUNT := NODECOUNT + 1 ;
09466 --          IF TAG ~= 0
09467 --          THEN STATES(ROOT,2) := 0 ;
09468 --          FOR I := NODETO(NODE,0) STEP -1 UNTIL 1
09469 --          DO IF MARKTREE(NODETO(NODE,I), NODE, DEPTH+packer, TAG)
09470 7-             THEN begin
09471 --               if warning then
09472 --                 write("marktree deletion node/i/nodeto(node,i)/nodeto(node,0)") ;
09473 --               if warning then
09474 --                 write(NODE, i, NODETO(NODE,i), NODETO(NODE,0)) ;
09475 --               COLLECT(NODETO(NODE,I), NODE) ;
09476 --               NODETO(NODE,I) := 0 ;
09477 -7             end ;
09478 --          PARENT(NODE) := ROOT + DEPTH ;
09479 -6        END ELSE
09480 6-        begin
09481 --          MARK := TRUE ;
09482 7-          if NODE > 0 and ROOT ~= PARENT(NODE) rem packer then begin
09483 --             if warning then
09484 --               write("Scrap inconsistent node", NODE, PARENT(NODE), ROOT,
09485 --                      NODETO(ROOT,0)) ;
09486 --             for i := NODETO(ROOT,0) step -1 until 1 do
09487 8-                 if NODE = NODETO(ROOT,i) then begin
09488 --                   write("Sent subtree root/i/node for collection",
09489 --                         root, i, nodeto(root,i)) ;
09490 --                   COLLECT(NODE, ROOT) ;
09491 --                   NODETO(ROOT,i) := 0 ;
09492 -8                 end ;
09493 -7          end ;
09494 -6        end ;
09495 -5      END ;
09496 --      MARK
09497 --        comment isolation of next tree ;
09498 -4    END OF_MARKTREE ;
09499 --  
09500 --    PROCEDURE DEADTREE (INTEGER VALUE REPLY) ;
09501 4-    BEGIN
09502 --          COMMENT between-move garbage collection underway ;
09503 --      PREVSCR := OLDSCR ;
09504 --      IF REPLY <= 0 OR REPLY > NODETO(ORIGIN,0)
09505 --           OR NODETO(ORIGIN,REPLY) <= 0
09506 5-      THEN begin
09507 --        SAVEL := 0 ;
09508 --        write("REPLY problem in DEADTREE reply/origin/nodeto(origin,0|reply):") ;
09509 --        write("     ", REPLY, ORIGIN, NODETO(ORIGIN,0)) ;
09510 --        if REPLY <= MAX_WID then writeon(NODETO(ORIGIN,REPLY))
09511 --        else writeon("reply > max_wid", REPLY, MAX_WID, "warning only") ;
09512 -5      end ;
09513 --      IF (SAVEL > 0)
09514 5-      THEN BEGIN
09515 --        POINT := 0 ;
09516 --        FOR I := SAVEL UNTIL MAXL
09517 6-        DO BEGIN
09518 --          POINT := POINT + 1 ;
09519 --          GETNODE(POINT) := GETNODE(I) ;
09520 --          if i > POINT then
09521 --             GETNODE(i) := 0 ;
09522 -6        END ;
09523 --                      COMMENT more unused nodes ;
09524 --                      COMMENT retrieve current origin ;
09525 --        MAXL := POINT + 1 ;
09526 --        GETNODE(MAXL) := NODE := ORIGIN ;
09527 --        POINT := 0 ;
09528 --        ORIGIN := NODETO(ORIGIN,REPLY) ;
09529 --                      COMMENT will reduce depth of tree by 1 ;
09530 --        NODECOUNT := 0 ;
09531 --        MARK := MARKTREE(ORIGIN, NODE, packer, 1) ;
09532 --                      COMMENT mark remnant of current tree,
09533 --                              in case duplicate positions ;
09534 --                      COMMENT retrieve discarded sub trees ;
09535 --        FOR I := NODETO(NODE,0) STEP -1 UNTIL 1
09536 --        DO IF I ~= REPLY
09537 --           THEN COLLECT(NODETO(NODE,I), NODE) ;
09538 --        GETNODE(MAXL+1) := NIL ;
09539 --        SAVEL := 1 ;
09540 --        NODECOUNT := NODECOUNT + MAXL - POINT ;
09541 --        new_count := MAXTREE - NODECOUNT ;
09542 --        exiting := false ;
09543 6-        if new_count < 0 then begin
09544 --          write("Node Count Error ", new_count, nodecount, POINT, MAXL, MAXTREE) ;
09545 --          iocontrol(2) ;
09546 --          new_count := 0 ;
09547 --          DisplayLostNodes ;
09548 --              comment the following eliminates infinite loop in COLLECT ;
09549 --              comment eliminate any nodes in both the gametree and getnode ;
09550 --          for i := 1 until maxtree do
09551 --            if holding(i) > i then
09552 --            for j := point+1 step 1 until maxl
09553 7-            do if getnode(j) = i then begin
09554 --              getnode(j) := getnode(point+1) ;
09555 --              point := point + 1 ;
09556 -7            end ;
09557 -6        end else
09558 --        if new_count ~= old_count and new_count > 0
09559 6-        THEN BEGIN
09560 --          WRITE("INCONSISTENT maxl=", MAXL, NODECOUNT, MAXTREE, "lost= ",
09561 --                new_count, old_count, POINT, MAXL) ;
09562 --          DisplayLostNodes ;
09563 --          old_count := new_count ;
09564 --          new_count := -new_count ;
09565 --                COMMENT MARK := MARKTREE(ORIGIN, NODE, packer, 1) ;
09566 -6        END ;
09567 --        IOCONTROL(2) ;
09568 --                      COMMENT savel is no. of nodes just added to tree ;
09569 --        OLDSCR := SCORE(TRY(REPLY)) ;
09570 -5      END ELSE
09571 5-      BEGIN
09572 --        write("In DeadTree savel<=0 Do INIT_TREE?", SAVEL) ;
09573 --        MAXL := MAXTREE ;
09574 --        FOR I := 1 UNTIL MAXL
09575 --        DO GETNODE(I) := I ;
09576 --        ORIGIN := 0 ;
09577 --                    comment why orign := 0 why not point := 0 and reuse := maxl ;
09578 --        OLDSCR := FIVES ;
09579 --                    COMMENT   unexpected move ;
09580 --        MINDEPTH := MAXNODES := 2 ;
09581 -5      END ;
09582 --      IF TEST THEN WRITE("DEAD ") ;
09583 --      IF TEST THEN
09584 --        FOR I := 1 UNTIL 10 DO WRITEON(GETNODE(I)) ;
09585 --        comment dead tree node collection ;
09586 -4    END OF_DEADTREE ;
09587 --  
09588 --    PROCEDURE INVALIDATE (INTEGER VALUE NODE) ;
09589 4-    BEGIN
09590 --      COMMENT IF MONITOR THEN WRITE("INVAL", NODE, NODETO(NODE,0),
09591 --                                    PARENT(NODETO(NODE,1))) ;
09592 --      IOCONTROL(2) ;
09593 --      IF NODE > 0 AND NODE <= MAXTREE
09594 5-      THEN BEGIN
09595 --        FOR I := 1 UNTIL NODETO(NODE,0)
09596 6-        DO begin
09597 --          if (NODETO(NODE,i) > 0) then
09598 --          IF PARENT(NODETO(NODE,I)) rem packer = NODE
09599 --          THEN INVALIDATE(NODETO(NODE,I))
09600 --          else
09601 --            write("INVALIDATED parent", NODE, PARENT(NODETO(NODE,i))) ;
09602 -6        end ;
09603 --        STATES(NODE,2) := 0 ;
09604 -5      END ;
09605 -4    END OF_INVALIDATE ;
09606 --  
09607 --  INTEGER PROCEDURE TREE (INTEGER VALUE ALPHA, BETA, T_HASH, DEEPER ;
09608 --                          LOGICAL VALUE PRINCVAR ; INTEGER RESULT TYPE) ;
09609 --  
09610 --  COMMENT generates the decision tree ;
09611 4-  BEGIN
09612 --    INTEGER IP, TARGET, ROOT, IDONE, LIMIT, PASTSCR, LASTSCR, INCREASE,
09613 --            EST_cnt, MIN_WID, SCR, REWN, BETTER, MX, LX, FIRST, F_T, INC_wid,
09614 --            INIT_T_NODES, CONDITION, LARGE, B_SCR, T_SCR, LOWER ;
09615 --    LOGICAL OLD, ANOTHER, DYNAMIC, SHAH, FORCED, PARTIAL, MATER,
09616 --            DISCARD, GOOD, MORE, SEEN, FINISH, AGAIN ;
09617 --    INTEGER HIGHER, L_SCR, CNT, NEW_HASH, TMP ;
09618 --    LOGICAL EXTENSION ;
09619 --    INTEGER ARRAY REFSAVE (1::WSIZE) ;
09620 --    INTEGER EXCESS, SAVE_WIDTH ;
09621 --  
09622 --    PROCEDURE SHIFT (INTEGER VALUE IP, F, ROOT) ;
09623 5-    BEGIN
09624 --      INTEGER LX, LAST, ptr ;
09625 --      logical update ;
09626 --      STRING(5) NOTE ;
09627 --      IF IP > F
09628 6-      THEN BEGIN
09629 --        NOTE := IF F = 1
09630 --                THEN "MOVE "
09631 --                ELSE "SHIFT" ;
09632 --        LX := TRY(IP) ;
09633 --        LAST := NODETO(ROOT, IP) ;
09634 --        ptr := NODETO(ROOT,0) ;
09635 --        FOR I := IP-1 STEP -1 UNTIL F
09636 7-        DO BEGIN
09637 --          TRY(I+1) := TRY(I) ;
09638 --          NODETO(ROOT, I+1) := NODETO(ROOT, I) ;
09639 -7        END ;
09640 --        update := F <= ptr and ptr < IP ;
09641 --        if update and IP <= MAX_WID
09642 --        then ptr := ptr + 1 ;
09643 --        NODETO(ROOT,0) := ptr ;
09644 --        TRY(F) := LX ;
09645 --        NODETO(ROOT,F) := LAST ;
09646 --        SAVE(ROOT) ;
09647 --        IF (TEST and update)
09648 7-        THEN begin
09649 --          WRITE(NOTE, LEVEL, F, ptr, IP, update, ROOT) ;
09650 --          for i := f step 1 until ptr
09651 --          do writeon(NODETO(ROOT,i)) ;
09652 -7        end ;
09653 -6      END ;
09654 -5    END OF_SHIFT ;
09655 --  
09656 --    PROCEDURE FIRSTENTRY (INTEGER VALUE ROOT) ;
09657 5-    BEGIN
09658 --      INTEGER TEMP ;
09659 --  
09660 --      EXPECT := SCORE(TRY(1)) ;
09661 --      TEMP := + SCALE*ONEVAL ;
09662 --                      COMMENT display parameters at beginning of each iteration ;
09663 --      IF TEST
09664 --      THEN WRITE("FIRST", ONEVAL, EXPECT, TEMP, MINDEPTH, MAXDEPTH,
09665 --                  DEEP, MAXNODES, NUM, TRY(0), TRY(WSIZE), WIDTH) ;
09666 --      FOR I := 1 UNTIL MAX_PLIES
09667 --      DO MINTREE(I) := IF I < 3
09668 --                       THEN MAXNODES
09669 --                       ELSE MINTREE(I-1) DIV 2 ;
09670 -5    END OF_FIRSTENTRY ;
09671 --  
09672 --    PROCEDURE REPETITION (INTEGER VALUE NODE, ROOT, LEVEL) ;
09673 5-    BEGIN
09674 --                        COMMENT repetition, looking for a cycle ;
09675 --      COMMENT IF MONITOR THEN WRITE("R", NODE, ROOT, LEVEL, NODETO(NODE,0))
09676 --       ;
09677 --      IF (FINAL ~= 3) AND LEVEL <= LENGTH AND NODE > 0
09678 --      THEN FOR I := 1 UNTIL NODETO(NODE,0)
09679 --           DO IF (NODETO(NODE,I) = ROOT)
09680 --              THEN FINAL := 3
09681 --              ELSE REPETITION(NODETO(NODE,I), ROOT, LEVEL+1) ;
09682 -5    END OF_REPETITIONTEST ;
09683 --  
09684 --    PROCEDURE LOCATE (INTEGER VALUE START, NODE, ROOT, DEPTH) ;
09685 5-    BEGIN
09686 --              COMMENT IF MONITOR THEN WRITE("LOCATE ", START, NODE, ROOT, DEPTH,
09687 --                                            PARENT(START), NODETO(START,0)) ;
09688 --      IF (START > 0) AND (START ~= ROOT) AND DEPTH < PARENT(START)
09689 --      THEN IF (START = NODE)
09690 6-           THEN BEGIN
09691 --             REPETITION(START, ROOT, 1) ;
09692 --             IF (FINAL ~= 3) AND (LEVEL*packer > PARENT(NODE))
09693 --             THEN FINAL := 1 ;
09694 --               COMMENT IF MONITOR AND (FINAL = 1)
09695 --               THEN WRITEON(PARENT(NODE), LEVEL, NODE, ROOT) ;
09696 -6      END ELSE FOR I := 1 UNTIL NODETO(START,0)
09697 --               DO IF (FINAL = 2)
09698 --                  THEN LOCATE(NODETO(START,I), NODE, ROOT, DEPTH+packer) ;
09699 --                       comment DEPTH of the form packer*LEVEL ;
09700 -5    END OF_LOCATE ;
09701 --  
09702 --    INTEGER PROCEDURE BUILD_SACR_TREE (INTEGER VALUE ROOT, DEPTH, BOUND, SAC_ALPHA,
09703 --                                       SAC_BETA ; INTEGER VALUE RESULT IDONE) ;
09704 5-    BEGIN
09705 --      INTEGER BESTSCR ;
09706 --      INTEGER ARRAY SAVER(0::W_LIM) ;
09707 --      LOGICAL MAYBEMATE, NARROW, EXCLUDE, EXTEND, FIRSTtime ;
09708 --  
09709 --      INTEGER PROCEDURE SACR_TREE (INTEGER VALUE PLY, AA, BB ;
09710 --                                   INTEGER ARRAY SAVER(*)) ;
09711 6-      BEGIN
09712 --        INTEGER ARRAY MOVES(0::W_LIM) ;
09713 --        STRING(140) BUFFER ;
09714 --        INTEGER BESTSCR, SCR, KK, N, DONE, SC, MT, NODE, REWN, ND, TEMP_HASH ;
09715 --        LOGICAL SAVECH, GOOD, PARTIAL ;
09716 --        INTEGER ARRAY SAVECL(-1::1) ;
09717 --  
09718 --        KK := IF PLY REM 2 = 0
09719 --              THEN -1
09720 --              ELSE 1 ;
09721 --        ALTERNATIVE := IF PLY > 1
09722 --                       THEN TRUE
09723 --                       ELSE FALSE ;
09724 --        TEMP_HASH := HASH ;
09725 --        UPPER := BB ;
09726 --        LISTLEGALMOVES (FALSE) ;
09727 --        PARTIAL := UPPER ~= EIGHTS ;
09728 --        N := TRY(1) ;
09729 --        IF ALTERNATIVE
09730 --        THEN SAVE_THE_MOVES(SAVER) ;
09731 --        IF (NUM = 0)
09732 7-        THEN BEGIN
09733 --          IF CON(-K,KINGSQ(K)) = 0
09734 --          THEN BESTSCR := DRAW      comment it is stalemate ;
09735 --          ELSE BESTSCR := -NINES ;  comment it is checkmate ;
09736 --          if warning then
09737 --            write("In SACR_TREE Stale/Mate at level=", LEVEL, bestscr) ;
09738 -7        END ELSE
09739 7-        BEGIN
09740 --          SCR := SCORE(N) ;
09741 --          IF FIRSTtime
09742 8-          THEN begin
09743 --            if test then
09744 --            write("first use ", LEVEL, POINT, REUSE, MAXL, NODE,
09745 --                                AA, SCR, BB, CREDIT(LEVEL), DEBIT(LEVEL-1)) ;
09746 -8          end else
09747 8-          begin
09748 --            IF PLY > 1 OR SCR > AA AND SCR < BB
09749 --                       OR INCHECK AND SCR > AA
09750 9-            THEN BEGIN
09751 --              REUSE := REUSE - 1 ;
09752 --              IF REUSE <= POINT
09753 --              THEN REUSE := MAXL ;
09754 --              NODE := GETNODE(REUSE) ;
09755 --              IF NODE > 0 AND NODE <= MAXTREE
09756 --              THEN IF POINT < MAXL
09757 10-                  THEN BEGIN
09758 --                     GOOD := TRUE ;
09759 --                     HASH := TEMP_HASH ;
09760 --                     comment doubt whether the following save is important,
09761 --                             since cannot find a companion restorestate ;
09762 --                     SAVESTATE(NODE) ;
09763 --                     IF PP_STATUS > 0 AND K*CON(0,M3) < 0
09764 --                     THEN SCR := SCR
09765 --                                   - SCALE*PP_STATUS DIV (IF CON(K,M3) ~= 0
09766 --                                                          THEN 2
09767 --                                                          ELSE 1) ;
09768 --                     STATES(NODE,5) := IF PARTIAL THEN 1 ELSE 0 ;
09769 --                     STATES(NODE,2) := 1 ;
09770 --                     NODETO(NODE,0) := 0 ;
09771 --                     STATES(NODE,4) := 1 ;
09772 --                     PARENT(NODE) := packer*LEVEL ;
09773 --                           Comment that should be LEVEL, was LENGTH !!! ;
09774 --                     IF TEST
09775 --                     THEN WRITE("REUSE", LEVEL, length, POINT, REUSE, MAXL, NODE,
09776 --                                AA, SCR, BB, CREDIT(LEVEL), DEBIT(LEVEL-1)) ;
09777 -10             END ELSE NODE := 0 ;
09778 -9            END ELSE NODE := 0 ;
09779 -8          end ;
09780 --          FIRSTtime := FALSE ;
09781 --          IF (PLY <= 1)
09782 8-          THEN BEGIN
09783 --            ND := 1 ;
09784 --  LOOP:
09785 --            SCR := SCORE(N) ;
09786 --            REWN := REWARD(N) ;
09787 --            IF TEST
09788 --            THEN PRINTLINE(N, LEVEL) ;
09789 --            IF TEST
09790 --            THEN WRITEON(IF PARTIAL THEN "%" ELSE "@",
09791 --                           CREDIT(LEVEL), DEBIT(LEVEL-1),
09792 --                           CLEARPAWN(-K), AA, BB, TEMP_HASH) ;
09793 --            IF ABS(REWN) >= DISCHECK
09794 --              OR SCR < BB
09795 --              OR INCHECK AND NUM < 5
09796 --              OR EXTEND
09797 --              OR ABS(REWARD(N)) >= REALCHECK
09798 --                AND ABS(CON(-K,KINGSQ(-K))) <= 1
09799 --                AND K*SEC(0,MOVETO(N)) > 0
09800 9-            THEN BEGIN
09801 --              GOOD := FALSE ;
09802 --              PUNCHBRD(TRUE, BUFFER) ;
09803 --              IF (REWN < 0 AND ABS(REWN) >= REALCHECK OR EXTEND OR INCHECK)
09804 --                    AND (LEVEL <= 4) AND SCR < SEVENS
09805 10-             THEN BEGIN
09806 --                IF TEST THEN
09807 --                  WRITE("EXTEND by 2-ply ", SCR, ALPHA, BETA, abs(rewn), extend,
09808 --                         incheck, LEVEL) ;
09809 --                DONE := NODETO(0,0) := 0 ;
09810 --                SAVESTATE(0) ;
09811 --                MAKEMOVE(N, TRUE) ;
09812 --                SCR := -BUILD_SACR_TREE(0, 2, BOUND, -BB, -AA, DONE) ;
09813 --                SETBOARD(BUFFER) ;
09814 --                IF ~STARTTHISPROBLEM(TRUE)
09815 --                THEN GOTO STARTS ;
09816 --                IF GOOD AND ABS(SCR) > SEVENS
09817 --                THEN STATES(NODE, T_SIZE+2+ND) := SCR -LEVEL ;
09818 --                              COMMENT if poor score returned from 2-ply
09819 --                                      extension look at first alternative ;
09820 --                ND := ND + 1 ;
09821 --                N := TRY(ND) ;
09822 --                IF ND = 2 AND TRY(WSIZE) > 1 AND SCR < SCORE(N)
09823 --                THEN GO TO LOOP ;
09824 -10             END ;
09825 -9            END ;
09826 --            BESTSCR := SCR ;
09827 --            CAP := CAP + 1 ;
09828 -8          END ELSE
09829 8-          BEGIN
09830 --            MAYBEMATE := INCHECK AND NUM < WIDTH ;
09831 --            BESTSCR := -EIGHTS ;
09832 --            PUNCHBRD(TRUE, BUFFER) ;
09833 --            FOR J := -1 UNTIL 1
09834 --            DO SAVECL(J) := CLEARPAWN(J) ;
09835 --            FOR I := 1 STEP 4 UNTIL SAVER(0)
09836 9-            DO BEGIN
09837 --              MOVEFROM(TOTAL) := SAVER(I) ;
09838 --              MOVETO(TOTAL) := MT := SAVER(I+1) ;
09839 --              REWARD(TOTAL) := SAVER(I+2) ;
09840 --              SCORE(TOTAL) := SC := SAVER(I+3) ;
09841 --              IF (SC > NOSCR)
09842 10-             THEN BEGIN
09843 --                IF TEST
09844 --                THEN PRINTLINE(TOTAL, LEVEL) ;
09845 --                MAKEMOVE(TOTAL, TRUE) ;
09846 --                IF TEST
09847 --                THEN WRITEON(IF PARTIAL THEN "%" ELSE "$",
09848 --                               CREDIT(LEVEL), DEBIT(LEVEL-1)) ;
09849 --                SAVECH := INCHECK ;
09850 --                K := -K ;
09851 --                LEVEL := LEVEL + 1 ;
09852 --                SCR := -SACR_TREE(PLY-1, -BB, -AA, MOVES) ;
09853 --                K := -K ;
09854 --                SETBOARD(BUFFER) ;
09855 --                IF ~STARTTHISPROBLEM(TRUE)
09856 --                THEN GO TO STARTS ;
09857 --                LEVEL := LEVEL - 1 ;
09858 --                INCHECK := SAVECH ;
09859 --                FOR J := -1 UNTIL 1
09860 --                DO CLEARPAWN(J) := SAVECL(J) ;
09861 -10             END ELSE SCR := -FIVES ;
09862 --              SAVER(I+3) := SCR ;
09863 --              IF SCR > BESTSCR
09864 --              THEN BESTSCR := SCR ;
09865 --              IF BESTSCR > BB
09866 10-             THEN BEGIN
09867 --                IF TEST
09868 --                THEN WRITE("CUT-OFF", INCHECK, SC, SCR, BB, BOUND, KK, PLY) ;
09869 --                SAVER(0) := I ;
09870 --                GO TO PRUNE ;
09871 -10             END ;
09872 --              IF BESTSCR > AA
09873 --              THEN AA := BESTSCR ;
09874 --              IF NARROW AND I > 5
09875 --              THEN GO TO PRUNE ;
09876 -9            END ;
09877 --  PRUNE:
09878 -8          END ;
09879 -7        END ;
09880 --        BESTSCR
09881 -6      END OF_SACR_TREE ;
09882 --  
09883 --      PROCEDURE INSERT_NEW_MOVES (INTEGER ARRAY SAVER(*)) ;
09884 6-      BEGIN
09885 --        LOGICAL NEW, PROMOTION, SHUFFLE ;
09886 --        INTEGER MF, MT, SCR, JJ, TW, S, TT, RW, N, R, SAVED, INC,
09887 --                IN, TOP, NN, BEST_J, MINSCR, TEMP, J_MAX ;
09888 --  
09889 --        J_MAX := IF NODETO(ROOT,0) > 4
09890 --                 THEN 4 ELSE NODETO(ROOT,0) ;
09891 --                       COMMENT IF TEST AND LEVEL <= 2
09892 --                               THEN TRACER(1, "?D") ;
09893 --        TW := TRY(WSIZE) ;
09894 --                               COMMENT display current movelist ;
09895 7-        IF (TEST) AND SAVER(0) > 0 THEN begin
09896 --          write("INSERT_NEW_MOVES current move list at level/j_max", LEVEL, j_max) ;
09897 --          FOR J := TW STEP -1 UNTIL 1
09898 8-          DO BEGIN
09899 --            N := TRY(J) ;
09900 --            WRITE(".....", N, chessman(abs(brd(movefrom(n)))),
09901 --                           box(movefrom(n)), box(moveto(n)),
09902 --                           MOVEFROM(N), MOVETO(N), REWARD(N), SCORE(N)) ;
09903 -8          END ;
09904 -7        end ;
09905 --        JJ := K ;
09906 --        TT := 0 ;
09907 --        FOR I := SAVER(0) STEP -4 UNTIL 1
09908 7-        DO BEGIN
09909 --          MINSCR := SCORE(TRY(TW)) ;
09910 --          TOP := SCORE(TRY(1)) ;
09911 --          BEST_J := 1 ;
09912 --          PROMOTION := FALSE ;
09913 --          NEW := TRUE ;
09914 --          S := TW + 1 ;
09915 --          TT := TT + 1 ;
09916 --          MF := SAVER(I) ; comment movefrom() ;
09917 --          MT := SAVER(I+1) ; comment moveto() ;
09918 --          RW := SAVER(I+2) ; comment reward() ;
09919 --          SCR := SAVER(I+3) ; comment score() ;
09920 --          IF ABS(SCR) ~= FIVES
09921 8-          THEN BEGIN
09922 --            FOR J := TW STEP -1 UNTIL 1
09923 9-            DO BEGIN
09924 --              N := TRY(J) ;
09925 --              IF MINSCR > SCORE(N)
09926 --              THEN MINSCR := SCORE(N) ;
09927 --              IF TOP < SCORE(N)
09928 10-             THEN BEGIN
09929 --                TOP := SCORE(N) ;
09930 --                BEST_J := J ;
09931 -10             END ;
09932 --              IF (MF = MOVEFROM(N)) AND (MT = MOVETO(N))
09933 10-             THEN BEGIN
09934 --                R := ABS (ABS(RW) - ABS(REWARD(N))) REM CHECKING ;
09935 --                IF R = 0 OR R = 2 AND (RW = 0)
09936 11-               THEN BEGIN
09937 --                  NEW := FALSE ;
09938 --                  IF RW > PFTWO
09939 --                  THEN PROMOTION := TRUE ;
09940 --                  S := J ;
09941 --                  RW := REWARD(N) ;
09942 --                  NN := N ;
09943 -11               END ;
09944 -10             END ;
09945 -9            END ;
09946 --                            COMMENT display sacrificial move ;
09947 --            IF TEST
09948 --            THEN WRITE("COMP", MF, MT, RW, SCR, MINSCR, TOP, BEST_J, new, s) ;
09949 --            IF SCR > TOP AND SCR < SIXES
09950 --            THEN SCR := TOP + (PAWNVALUE*(SCR-TOP)) DIV (SCR-TOP + PAWNVALUE) ;
09951 --            IF TEST
09952 --            then writeon("revised score ", scr) ;
09953 --  
09954 --            IF NEW AND SCR > TOP AND SCR < SIXES
09955 --            THEN SCR := TOP - 1 ;
09956 --            IF (~NEW OR SCR > MINSCR) THEN
09957 --            WHILE S > 0
09958 9-            DO BEGIN
09959 --                   COMMENT the movelist is divided into two parts
09960 --                               a. Moves searched by 3-ply tree
09961 --                               b. Unsearched 1-ply moves.
09962 --                    Part a moves may have lower scores than those from part b ;
09963 --              FOR J := 1 UNTIL TW
09964 10-             DO begin
09965 --                 if abs(reward(try(j))) >= twocheck
09966 11-                then begin
09967 --                    if warning then
09968 --                      write("Don't replace a double check") ;
09969 -11                end else
09970 --                 IF SCR >= SCORE(TRY(J))
09971 --                       AND (SCR > TOP OR J > J_MAX OR J > BEST_J)
09972 --                    OR ~NEW AND J = TW
09973 11-                THEN BEGIN
09974 --                   IN := IF S < J
09975 --                         THEN J - 1
09976 --                         ELSE J ;
09977 --                   IF (TEST) AND S ~= IN
09978 --                   THEN WRITE("INSERT ", box(mf), box(mt), S, IN, J, IDONE, K, 
09979 --                           NEW, TT, TW, JJ, SCORE(TRY(1)), SCR, SCORE(TRY(J))) ;
09980 --                   IF NEW
09981 12-                  THEN BEGIN
09982 --                     S := TW ;
09983 --                     IF S <= IDONE
09984 --                     THEN DISCARD_SUBTREES(S) ;
09985 --                     IF NODETO(ROOT,0) >= S
09986 --                     THEN COLLECT(NODETO(ROOT,S), ROOT)
09987 13-                    else begin
09988 --                       comment it seems that if s > NODETO(ROOT,0) all is OK ;
09989 -13                    end ;
09990 --                     NODETO(ROOT, S) := 0 ;
09991 --                     TRY(S) := JJ ;
09992 --                     MOVEFROM(JJ) := MF ;
09993 --                     MOVETO(JJ) := MT ;
09994 --                     REWARD(JJ) := RW ;
09995 --                     SCORE(JJ) := SCR ;
09996 --                     JJ := JJ + K ;
09997 -12                  END ELSE SCORE(NN) := SCR ;
09998 --                   SHUFFLE := FALSE ;
09999 --                   IF S < IN
10000 12-                  THEN BEGIN
10001 --                     SHUFFLE := TRUE ;
10002 --                     TEMP := S ;
10003 --                     IF S + 5 < IN
10004 --                     THEN S := S + 5
10005 --                     ELSE S := IN ;
10006 --                     IN := TEMP ;
10007 -12                  END ;
10008 --                   IF S > IDONE
10009 12-                  THEN BEGIN
10010 --                     IF IN <= IDONE
10011 13-                    THEN BEGIN
10012 --                       DISCARD_SUBTREES(IN) ;
10013 --                       IDONE := IDONE + 1 ;
10014 --                       NODETO(ROOT, 0) := IDONE ;
10015 -13                    END ;
10016 --                     if warning and S = IDONE and NODETO(ROOT,S) > 0 then
10017 --                        write("Warning: INSERT_NEW deleting nodeto(root,s)/in/s/idone",
10018 --                                 NODETO(ROOT,s), in, s, idone) ;
10019 --                     NODETO(ROOT, S) := 0 ;
10020 -12                  END ;
10021 --  
10022 --                   COMMENT is the target move advancing or declining in score ;
10023 --                   IF SHUFFLE
10024 --                   THEN
10025 --                     IF S <= IDONE AND IN > IDONE
10026 12-                    THEN BEGIN
10027 --                       COLLECT(NODETO(ROOT,S), ROOT) ;
10028 --                       NODETO(ROOT,S) := -1 ;
10029 --                       IDONE := IDONE - 1 ;
10030 -12                    END ;
10031 --                   SHIFT(S, IN, ROOT) ;
10032 --                   GOTO INSERTED ;
10033 -11                END ;
10034 -10             end ;
10035 --  INSERTED:
10036 --              S := 0 ;
10037 -9            END ;
10038 --            TRY(WSIZE) := TW ;
10039 -8          END ;
10040 -7        END ;
10041 --        TW := TRY(WSIZE) ;
10042 --                               COMMENT display final movelist ;
10043 7-        IF (TEST) AND SAVER(0) > 0 THEN begin
10044 --          write("INSERT_NEW_MOVES final move list at level", LEVEL) ;
10045 --          FOR J := TW STEP -1 UNTIL 1
10046 8-          DO BEGIN
10047 --            N := TRY(J) ;
10048 --            WRITE(".....", N, chessman(abs(brd(movefrom(n)))),
10049 --                           box(movefrom(n)), box(moveto(n)),
10050 --                           MOVEFROM(N), MOVETO(N), REWARD(N), SCORE(N)) ;
10051 -8          END ;
10052 -7        end ;
10053 --        SAVE(ROOT) ;
10054 -6      END OF_INSERT_NEW_MOVES ;
10055 --  
10056 --      PROCEDURE SAVE_THE_MOVES (INTEGER ARRAY SAVER(*)) ;
10057 6-      BEGIN
10058 --        INTEGER ARRAY HOLD (1::MAX_WID) ;
10059 --        LOGICAL DELETE ;
10060 --        INTEGER J, JJ, MOVE, DONE ;
10061 --  
10062 --        DONE := NODETO(ROOT,0) ;
10063 --        IF DONE > WIDTH THEN DONE := WIDTH ;
10064 --        IF EXCLUDE
10065 --        THEN FOR L := 1 UNTIL DONE
10066 --             DO HOLD(L) := ABS(STATES(ROOT, T_SIZE+2+MAX_WID+L)) REM 65536 ;
10067 7-        IF FALSE AND TEST AND LEVEL <= 2 THEN BEGIN
10068 --          WRITE("SAVE_THE ", DONE) ;
10069 --          FOR L := 1 UNTIL DONE DO WRITEON(HOLD(L)) ;
10070 -7        END ;
10071 --        J := -3 ;
10072 --        FOR I := 1 UNTIL TRY(0)
10073 7-        DO BEGIN
10074 --          J := J + 4 ;
10075 --          JJ := TRY(I) ;
10076 --            IF FALSE AND TEST AND LEVEL <= 2
10077 --            THEN PRINTLINE(JJ, LEVEL) ;
10078 --          DELETE := FALSE ;
10079 --          IF EXCLUDE
10080 8-          THEN BEGIN
10081 --            MOVE := MOVEFROM(JJ) + 256*MOVETO(JJ) ;
10082 --            FOR L := 1 UNTIL DONE
10083 --            DO IF ~ DELETE
10084 9-               THEN BEGIN
10085 --                 IF HOLD(L) = MOVE
10086 --                 THEN DELETE := TRUE ;
10087 -9            END ;
10088 -8          END ;
10089 --          IF DELETE
10090 --          THEN J := J - 4
10091 8-          ELSE BEGIN
10092 --            SAVER(J) := MOVEFROM(JJ) ;
10093 --            SAVER(J+1) := MOVETO(JJ) ;
10094 --            SAVER(J+2) := REWARD(JJ) ;
10095 --            SAVER(J+3) := SCORE(JJ) ;
10096 -8          END ;
10097 -7        END ;
10098 --        SAVER(0) := J ;
10099 --        EXCLUDE := FALSE ;
10100 -6      END OF_SAVE_THE_MOVES ;
10101 --  
10102 --      PROCEDURE DISCARD_SUBTREES (INTEGER VALUE FIRST) ;
10103 6-      BEGIN
10104 --        INTEGER SAVE_P ;
10105 --  
10106 --        if POINT < 0 then
10107 --           write("DISCARD_SUBTREE Trouble point < 0", POINT) ;
10108 --        FOR I := FIRST STEP -1 UNTIL 1
10109 --        DO MARK := MARKTREE(NODETO(ROOT,I), ROOT, LEVEL*packer, 0) ;
10110 --        comment Perhaps leave getnode, maxl and reuse unchanged if point = 0 ;
10111 --        SAVE_P := POINT + 1 ;
10112 --        IF POINT > 0
10113 7-        then BEGIN
10114 --          REUSE := REUSE - POINT ;
10115 --          POINT := 0 ;
10116 --          FOR I := SAVE_P UNTIL MAXL
10117 8-          DO BEGIN
10118 --            POINT := POINT + 1 ;
10119 --            GETNODE(POINT) := GETNODE(I) ;
10120 -8          END ;
10121 -7        END else POINT := MAXL ;
10122 --        IF TEST
10123 --        THEN WRITE("DISC", FIRST, IDONE, ROOT, LEVEL, SAVE_P, MAXL, REUSE) ;
10124 --        IF TEST THEN WRITEON(POINT, GETNODE(1)) ;
10125 --        MAXL := POINT ;
10126 --        POINT := 0 ;
10127 --        if REUSE <= POINT
10128 --        then REUSE := MAXL ;
10129 --        GETNODE(MAXL+1) := 0 ;
10130 --        DISCARD := TRUE ;
10131 -6      END OF_DISCARD_SUBTREES ;
10132 --  
10133 --  @TITLE, "BUILD_SACR_TREE"
10134 --          comment start of BUILD_SACR_TREE (ROOT, DEPTH, BOUND ...) ;
10135 --      IF DEPTH <= MAXPLY AND LEVEL > 4
10136 6-      THEN BEGIN
10137 --        IF SAC_ALPHA < BOUND AND SAC_BETA > BOUND
10138 --        THEN SAC_BETA := -BOUND ;
10139 -6      END ;
10140 --      IF DEPTH <= MAXPLY
10141 6-      THEN BEGIN
10142 --        NARROW := LEVEL > 2 AND ~INCHECK ;
10143 --        LEVEL := LEVEL + 1 ;
10144 --        K := -K ;
10145 -6      END ELSE IF SAC_ALPHA < BOUND AND SAC_BETA > BOUND
10146 --               THEN SAC_ALPHA := BOUND ;
10147 --      EXCLUDE := LEVEL < MAXDEPTH ;
10148 --      EXTEND := LEVEL = 2 ;
10149 --      FIRSTtime := TRUE ;
10150 --      BESTSCR := SACR_TREE(IF EXTEND THEN 2 ELSE DEPTH, SAC_ALPHA, SAC_BETA, SAVER) ;
10151 --      IF DEPTH <= MAXPLY
10152 6-      THEN BEGIN
10153 --        LEVEL := LEVEL - 1 ;
10154 --        K := -K ;
10155 -6      END ;
10156 --      STATES(ROOT,3) := CAPT_T := 1 ;
10157 --      RESTORESTATE(ROOT) ;
10158 --      IF DEPTH > MAXPLY
10159 --      THEN INSERT_NEW_MOVES(SAVER)
10160 --      ELSE SCORE(TRY(1)) := BESTSCR ;
10161 --      ALTERNATIVE := FALSE ;
10162 --      SCORE(TRY(1)) + DEPTH
10163 -5    END OF_BUILD_SACR_TREE ;
10164 --  
10165 --    PROCEDURE REFUTE (INTEGER VALUE MV) ;
10166 5-    BEGIN
10167 --      INTEGER I, DENIER, sf, st ;
10168 --         comment refut(level,0) is the number of cut-offs that occurred
10169 --                 at depth "level".  refut(level,i) is the "i-th" such cut-off
10170 --                 move.  refcnt(level,i) is the frequency with which the
10171 --                 i-th cut-off was used. ;
10172 --  
10173 --      DENIER := I := REFUT(LEVEL,0) ;
10174 --      WHILE I > 0
10175 6-      DO BEGIN
10176 --        IF REFUT(LEVEL,I) = MV
10177 --        THEN GOTO DELTA ;
10178 --        I := I - 1 ;
10179 -6      END ;
10180 --      IF DENIER < 10
10181 6-      THEN BEGIN
10182 --        I := REFUT(LEVEL,0) := DENIER + 1 ;
10183 --        REFUT(LEVEL,I) := MV ;
10184 -6      END ; comment only track up to 10 cut-offs (deniers) at any one level ;
10185 --  DELTA:
10186 --      REFCNT(LEVEL,I) := REFCNT(LEVEL,I) + 1 ;
10187 --      IF TEST
10188 --      THEN WRITE("REFUT ", LEVEL, path, MV, I, DENIER, REFCNT(LEVEL,I)) ;
10189 --      IF LEVEL > 1 THEN
10190 --         FOR I := LEVEL UNTIL MAX_PLIES
10191 --         DO REFTAB(PATH+LEVEL-2,I) := REFTAB(PATH+LEVEL-1,I) ;
10192 -5    END OF_REFUTE ;
10193 --  
10194 --    LOGICAL PROCEDURE DUPLICATE (INTEGER VALUE NODE) ;
10195 5-    BEGIN
10196 --      INTEGER J, LL ;
10197 --      LOGICAL DUPLICATE ;
10198 --  
10199 --      DUPLICATE := false ;
10200 --      LL := POINT + 1 ;
10201 --      if (ll <= 0) then
10202 --        write("Serious error in DUPLICATE", ll, POINT, NODE)
10203 --      else
10204 --      FOR I := LL UNTIL MAXL
10205 --      DO IF (NODE = GETNODE(I))
10206 6-         THEN BEGIN
10207 --           REC := REC + 1 ;
10208 --           REC_S := REC_S + ABS(STATES(NODE,4)) ;
10209 --           J := GETNODE(I) ;
10210 --           GETNODE(I) := GETNODE(LL) ;
10211 --           GETNODE(LL) := J ;
10212 --           duplicate := true ;
10213 --           if MONITOR then
10214 --           write("Replicant swap location", i, J, GETNODE(i), NODE, NODETO(NODE,1)) ;
10215 --           FINAL := 5 ;
10216 --           NODETO(NODE,0) := NODETO(NODE,1) := 0 ;
10217 --           GO TO QUIT ;
10218 -6      END ;
10219 --      duplicate := false ;
10220 --      FINAL := 2 ;
10221 --      DUP := DUP + 1 ;
10222 --  QUIT:
10223 --      IF TEST
10224 --      THEN WRITEON(NODE, IF (FINAL = 2) THEN "DUPLIC. " ELSE "FLOATER ",
10225 --                   PARENT(NODE), STATES(NODE,2), STATES(NODE,T_SIZE+2+1), "&") ;
10226 --      DUPLICATE
10227 --       comment duplicate POSITION CHECKER ;
10228 -5    END OF_DUPLICATE ;
10229 --  
10230 --    LOGICAL PROCEDURE NODAL ;
10231 5-    BEGIN
10232 --      INTEGER D ;
10233 --                   COMMENT   check for duplicate position ;
10234 --      IF OLD AND NODE > 0 AND NEW_HASH = STATES(NODE, T_SIZE)
10235 --      THEN GO TO FOUNDUPLICATE ;
10236 --      FOR NODEX := 1 UNTIL MAXTREE
10237 --      DO IF NEW_HASH = STATES(NODEX,T_SIZE) AND K ~= STATES(NODEX,1)
10238 --         THEN IF OLD OR FINAL = 5 OR ROOT ~= PARENT(NODEX) REM packer
10239 6-              THEN BEGIN
10240 --                NODE := NODEX ;
10241 --                IF (DUPLICATE(NODE))
10242 --                THEN GO TO FOUNDUPLICATE ;
10243 -6      END ;
10244 --      FINAL := 0 ;
10245 --      OLD := FALSE ;
10246 --      if NODE = 0 then
10247 --        goto EXIT ;
10248 --  FOUNDUPLICATE:
10249 --      IF REVERSIBLE AND (ENDGAME OR FINAL > 0 OR LEVEL <= 2)
10250 6-      THEN BEGIN
10251 --        D := 0 ;
10252 --        FOR J := 1 UNTIL ENDPLAY
10253 --        DO IF (NEW_HASH = REPEATS(J))
10254 --           THEN D := D + 1 ;
10255 --        FOR J := 1 UNTIL LEVEL - 1
10256 --        DO IF NEW_HASH = STACK_HASH(J)
10257 --           THEN D := D + 1 ;
10258 --        IF D > 0
10259 7-        THEN BEGIN
10260 --          ANOTHER := TRUE ;
10261 --          SCR := STATES(ROOT, T_SIZE+2+IP) ;
10262 --          IF TEST
10263 --          THEN WRITE("DRAWING", D, FINAL, IP, ROOT, SCR, NEW_HASH, OLD) ;
10264 --          IF D > 1 OR SCR <= DRAW AND SIDE = -1
10265 --          THEN FINAL := 3
10266 --          ELSE FINAL := 1 ;
10267 --          IF FINAL = 3 THEN
10268 --          STATES(ROOT,T_SIZE+2+IP) := -SIDE*DRAW ;
10269 -7        END ;
10270 -6      END ;
10271 --      IF (FINAL > 0)
10272 6-      THEN BEGIN
10273 --        IF (FINAL = 2) AND (LEVEL > 2)
10274 --        THEN IF (NODE = ORIGIN)
10275 --             THEN FINAL := 3
10276 --             ELSE LOCATE(NODETO(ORIGIN,PATH), NODE, ROOT, packer) ;
10277 --        IF (FINAL = 2)
10278 --        THEN IF (packer*LEVEL > PARENT(NODE))
10279 --             THEN FINAL := 1 ;
10280 --        IF (FINAL = 3) OR (FINAL = 1)
10281 7-        THEN BEGIN
10282 --                            COMMENT repetition loop detected, draw ;
10283 --          SCR := IF (FINAL = 3)
10284 --                 THEN DRAW
10285 --                 ELSE -STATES(NODE, T_SIZE+2+1) ;
10286 --          IF FINAL = 1
10287 --          THEN OLD := TRUE ;
10288 --                         COMMENT reject ;
10289 --          IF FINAL = 3 OR SIDE = -1
10290 --          THEN ANOTHER := TRUE ;
10291 --          GO TO EXIT ;
10292 -7        END ;
10293 --        D := ABS(STATES(NODE,4)) ;
10294 --        IF D = 0 AND FINAL ~= 3
10295 --        THEN WRITE("INCONSISTENT DRAW", FINAL, D) ;
10296 --        IF (FINAL = 2)
10297 --        THEN OLD := TRUE ;
10298 --        IF OLD OR FINAL = 3
10299 --        THEN DUP_S := DUP_S + (IF D = 0
10300 --                               THEN 1
10301 --                               ELSE D) ;
10302 -6      END ;
10303 --  EXIT:
10304 --      ANOTHER
10305 -5    END OF_NODAL ;
10306 --  
10307 --    PROCEDURE MAKE_SPACE (INTEGER VALUE ORIGIN, REPLY, PATH, DEPTH, EST) ;
10308 5-    BEGIN
10309 --      INTEGER TEMP, LX, NOD, OLDMAXL, tmp ;
10310 --      logical display ;
10311 --  
10312 --      display := false ;
10313 --  
10314 --      comment Perhaps leave getnode, maxl and reuse unchanged if point = 0 ;
10315 --      IF POINT > 0
10316 6-      THEN BEGIN
10317 --        LX := POINT + 1 ;
10318 --        REUSE := REUSE - POINT ;
10319 --        POINT := 0 ;
10320 --        FOR I := LX UNTIL MAXL
10321 7-        DO BEGIN
10322 --          POINT := POINT + 1 ;
10323 --          GETNODE(POINT) := GETNODE(I) ;
10324 -7        END ;
10325 --        MAXL := POINT ;
10326 --        GETNODE(MAXL+1) := 0 ;
10327 --        POINT := 0 ;
10328 --        if REUSE <= POINT
10329 --        then REUSE := MAXL ;
10330 -6      END ;
10331 --      FIRST := IF ORIGIN > 0
10332 --               THEN NODETO(ORIGIN,0)
10333 --               ELSE 0 ;
10334 --                  COMMENT mark subtree of best move.  Note cannot mark subtree
10335 --                          of current path, since part of it may have been discarded
10336 --                          and re-used elsewhere.  See 12 Feb. 76 Belzerowski game ;
10337 --      LX := IF REPLY > 0 AND REPLY ~= PATH
10338 --            THEN REPLY
10339 --            ELSE IF PATH = 0
10340 --                 THEN 1
10341 --                 ELSE 0 ;
10342 --                                  COMMENT node collection, about to regain space ;
10343 --      IF warning and ORIGIN < 0
10344 --      THEN WRITE("MAKE_SPACE -ve origin ", ORIGIN, REPLY, PATH, FIRST, LX, MAXL,
10345 --                  EST, GETNODE(1))
10346 6-      else begin
10347 --        FOR I := FIRST STEP -1 UNTIL 1
10348 --        DO IF I ~= LX AND I ~= PATH
10349 7-           THEN begin
10350 --             MARK := MARKTREE(NODETO(ORIGIN,I), ORIGIN, DEPTH, 0) ;
10351 -7           end ;
10352 --        IF LX > 0
10353 7-        THEN begin
10354 --          MARK := MARKTREE(NODETO(ORIGIN,LX), ORIGIN, DEPTH, 0) ;
10355 -7        end ;
10356 --        IF PATH > 0
10357 7-        THEN begin
10358 --          MARK := MARKTREE(NODETO(ORIGIN,PATH), ORIGIN, DEPTH, 0) ;
10359 -7        end ;
10360 --            comment  moot, trying to ensure PATH nodes are marked last ;
10361 --        FOR LX := FIRST STEP -1 UNTIL 1
10362 --        DO IF REPLY <= 0 AND PATH <= 0 AND (LX ~= 1 OR PATH < 0)
10363 7-           THEN BEGIN
10364 --             COLLECT(NODETO(ORIGIN,LX), ORIGIN) ;
10365 --             NODETO(ORIGIN,LX) := -1 ;
10366 --             IF TEST
10367 --             THEN WRITE("FULL PURGE", ROOT, LX, MAXL) ;
10368 -7           END ELSE IF (MAXL - POINT <= EST) AND (LX ~= REPLY) AND (LX ~= PATH)
10369 7-                    THEN BEGIN
10370 --                      TEMP := NODETO(ORIGIN,LX) ;
10371 --                      IF TEMP > 0
10372 8-                      THEN BEGIN
10373 --                        OLDMAXL := MAXL ;
10374 --                        comment omit this patch. It only causes node re-creation
10375 --                        if NODETO(TEMP,0) <= 0
10376 --                        then COLLECT(TEMP, PARENT(TEMP) rem packer) ;
10377 --                        FOR J := (IF REPLY = 0 AND PATH = 0
10378 --                                   THEN 2
10379 --                                   ELSE 1) UNTIL NODETO(TEMP,0)
10380 9-                        DO BEGIN
10381 --                          COLLECT(NODETO(TEMP,J), TEMP) ;
10382 --                          IF TEST AND MAXL > OLDMAXL
10383 --                          THEN WRITE("SUBTREE discard", LX, J, NODETO(TEMP,J), MAXL) ;
10384 --                          NODETO(TEMP,J) := -1 ;
10385 -9                        END ;
10386 -8                      END ;
10387 -7        END ;
10388 -6      end;
10389 --      IF (IP <= MIN_WID) AND (REPLY > 0) AND (MAXL - POINT <= EST)
10390 --          AND (LEVEL <= 2 OR LEVEL = 3 AND IP < 2 OR INCHECK)
10391 --      THEN IF REPLY ~= PATH
10392 6-           THEN BEGIN
10393 --             TEMP := NODETO(ORIGIN,REPLY) ;
10394 --                            COMMENT about to take some nodes from the PV ;
10395 --             IF TEST
10396 --             THEN WRITE("REPLY DISCARD", TEMP, NODETO(temp,0), MAXL, est) ;
10397 --             IF TEMP > 0
10398 --             THEN FOR LX := NODETO(TEMP,0) STEP -1 UNTIL 1
10399 --                  DO IF MAXL - POINT <= EST
10400 7-                     THEN BEGIN
10401 --                       COLLECT(NODETO(TEMP,LX), TEMP) ;
10402 --                       NODETO(TEMP,LX) := -1 ;
10403 --                       IF TEST
10404 --                       THEN WRITEON(":", LX, MAXL) ;
10405 -7                     END ;
10406 -6           END
10407 --           ELSE
10408 --           IF MAXL = 0
10409 6-           THEN BEGIN
10410 --             NOD := NODETO(ORIGIN,1) ;
10411 --             if nod <= 0
10412 --             then write("No point in going further ", ORIGIN, NODETO(ORIGIN,0), nod)
10413 7-             else begin
10414 --               temp := (DEPTH+packer) DIV packer ;
10415 --               IF NOD = ROOTNODE(temp)
10416 8-               THEN BEGIN
10417 --                     comment which "rootnode" value do we seek ??? ;
10418 --                 MAXL := 0 ;
10419 9-                 if warning and temp > LEVEL then begin
10420 --                   WRITE("MAKE_SPACE no nodes ", LEVEL, temp, DEPTH, EST, NOD,
10421 --                        NODETO(nod,0)) ;
10422 --                   display := true ;
10423 --                   FOR LX := 1 UNTIL LEVEL
10424 --                   DO WRITEON(ROOTNODE(LX)) ;
10425 -9                 end ;
10426 --                 FOR I := 1 UNTIL NODETO(NOD,0)
10427 9-                 DO begin
10428 --                   tmp := (DEPTH+2*packer) DIV packer ;
10429 --                   IF NODETO(NOD,I) = ROOTNODE(tmp)
10430 10-                  THEN begin
10431 --                     MAKE_SPACE(NOD, 1, I, DEPTH+packer, EST) ;
10432 -10                  end ;
10433 -9                 end ;
10434 -8             end ;
10435 -7           END ;
10436 -6      END ;
10437 --      IF TEST
10438 --      THEN WRITE("####", LEVEL, DEPTH, REPLY, PATH, EST, REUSE, MAXL,
10439 --                   POINT, GETNODE(1), GETNODE(MAXL+1)) ;
10440 --      POINT := 0 ;
10441 --      GETNODE(MAXL+1) := 0 ;
10442 -5    END OF_MAKE_SPACE ;
10443 --  
10444 --    PROCEDURE LOOKingAHEAD ;
10445 5-    BEGIN
10446 --      IP := 0 ;
10447 --      B_SCR := -EIGHTS ;
10448 --      EXTENSION := FALSE ;
10449 --      WHILE (IP < LIMIT) AND (WHO OR FLAG(1) = 0)
10450 6-      DO BEGIN
10451 --        IP := IP + 1 ;
10452 --        N := TRY(IP) ;
10453 --        SCR := SCORE(N) ;
10454 --        REWN := REWARD(N) ;
10455 --        IF IP = MIN_WID AND (SCR <= SCORE(TRY(MIN_WID+1))
10456 --                               OR MIN_WID < TRY(0) AND LEVEL <= 2)
10457 --        THEN MIN_WID := MIN_WID + 1 ;
10458 --        OLD := IF (IP > IDONE) AND ~AGAIN
10459 --               THEN FALSE
10460 --               ELSE TRUE ;
10461 --        IF LEVEL = 1
10462 --        THEN T_TIME := TIME(1) ;
10463 --        IF TEST
10464 7-        THEN BEGIN
10465 --          PRINTLINE(N, LEVEL-1) ;
10466 --          WRITEON(IF PARTIAL THEN "%" ELSE "^",
10467 --                  IF OLD THEN -12345 ELSE PASTSCR, CLEARPAWN(-K), CLEARPAWN(K),
10468 --                  ALPHA, BETA, HASH, IP, idone, again, node) ;
10469 --          if abs(SCORE(N)) > NINES
10470 --          then TRACER(2, if K = -1 then "?PW" else "?PB") ;
10471 -7        END ;
10472 --        IF OLD
10473 7-        THEN BEGIN
10474 --          NODE := NODETO(ROOT,IP) ;
10475 --          IF (NODE < 0)
10476 8-          THEN BEGIN
10477 --            OLD := FALSE ;
10478 --            FINAL := -3 ;
10479 -8          END ELSE IF (PARENT(NODE) REM packer ~= ROOT)
10480 8-                   THEN begin
10481 --                     NODE := NIL ;
10482 -8                   end ;
10483 -7        END ELSE
10484 7-        begin
10485 --          if NODETO(ROOT,IP) > 0 then
10486 --          if IP <= NODETO(ROOT,0)
10487 8-          then begin
10488 --            if warning then
10489 --              write("LOOKing delete node", NODETO(ROOT,IP), IP, "<=", NODETO(ROOT,0)) ;
10490 --            if warning then
10491 --              write("Not returning", NODETO(ROOT,IP), " to getnode list? ") ;
10492 --          end else begin
10493 --              comment here we know that IP > NODETO(ROOT,0) and therefore that
10494 --                    NODETO(ROOT,IP) has not yet been linked into the tree ;
10495 --  
10496 --            if TEST and NODETO(ROOT,0) > 0 then
10497 --              for j := NODETO(NODETO(ROOT,IP),0) step -1 until 1 do
10498 --                if NODETO(NODETO(ROOT,IP),j) > 0 then
10499 --                  if PARENT(NODETO(ROOT,IP)) rem packer = ROOT then
10500 --                    write("LOOKing-2 Will lose node", NODETO(ROOT,IP)) ;
10501 -8          end ;
10502 --          NODETO(ROOT, IP) := 0 ;
10503 -7        end ;
10504 --        SEEN := QUIES(TRY(IP)) ;
10505 --        ANOTHER := FALSE ;
10506 --        SHAH := IF (ABS(REWN) < REALCHECK)
10507 --                THEN FALSE
10508 --                ELSE TRUE ;
10509 --                                     COMMENT also expand tree if large epgain ;
10510 --        IF (LEVEL = 1)
10511 7-        THEN BEGIN
10512 --          PATH := IP ;
10513 --          PLEX := 0 ;
10514 --          MX := AB(1) := -NINES ;
10515 --          MAXSC(IP) := SCR - 1 ;
10516 --          INIT_T_NODES := T_NODES := 0 ;
10517 --          IF MAXDEPTH = 1
10518 8-          THEN BEGIN
10519 --            REPLY := 1 ;
10520 --            FINAL := 0 ;
10521 --            MX := MOST := B_SCR := SCR ;
10522 --            IF (IDONE > 0)
10523 --            THEN GO TO QUIT ;
10524 --            if NODETO(ROOT,1) > 0 then
10525 --              write("LOOKing quit root/nodeto(root,0/1)",
10526 --                    ROOT, NODETO(ROOT,0), NODETO(ROOT,1)) ;
10527 --            NODETO(ROOT,0) := 1 ;
10528 --            NODETO(ROOT,1) := NIL ;
10529 --            GO TO QUIT ;
10530 -8          END ;
10531 -7        END ;
10532 --        REFTAB(PATH+LEVEL-1,LEVEL) := 1000*MOVEFROM(N) + MOVETO(N) ;
10533 --        MAKEMOVE(N, TRUE) ;
10534 --        NEW_HASH := HASH ;
10535 --        IF OLD AND NODE ~= NIL AND NEW_HASH ~= STATES(NODE, T_SIZE)
10536 7-        THEN BEGIN
10537 --          OLD := FALSE ;
10538 --                  COMMENT The node we were pointing to was not a proper successor
10539 --                          of the previous position. Should only occur deep in the
10540 --                          tree, and should be infrequent ;
10541 --          printshortbrd(-1) ;
10542 --          WRITE("DISASTER, bad HASH AVOIDED",
10543 --                 LEVEL, NODE, PARENT(NODE), NODETO(NODE,0), NODETO(NODE,1),
10544 --                 T_HASH, NEW_HASH, STATES(NODE, T_SIZE)) ;
10545 --          write("stack ") ;
10546 --          for i:=1 until LEVEL
10547 --            do writeon(stack_hash(i));
10548 --          write("prior ") ;
10549 --          for i:=1 until endplay
10550 --            do writeon(repeats(i)) ;
10551 --          write("k/m2/m3/m4/m5/ksq", k, m2, m3, m4, m5, ksq) ;
10552 --          TRACER(1, "?G") ;
10553 --          NODE := NIL ;
10554 -7        END ;
10555 --        IF TEST
10556 --        THEN WRITE("Credit/Debit/root", CREDIT(LEVEL), DEBIT(LEVEL-1), "R=", ROOT) ;
10557 --        MORE := SHAH OR INCHECK ;
10558 --        DYNAMIC := IF INCHECK OR ~EARLY AND (SHAH OR (REWN < 0))
10559 --                      OR (SIDE = -1) AND (GARDE OR (REWN < 0))
10560 --                   THEN TRUE
10561 --                   ELSE FALSE ;
10562 --        IF (CON(-K,KINGSQ(K)) ~= 0)
10563 7-        THEN BEGIN
10564 --                      COMMENT illegal move "impossible" ;
10565 --          SCR := EIGHTS*SIDE ;
10566 --                      COMMENT A King is in check and the other side has the move ;
10567 --          WRITE("IMPOSSIBLE", K, KINGSQ(K), CON(-K,KINGSQ(K)), KINGSQ(-K))
10568 --           ;
10569 --          TRACER(2, "?PD") ;
10570 --          ANOTHER := TRUE ;
10571 --          FINAL := -3 ;
10572 --          GO TO EXIT ;
10573 -7        END ;
10574 --        IF ~OLD OR (NODE = NIL)
10575 --        THEN IF (ROOT = NIL) OR NODAL
10576 --             THEN GO TO EXIT ;
10577 7-        IF FINAL >= 1 THEN BEGIN
10578 --          IF TEST or IP <= NODETO(ROOT,0) and NODETO(ROOT,IP) > 0 THEN
10579 --             WRITE("RECLAIM ", SCR, NODE, PARENT(NODE), packer*LEVEL,
10580 --                      ROOT, IP, NODETO(ROOT,0), NODETO(ROOT,IP),
10581 --                      STATES(NODE,2), DEEPER, STATES(NODE,3), STATES(NODE,5)) ;
10582 --          if NODETO(ROOT,IP) > 0 then
10583 --            write("LOOKing ip/nodeto(root,0)/nodeto(root,ip) lost",
10584 --                  IP, NODETO(ROOT,0), NODETO(ROOT,IP)) ;
10585 --          NODETO(ROOT,IP) := 0 ;
10586 -7        END ;
10587 --        IF (OLD OR FINAL = 5) AND NODE > NIL AND packer*LEVEL >= PARENT(NODE)
10588 --             AND STATES(NODE,2) > DEEPER AND ~INCHECK AND ~AGAIN
10589 7-        THEN BEGIN
10590 --                            COMMENT extension into lower subtree ;
10591 --          FINAL := 1 ;
10592 --          ANOTHER := TRUE ;
10593 --          PP_STATUS := 0 ;
10594 --          SCR := -STATES(NODE, T_SIZE+2+1) ;
10595 --          IF TEST
10596 --          THEN WRITEON("&&&", NODE, SCR, PARENT(NODE), FINAL) ;
10597 --          GO TO EXIT ;
10598 -7        END ;
10599 --        INCREASE := 0 ;
10600 --  
10601 --        IF GIVINGCH or EXTENSION OR DYNAMIC
10602 --           OR (NUM < 10) AND ~EARLY
10603 --           OR SIDE < 0 AND (IP = 1)
10604 --        THEN IF DEEPER <= 1 AND LEVEL + 1 < MAXDEPTH
10605 --             THEN INCREASE := IF (DEEPER > 0) AND (SIDE = -1)
10606 --                                 OR DEEPER = 0 AND SIDE = 1
10607 --                              THEN 1
10608 --                              ELSE 2 ;
10609 --        IF INCREASE = 0 AND OLD AND DYNAMIC AND DEEPER = 0
10610 --           AND LEVEL < MAXDEPTH AND LEVEL > MINDEPTH
10611 --        THEN INCREASE := 1 ;
10612 --           comment rarely is increase > 0 at this point ;
10613 --        IF (TEST) AND (INCHECK OR INCREASE > 0)
10614 --        THEN WRITE("INC1 increase/deeper/side/level/length/givingch/extension/dynamic/ip",
10615 --                   INCREASE, DEEP, DEEPER, SIDE, LEVEL, LENGTH, givingch, extension, dynamic, IP) ;
10616 --    if INCREASE = 0 then
10617 7-    begin
10618 --        if (incheck or givingch) and LEVEL < max_plies
10619 --                         or side = 1 and LEVEL = max_plies - 1
10620 --        then increase := 1 else
10621 --        IF LEVEL > LENGTH
10622 --        THEN INCREASE := 0
10623 --        ELSE IF EXTENSION AND LEVEL <= MAXDEPTH
10624 --               OR (INCHECK OR PP_STATUS >= 10 OR M14 ~= 0 OR LATE_END AND PP_STATUS > 0)
10625 --                 AND LEVEL >= MINDEPTH AND INCREASE = 0
10626 --                 AND (LEVEL + DEEPER < MAXDEPTH OR LEVEL <= 3 AND LEVEL = MAXDEPTH
10627 --                      AND DEEPER = 0)
10628 --             THEN INCREASE := (IF SIDE = -1
10629 --                                THEN 2
10630 --                                ELSE 1) ;
10631 --  
10632 --        IF (TEST) AND (INCHECK OR INCREASE > 0)
10633 --        then write("INC2  incheck/ip/pp_status/m14/mindepth/deeper/maxdepth/side",
10634 --             incheck, IP, PP_STATUS, m14, mindepth, deeper, maxdepth, side) ;
10635 -7    end ;
10636 --  
10637 --        IF (LEVEL >= MAXDEPTH) AND LEVEL > DEEP + 1 AND (~INCHECK
10638 --            AND PP_STATUS < 10 AND M14 = 0 AND (~LATE_END OR PP_STATUS = 0)
10639 --            OR LEVEL > LENGTH AND SIDE = -1)
10640 --        THEN FINAL := -6
10641 --        ELSE IF ROOT = NIL
10642 --             THEN FINAL := -6
10643 --             ELSE IF EXPAND
10644 --                  THEN GO TO LOOP ;
10645 --        IF FINAL = -4 OR FINAL = -5
10646 --        THEN GO TO QUIT ;
10647 --  EXIT:
10648 --        IF TERMINATE
10649 --        THEN GO TO QUIT ;
10650 --                         COMMENT if drawing or rejecting, point to dummy node 0
10651 --                                 and examine next move ;
10652 --        IF (IDONE < IP) AND ~ EXTENSION
10653 7-        THEN BEGIN
10654 --          if (MONITOR) and IP ~= NODETO(ROOT,0) then
10655 --            write("Changing nodeto(root,0)", NODETO(ROOT,0), IP, idone) ;
10656 --          NODETO(ROOT,0) := IP ;
10657 --          COMMENT NODETO(ROOT,IP) := NIL ;
10658 -7        END ;
10659 --                COMMENT IF SIDE*MX > -B_SCR THEN MX := -B_SCR ;
10660 --        IF TEST
10661 --        THEN WRITE(REASON(FINAL), "EXPANSION level/ab(L)/extension/b_scr/mx/side",
10662 --                 LEVEL, AB(LEVEL), EXTENSION, B_SCR, mx, side)
10663 --            ;
10664 --        IF ((AB(LEVEL) - MX)*SIDE > 0)
10665 --        THEN AB(LEVEL) := MX ;
10666 --        OLDSCR := LASTSCR ;
10667 --        PREVSCR := PASTSCR ;
10668 --        IF PARTIAL AND IP < LIMIT AND SCORE(TRY(IP+1)) < BETA AND IP > 0
10669 7-        THEN BEGIN
10670 --                              COMMENT for some reason the beta bound has increased,
10671 --                                      so a full evaluation is not required ;
10672 --          if IP > 1 and warning then
10673 --          WRITE("EMERGENCY in LOOKingAHEAD, setting IP to Zero", IP, SCORE(TRY(IP+1)), BETA) ;
10674 --          IP := 0 ;  comment re-do a partially evaluated line ;
10675 --          UPPER := EIGHTS ;
10676 --          PARTIAL := FALSE ;
10677 --          PART := PLEX := 0 ;
10678 --          LISTLEGALMOVES(FALSE) ;
10679 --          HASH := T_HASH ;
10680 --          SAVESTATE(ROOT) ;
10681 -7        END ;
10682 --  LOOP:
10683 --        IF IP > 0 AND ~EXTENSION
10684 --        THEN LIMITS ;
10685 --        IF (TEST) AND LEVEL = 1
10686 --        THEN WRITE("TIMES", IP, MIN_WID, LIMIT, TIME(1)-OLDCPU, M_TIMES(MODE),
10687 --                   MODE, MX, B_SCR) ;
10688 -6      END ;
10689 --                         COMMENT limit of variations ;
10690 --  QUIT:
10691 --  
10692 -5    END OF_LOOKingAHEAD ;
10693 --  
10694 --    LOGICAL PROCEDURE EXPAND ;
10695 5-    BEGIN
10696 --      LOGICAL EXP, ABANDONNED, xxx ;
10697 --      INTEGER TEMP, I, MP, GAP, NOD, LEV, FROM, TOTO, NODEX, STATE,
10698 --              CHANGE, BASE_SCR, EST_spa ;
10699 --      LOGICAL ARRAY FULLEVAL(1::MAX_WID) ;
10700 --  
10701 --      EXP := FALSE ;
10702 --      EST_spa := MINTREE(LEVEL) DIV 2 ;
10703 --      IF (MAXL - POINT < EST_spa) AND ~OLD
10704 6-      THEN BEGIN
10705 --        MAKE_SPACE(ORIGIN, 1, PATH, packer, EST_spa) ;
10706 --        LEV := 2 ;
10707 --        NOD := ROOTNODE(2) ;
10708 --        WHILE (MAXL - POINT < EST_spa) AND (LEV < LEVEL)
10709 7-        DO BEGIN
10710 --          LEV := LEV + 1 ;
10711 --          FOR I := 1 UNTIL NODETO(NOD,0)
10712 --          DO IF NODETO(NOD,I) = ROOTNODE(LEV)
10713 8-             THEN begin
10714 --               MAKE_SPACE(NOD, 1, I, packer*LEV, EST_spa) ;
10715 -8             end ;
10716 --          IF TEST
10717 --          THEN WRITE("NO ROOM?", LEV, LEVEL, NOD, MAXL-POINT, EST_spa) ;
10718 --          NOD := ROOTNODE(LEV) ;
10719 -7        END ;
10720 -6      END ;
10721 --      IF GIVINGCH OR OLD OR FINAL = 5 OR SIDE = 1 OR INCREASE > 0
10722 --        OR ((MAXL >= POINT) AND (FORCED AND (LEVEL > 2)))
10723 --        OR (MAXL - POINT >= EST_spa) AND ((IP <= MIN_WID)
10724 --             OR (MOST <= EXPECT + EPSILON) OR LEVEL = 1 AND MOST < SCR)
10725 6-      THEN BEGIN
10726 --        IF (DEEPER > 0 OR INCREASE > 0 OR OLD) AND (INCHECK or GIVINGCH
10727 --           OR LEVEL ~= DEEP OR IP <= MIN_WID)
10728 7-        THEN BEGIN
10729 --                  COMMENT abreviate search if excessive CPU time on this 
10730 --                          variation, and not in check ;
10731 --          IF ~OLD OR FINAL = 5
10732 8-          THEN BEGIN
10733 --            IF SIDE = 1 AND POINT >= MAXL
10734 --            THEN NODE := 0
10735 9-            ELSE BEGIN
10736 --              IF POINT < MAXL
10737 10-             THEN BEGIN
10738 --                POINT := POINT + 1 ;
10739 --                NODE := GETNODE(POINT) ;
10740 -10             END ELSE NODE := NIL ;
10741 -9            END ;
10742 --            NODETO(NODE,0) := IF FINAL = 5 AND NODETO(NODE,0) >= 0
10743 --                              THEN 0
10744 --                              ELSE -1 ;
10745 -8          END ;
10746 --          IF TEST
10747 --          THEN WRITE("Using node", NODE, ROOT, old, final, NODETO(NODE,0),
10748 --                      NODETO(ROOT,0), ip, t_nodes, LEVEL, POINT) ;
10749 --          if node <= 0 and root <= 0 then
10750 --          write("Question node/root/point/maxl/getnode(point)/old/final/side",
10751 --                 node, root, point, maxl, getnode(point), old, final, side) ;
10752 --          PARENT(NODE) := ROOT + LEVEL*packer ;
10753 --          IF (NODETO(ROOT,0) < IP)
10754 --          THEN NODETO(ROOT,0) := IP
10755 8-          else if NODETO(ROOT,IP) ~= NODE then begin
10756 --            if NODETO(ROOT,IP) > 0
10757 --            then write("Using-Error, replacing node", NODETO(ROOT,IP), "with",
10758 --                      NODE, IP, "=", NODETO(ROOT,0));
10759 --            Reclaim_Node(NODETO(ROOT,IP), "EXPAND") ;
10760 -8          end ;
10761 --          NODETO(ROOT,IP) := NODE ;
10762 --          T_NODES := T_NODES + 1 ;
10763 --          PREVSCR := OLDSCR ;
10764 --          OLDSCR := SCR ;
10765 --          BASE_SCR := SCR ;
10766 --          SAVEBACK(LEVEL, TRUE) ;
10767 --          K := -K ;
10768 --          LEVEL := LEVEL + 1 ;
10769 --                            COMMENT  switchsides. ;
10770 --          IF PRINCVAR AND IP > 1 AND ~AGAIN
10771 --          THEN FULLWIN := FALSE ;
10772 --          IF ~AGAIN
10773 8-          THEN BEGIN
10774 --            LOWER := IF B_SCR > ALPHA
10775 --                     THEN B_SCR
10776 --                     ELSE ALPHA ;
10777 --            HIGHER := IF FULLWIN OR IP = 1
10778 --                      THEN BETA
10779 --                      ELSE LOWER + 1 ;
10780 --            L_SCR := HIGHER ;
10781 -8          END ;
10782 --          T_SCR := - TREE(-HIGHER, -LOWER, NEW_HASH, DEEPER+INCREASE-1,
10783 --                           PRINCVAR AND FULLWIN, F_T) ;
10784 --          IF TEST THEN
10785 --             WRITE("SCORE level/ip/root/states(,)/t_scr/b_scr/mx/f_t",
10786 --               LEVEL, IP, ROOT, STATES(ROOT,T_SIZE+2+IP), T_SCR, B_SCR, MX, F_T) ;
10787 --          IF TEST AND PRINCVAR
10788 --          THEN WRITE("PAB-in expand", IP, AGAIN, HIGHER, LOWER, B_SCR, T_SCR,
10789 --                     FULLWIN, PRINCVAR, L_SCR, MX, MOST, EXTENSION) ;
10790 --          IF EXTENSION
10791 --          THEN EXTENSION := ANOTHER := FALSE ;
10792 --          IF T_SCR > B_SCR OR AGAIN AND T_SCR > L_SCR
10793 8-          THEN BEGIN
10794 --            IF AGAIN
10795 9-            THEN BEGIN
10796 --              IF CNT > 0
10797 10-             THEN begin
10798 --                WRITE ("PAB InfiniteError-loop avoidance in EXPAND.") ;
10799 --                WRITE("  Inadequate nodespace. ",
10800 --                        LOWER, T_SCR, HIGHER, b_scr, l_scr, again, IP, cnt,
10801 --                        exp, princvar, LEVEL, deep, deeper) ;
10802 --                    comment initially controlled indirectly in TERMINATE by:
10803 --                         IF PRINCVAR AND SCR > MOST
10804 --                                     and VAR_TIME - T_TIME < M_TIMES(0) ;
10805 --                    comment and later also by the test "and CNT < 3" below ;
10806 -10             end ;
10807 --              CNT := CNT + 1 ;
10808 --              B_SCR := IF T_SCR > L_SCR
10809 --                       THEN T_SCR
10810 --                       ELSE L_SCR ;
10811 -9            END ELSE
10812 9-            BEGIN
10813 --              CNT := 0 ;
10814 --              L_SCR := B_SCR ;
10815 --              B_SCR := T_SCR ;
10816 -9            END ;
10817 --            IF PRINCVAR AND IP > 1 and CNT < 3
10818 --            THEN IF ~AGAIN OR T_SCR > HIGHER OR T_SCR < LOWER
10819 9-                 THEN BEGIN
10820 --                   comment IF LEVEL = 1
10821 --                   THEN WRITE("New candidate PV", FIRSTONE, IP, PRINCVAR, cnt,
10822 --                              L_SCR, B_SCR, T_SCR, higher, lower) ;
10823 --                   IOCONTROL(2) ;
10824 --                   IF FIRSTONE = 0 AND LEVEL = 1
10825 --                   THEN FIRSTONE := IP ;
10826 --                   FULLWIN := AGAIN := TRUE ;
10827 --                   HIGHER := EIGHTS ;
10828 --                   LOWER := L_SCR - 1 ;
10829 -9                 END ELSE AGAIN := FALSE ;
10830 -8          END ELSE
10831 8-          BEGIN
10832 --            IF AGAIN
10833 --            THEN B_SCR := L_SCR ;
10834 --            IF (warning or TEST) AND AGAIN AND LEVEL = 1
10835 9-            THEN BEGIN
10836 --              WRITE("    Candidate Rejected", 
10837 --                    again, LEVEL, FIRSTONE, IP, L_SCR, B_SCR, T_SCR) ;
10838 --              IOCONTROL(2) ;
10839 -9            END ;
10840 --            AGAIN := FALSE ;
10841 -8          END ;
10842 --          if CNT < 3 then
10843 --          IF AGAIN
10844 --          THEN EXP := TRUE
10845 8-          ELSE BEGIN
10846 --            IF KTEST ~= 0
10847 9-            THEN begin
10848 --              write("Again expand ktest/ip/root/nodeto(root,ip)") ;
10849 --              write("    ", ktest, IP, ROOT, NODETO(ROOT,IP), NODETO(ROOT,0)) ;
10850 --              NODETO(ROOT,IP) := NIL ;
10851 -9            end ;
10852 --            IF KTEST = 2
10853 --            THEN KTEST := BACK(LEVEL,16) := 0 ;
10854 --            BETTER := NINES ;
10855 --            IF IP = 1 OR SIDE*(MX -AB(LEVEL+1)) > 0
10856 --            THEN MX := BETTER := AB(LEVEL) := AB(LEVEL+1) ;
10857 --                                COMMENT increase width if first move loses ;
10858 --            IF IP = 1 AND DEEPER > 1 AND SIDE < 0 AND SCR - MX > PAWNVALUE
10859 --            THEN MIN_WID := MIN_WID + 1 ;
10860 --              IF TEST
10861 --              THEN WRITE("TEST-1 ", T_SCR, ALPHA ,BETA, BETTER, MX, AB(LEVEL+1)) ;
10862 --            SCORE(TRY(IP)) := STATES(ROOT,T_SIZE+2+IP) := -SIDE*AB(LEVEL+1) ;
10863 --              IF TEST
10864 --              THEN WRITE("TEST-2 ", LEVEL, IP, ALPHA, B_SCR, BETA, F_T, BETTER) ;
10865 --            FINAL := 0 ; ABANDONNED := FALSE ;
10866 --            IF (B_SCR < BETA) AND (LEVEL > 2 OR IP < 4 OR B_SCR > ALPHA)
10867 --            THEN EXP := TRUE
10868 9-            ELSE BEGIN
10869 --              IF B_SCR > ALPHA OR LEVEL > 2 OR IP < 4
10870 --                  OR B_SCR >= SCORE(TRY(IP+1))
10871 10-             THEN begin
10872 --                REFUTE(1000*M2 + M3) ;
10873 -10             end
10874 10-             ELSE BEGIN
10875 --                ABANDONNED := TRUE ;
10876 --                IF TEST THEN
10877 --                   WRITE("ABANDONNED", LEVEL, IP, PLY, DEEP, ALPHA,
10878 --                          B_SCR, BETA, SCORE(TRY(IP+1))) ;
10879 -10             END ;
10880 --              STATES(NODETO(ROOT,IP),2) := 0 ;
10881 --                                COMMENT unreliable subtree ;
10882 --              FINAL := -5 ;
10883 --                                COMMENT reverse prune, already found better line ;
10884 --                                COMMENT or abandon aspiration search early ;
10885 --              IF TEST
10886 --              THEN WRITE("  REVE", LEVEL, ALPHA, B_SCR, BETA, T_SCR,
10887 --                         MX, MOST, PRINCVAR, FULLWIN) ;
10888 --                                COMMENT can now distinguish between no more nodes
10889 --                                        and no more depth ;
10890 --              CHANGE := BASE_SCR - T_SCR ;
10891 --              if NODETO(ROOT,0) < 0 then
10892 --                write("Pointer should be > 0 root/try(wsize)/nodeto(root,0)",
10893 --                     ROOT, try(wsize), NODETO(ROOT,0)) ;
10894 --              FOR I := NODETO(ROOT,0) + 1 UNTIL TRY(WSIZE)
10895 --                DO SCORE(TRY(I)) := SCORE(TRY(I)) - CHANGE ;
10896 --              HASH := T_HASH ;
10897 --              SAVESTATE(ROOT) ;
10898 -9            END ;
10899 --            MP := 0 ;
10900 --            IF IP > 1 AND (~ABANDONNED OR T_SCR = B_SCR)
10901 --            THEN IF (FINAL = -5 AND B_SCR > ALPHA
10902 --                     OR EXP AND F_T = 0 AND BETTER ~= NINES AND LEVEL > 1
10903 --                     OR LEVEL = 1 AND MX > MOST)
10904 --            THEN MP := 1
10905 9-            ELSE BEGIN
10906 --              IF F_T = 0 AND PRINCVAR AND ABS(HIGHER - LOWER) = 1
10907 --              THEN F_T := 1 ;
10908 --              TEMP := -SIDE*AB(LEVEL+1) ;
10909 --              I := IP ;
10910 10-             WHILE I > 1 DO BEGIN
10911 --                I := I - 1 ;
10912 --                xxx := FULLEVAL(I) := STATES(NODETO(ROOT,I),5) = 0 ;
10913 --                IF F_T ~= 0 AND FULLEVAL(I)
10914 --                THEN I := 0 ELSE
10915 --                GAP := TEMP - STATES(ROOT, T_SIZE+2+I) ;
10916 --                IF I > 0
10917 --                THEN IF GAP < -200
10918 --                     THEN I := 0
10919 --                     ELSE IF GAP > 0 OR F_T = 0 AND ~FULLEVAL(I)
10920 --                          THEN IF F_T = 0 OR I = 1
10921 --                               THEN MP := I
10922 --                               ELSE IF GAP > 200 OR I > 8 OR IP - 5 <= I
10923 --                                    THEN MP := I
10924 --                                    ELSE IF IP - 5 < MP
10925 --                                         THEN IF IP - 5 >= 8
10926 --                                              THEN MP := 8
10927 --                                              ELSE MP := IP - 5 ;
10928 -10             END ;
10929 -9            END ;
10930 --            IF MP > 0
10931 9-            THEN BEGIN
10932 10-             IF TEST THEN begin
10933 --                WRITE("SEE", MP, IP, F_T, GAP, ROOT, TEMP,
10934 --                         NODETO(ROOT,MP), STATES(NODETO(ROOT,MP),5)) ;
10935 --                FOR I:= 1 UNTIL IP
10936 --                   DO WRITEON(STATES(ROOT,T_SIZE+2+I)) ;
10937 -10             end ;
10938 --              SHIFT(IP, MP, ROOT) ;
10939 --                   comment if IP > MP insert try(IP) at location MP ;
10940 -9            END ;
10941 --            IF (IP = 1 OR MP = 1)
10942 --            THEN IF ABS(HIGHER - LOWER) = 1
10943 --                 THEN TYPE := -1
10944 --                 ELSE TYPE := IF F_T = 0
10945 --                              THEN 0
10946 --                              ELSE -1 ;
10947 --            IF IP = 1 OR MP > 0
10948 --            THEN STATES(ROOT,2) := DEEPER + 1 ;
10949 --            IF LEVEL = 1 AND MX > MOST
10950 9-            THEN BEGIN
10951 --              REPLY := PATH ;
10952 --              MOST := MAXSC(PATH) := MX ;
10953 -9            END ;
10954 --            IF PARTIAL THEN
10955 --            IF EXP
10956 9-            THEN BEGIN
10957 --                           COMMENT previous partial evaluation insufficient,
10958 --                                    do full evaluation ;
10959 --              IF TEST
10960 --              THEN WRITE("CUTOFF REVISED", LEVEL, IP, B_SCR, BETA) ;
10961 --              FROM := MOVEFROM(TRY(1)) ;
10962 --              TOTO := MOVETO(TRY(1)) ;
10963 --              PARTIAL := FALSE ;
10964 --              UPPER := EIGHTS ;
10965 --              LISTLEGALMOVES(FALSE) ;
10966 --              TYPE := PLEX := PART := 0 ;
10967 --              if IP > 1 then
10968 --                write("Expand is about to set IP to 0/1", 
10969 --                      IP, from, toto, moveto(try(1))) ;
10970 --              IP := IF FROM = MOVEFROM(TRY(1))
10971 --                       AND TOTO = MOVETO(TRY(1))
10972 --                    THEN 1
10973 --                    ELSE 0 ; 
10974 --                    comment to protect against case when TRY array not aligned ;
10975 --              MAKE_SPACE(ROOT, IP, -1, packer*LEVEL, MAXTREE) ;
10976 --              IDONE := IP ;
10977 --              HASH := T_HASH ;
10978 --              SAVESTATE(ROOT) ;
10979 -9            END
10980 --            ELSE IF TEST
10981 --                 THEN WRITE("SUCCESSFUL SALVAGE", ROOT, IP) ;
10982 --                     COMMENT "successful salvage" means that the previous partial
10983 --                             evaluation still provides an effective cut-off ;
10984 -8          END Again_ExtendSegment ;
10985 --  
10986 --          IF LEVEL = 1 then
10987 --          if (AGAIN OR IP <= 6 OR T_SCR > L_SCR)
10988 8-          THEN BEGIN
10989 --            IOCONTROL(2) ;
10990 --            I : = if MP > 0 and MP < IP
10991 --                  then MP
10992 --                  else IP ;
10993 --  
10994 --            for j := NODETO(ORIGIN,0) step -1 until 1 do
10995 --               MARK := MARKTREE(NODETO(ORIGIN,j), ORIGIN, packer, 0) ;
10996 --               comment note that in ALGOLW, "j" in for-loop above is local to loop ;
10997 --            comment when again is true at this point, the current line will be
10998 --                    searched again with improved aspiration windows ;
10999 --            if again
11000 --            then write("    Candidate: ")
11001 --            else if IP = 1 or T_SCR > L_SCR
11002 --            then write("  New PV: ") ;
11003 --            NODEX := ORIGIN ;
11004 9-            if again or IP = 1 or T_SCR > L_SCR then begin
11005 --              WHILE NODEX > 0
11006 10-             DO BEGIN
11007 --                STATE := STATES(NODEX, T_SIZE+2+MAX_WID+I) ;
11008 --                FROM := ABS(STATE) REM 256 ;
11009 --                TOTO := (ABS(STATE) REM 65536) DIV 256 ;
11010 --                WRITEON(BOX(FROM), BOX(TOTO), " ") ;
11011 --                if NODEX = NODETO(NODEX,i)
11012 11-               then begin
11013 --                  write("Potential Infinite Loop ", I, NODEX, NODETO(nodex,0)) ;
11014 --                  NODEX := 0 ;
11015 -11               end else
11016 --                        NODEX := NODETO(NODEX,I) ;
11017 --                I := 1 ; comment only want to traverse first variation (main line) ;
11018 -10             END ;
11019 --              WRITEON(LOWER, T_SCR) ;
11020 --              IOCONTROL(2) ;
11021 -9            end ;
11022 -8          END ;
11023 --          IF TEST AND LEVEL < 3
11024 --          THEN WRITE("TYPE", LEVEL, LOWER, HIGHER, ALPHA, BETA, F_T, TYPE,
11025 --                      AGAIN, IP, MP, PRINCVAR) ;
11026 -7        END ELSE FINAL := -6 ;
11027 --                               COMMENT maximum depth ;
11028 -6      END ELSE
11029 6-      BEGIN
11030 --        IF TEST
11031 7-        THEN begin
11032 --          WRITE("   Space PRUNE level/ip/final/maxl/point/est") ;
11033 --          write("   ", LEVEL, IP, FINAL, MAXL, POINT, EST_spa) ;
11034 --          write("   side/forced/maxnodes/t_nodes/deeper/increase") ;
11035 --          write("   ", SIDE, FORCED, MAXNODES, T_NODES,
11036 --                        deeper, increase, old, incheck, width div 2) ;
11037 -7        end ;
11038 --        IF IP > 1 AND LEVEL < MAXDEPTH
11039 --        THEN SCR := -44444 ;
11040 --        FINAL := -7 ;
11041 --        IF FORCED
11042 --        THEN SMALL := TRUE ;
11043 -6      END ;
11044 --                             COMMENT no more nodes for this variation ;
11045 --      if AGAIN
11046 --      then IP := IP - 1 ;
11047 --      EXP
11048 -5    END OF_EXPAND ;
11049 --  
11050 --    PROCEDURE MATE_SOLN ;
11051 5-    BEGIN
11052 --      LOGICAL PRINT ;
11053 --      INTEGER MVT, MVF, SQ3, NEW_MOVES, VAR, KEEP, SCR, LEV, STATE,
11054 --              NODEX, FROM, TOTO, ALL ;
11055 --      INTEGER JJ, IN, R, M, J, SQF, SQT, DIR, SQ, L, PC, OFFT, SQ1, D ;
11056 --      LOGICAL ARRAY AVAIL(1::80) ;
11057 --      INTEGER ARRAY REFLINE (1::E_Depth) ;
11058 --  
11059 --      PRINT := TEST OR -B_SCR > SEVENS and warning ;
11060 --      VAR := IF LEVEL = 1 THEN REPLY ELSE PATH ;
11061 --      IF PRINT THEN
11062 --          WRITE("LOSS_SOLN ", COLOR(K), LEVEL, IP, IDONE, VAR, REPLY, LASTSCR,
11063 --                  TARGET, B_SCR, ALPHA, BETA) ;
11064 --      IF PRINT THEN WRITE("REFUTATIONS-one ") ;
11065 --      FOR LEV := 1 UNTIL MAX_PLIES
11066 --      DO REFLINE(LEV) := 0 ;
11067 --      NODEX := ROOT ;
11068 --      LEV := LEVEL ;
11069 --      WHILE NODEX > 0
11070 6-      DO BEGIN
11071 --        STATE := STATES(NODEX, T_SIZE+2+MAX_WID+1) ;
11072 --        FROM := ABS(STATE) REM 256 ;
11073 --        TOTO := (ABS(STATE) REM 65536) DIV 256 ;
11074 --        REFLINE(LEV) := 1000*FROM + TOTO ;
11075 --        IF PRINT THEN WRITEON(REFLINE(LEV)) ;
11076 --        LEV := LEV + 1 ;
11077 --        NODEX := NODETO(NODEX,1) ;
11078 -6      END ;
11079 --      R := 1 ;
11080 --      MAKE_SPACE(ROOT, 0, 0, packer*LEVEL, MAXTREE) ;
11081 --      ALL := TRY(WSIZE) ;
11082 --      IN := TOTAL*K ;
11083 --      JJ := -IN - K ;  comment JJ will vary from -IN to -IN + k*all ;
11084 --      FOR L := 1 UNTIL ALL
11085 6-      DO BEGIN
11086 --        JJ := JJ + K ;
11087 --        MOVEFROM(JJ) := MOVEFROM(TRY(L)) ;
11088 --        MOVETO(JJ) := MOVETO(TRY(L)) ;
11089 --        REWARD(JJ) := REWARD(TRY(L)) ;
11090 --        SCORE(JJ) := SCORE(TRY(L)) ;
11091 --        QUIES(JJ) := QUIES(TRY(L)) ;
11092 --              COMMENT IF PRINT THEN PRINTLINE(JJ, 2) ;
11093 --              COMMENT IF PRINT THEN WRITEON(L, JJ, TRY(L)) ;
11094 -6      END ;
11095 --      R := TRY(R) ;
11096 --      SCORE(IN) := SCORE(R) ;
11097 --      REWARD(IN) := REWARD(R) ;
11098 --      MOVEFROM(IN) := MOVEFROM(R) ;
11099 --      MOVETO(IN) := MOVETO(R) ;
11100 --      ALTERNATIVE := TRUE ;
11101 --      LISTLEGALMOVES (TRUE) ;
11102 --      ALTERNATIVE := FALSE ;
11103 --      NUM := NUMBER(K) ;
11104 --      FOR L := -IN STEP K UNTIL JJ
11105 6-      DO begin
11106 --         FOR J := NUM STEP -K UNTIL K
11107 --         DO IF (MOVEFROM(J) = MOVEFROM(L) AND MOVETO(J) = MOVETO(L))
11108 7-            THEN begin
11109 --              SCORE(J) := BAD ;
11110 -7            end ;
11111 -6      end ;
11112 --      FOR J := K STEP K UNTIL NUM
11113 --      DO AVAIL(ABS(J)) := SCORE(J) ~= BAD ;
11114 --      NEW_MOVES := M := 1 ;
11115 --      IF PRINT
11116 6-      THEN BEGIN
11117 --        WRITE("REFUTATIONS-two ") ;
11118 --        FOR LEV := 1 UNTIL MAX_PLIES
11119 --        DO WRITEON(REFTAB(PATH+LEVEL-1,LEV)) ;
11120 -6      END ;
11121 --      FOR LEV := LEVEL+1 STEP 2 UNTIL MAX_PLIES
11122 6-      DO BEGIN
11123 --        R := REFLINE(LEV) ;
11124 --        IF R > 0
11125 7-        THEN BEGIN
11126 --                    COMMENT get direction of refuting move SQF - SQT
11127 --                               look for moves which
11128 --                                        1. give check or move King.
11129 --                                        2. Move pc on SQT, if present.
11130 --                                        3. Defend SQT.
11131 --                                        4. Attack SQF, if empty.
11132 --                                        5. Block attack path, SQF - SQT ;
11133 --          SQF := R DIV 1000 ;
11134 --          SQT := R REM 1000 ;
11135 --          OFFT := OFFSET(SQT) ;
11136 --          DIR := BOTV(EDGE, OFFT-OFFSET(SQF)) ;
11137 --                           COMMENT DIR = 0 means attacker is a Knight ;
11138 --          IF PRINT
11139 --          THEN WRITE("MATER", SQF, SQT, M, DIR, ROOT, NODETO(ROOT,1)) ;
11140 --          L := SEC(0,SQT) ;
11141 --          IF L ~= 0
11142 --          THEN L := 1 ;
11143 --          J := NUM ;
11144 --          IF SQF >= WQRSQ and SQF <= BKRSQ THEN
11145 --          WHILE J ~= 0
11146 8-          DO BEGIN
11147 --            IF AVAIL(ABS(J))
11148 9-            THEN BEGIN
11149 --              SQ := SQT + DIR ;
11150 --              JJ := L ;
11151 --              PC := ABS(BRD(MOVEFROM(J))) ;
11152 --              KEEP := 0 ;
11153 --              MVF := MOVEFROM(J) ;
11154 --              MVT := MOVETO(J) ;
11155 --                              COMMENT accept checks or King moves ;
11156 --              IF ABS(REWARD(J)) >= CHECKING OR PC = KING
11157 --              THEN KEEP := 1
11158 --              ELSE IF PC >= KNIGHT AND BOTV(PC, OFFT-OFFSET(MVT)) = 1
11159 --                      AND BOTV(PC, OFFT-OFFSET(MVF)) ~= 1
11160 10-                  THEN BEGIN
11161 --                               COMMENT move attacked piece, unless it is a
11162 --                                       Pawn.  Add a new defender to SQT ;
11163 --                     D := BOTV(EDGE, OFFSET(MVT) -OFFT) ;
11164 --                     IF PC = KNIGHT
11165 --                     THEN D := SQT - MVT ;
11166 --                     IF D ~= 0 AND D ~= BOTV(EDGE, OFFSET(MVF) -OFFT)
11167 11-                    THEN BEGIN
11168 --                       SQ1 := MVT + D ;
11169 --                       IF D ~= 0
11170 --                       THEN WHILE SQ1 ~= SQT AND BRD(SQ1) = 0
11171 --                       DO SQ1 := SQ1 + D ;
11172 --                                       COMMENT D = 0 means that SQT = MVT ;
11173 --                       IF SQ1 = SQT
11174 --                       THEN KEEP := 2 ;
11175 -11                    END ;
11176 -10             END ;
11177 --                                COMMENT  find pawn defence ;
11178 --              IF PC = PAWN
11179 --              THEN IF ABS(MVT - SQT + K*FILE) = 1
11180 --                      OR BRD(SQF) = 0 AND ABS(MVT - SQF + K*FILE) = 1
11181 --                   THEN KEEP := 3 ;
11182 --              IF KEEP = 0 AND DIR ~= 0
11183 --              THEN WHILE KEEP = 0 AND (JJ <= 1)
11184 10-                  DO BEGIN
11185 --                               COMMENT block the attack path ;
11186 --                     IF BRD(SQ) ~= 0
11187 --                     THEN JJ := JJ + 1 ;
11188 --                     IF SQ = MVT
11189 --                     THEN KEEP := 4
11190 --                     ELSE
11191 --                     if SQ = SQF
11192 --                     then JJ := 2
11193 11-                    else begin
11194 --                       SQ := SQ + DIR ;
11195 --                         if BRD(SQ) = EDGE
11196 12-                        then begin
11197 --                           write("MATE_SOLN index error avoided ", "DIR=", DIR,
11198 --                                 "SQ=", SQ, "PC=", PC) ;
11199 --                           WRITE("Mater ", "sqf", SQF, offset(sqf), "sqt", SQT,
11200 --                            offt, "mvf/mvt", mvf, mvt, "j, k, l jj", j, k, l, jj) ;
11201 --                           TRACER(2, "?PZ") ;
11202 --                           JJ := 2 ;
11203 -12                         end ;
11204 -11                     end ;
11205 -10             END ;
11206 --                               COMMENT does piece movement add a hidden defender ;
11207 --              IF KEEP = 0 AND BOTV(EDGE, OFFT-OFFSET(MVF)) ~= 0
11208 --              THEN IF CLEAR(MVF, MVF, SQT)
11209 --                   THEN IF BOTV(PC, OFFT-OFFSET(MVT)) ~= 1
11210 --                        THEN IF HIDDEN(SQT, MVF, SQ3, K, FALSE)
11211 --                             THEN KEEP := 5 ;
11212 --              IF (KEEP = 0 OR SQT = MVF) AND BRD(SQF) = 0
11213 --                   AND BOTV(PC, OFFSET(MVT) -OFFSET(SQF)) = 1
11214 10-             THEN BEGIN
11215 --                         COMMENT attack SQF, so that opponent cannot move there ;
11216 --                D := BOTV(EDGE, OFFSET(MVT) -OFFSET(SQF)) ;
11217 --                IF D ~= DIR AND D ~= BOTV(EDGE, OFFSET(MVF) -OFFSET(SQF))
11218 11-               THEN BEGIN
11219 --                               COMMENT not an inline move ;
11220 --                  SQ1 := MVT + D ;
11221 --                  IF D ~= 0
11222 --                  THEN WHILE BRD(SQ1) = 0 AND SQ1 ~= SQF
11223 --                         DO SQ1 := SQ1 + D ;
11224 --                  IF PC = KNIGHT
11225 --                  THEN SQ1 := SQF ;
11226 --                  IF SQ1 = SQF
11227 --                  THEN IF KEEP > 0
11228 --                       THEN SCORE(J) := SCORE(J) + 50
11229 --                       ELSE KEEP := 6 ;
11230 -11               END ;
11231 -10             END ;
11232 --              IF KEEP > 0
11233 10-             THEN BEGIN
11234 --               IF PRINT THEN
11235 --                    WRITE("SOLN", SQF, SQT, PC, MVF, MVT, D,
11236 --                              DIR, SQ1, SQ, M, KEEP) ;
11237 --                                      COMMENT assert TW = MAX_WID ;
11238 --                IF PRINT THEN PRINTLINE(J, 2) ;
11239 --                SCR := 0 ;
11240 --                IF KEEP = 1 AND PC = KING
11241 --                THEN SCR := -50
11242 --                ELSE IF KEEP = 5 OR KEEP = 2 AND CON(-K,MVT) = 0
11243 --                     THEN SCR := 50 ;
11244 --                SCORE(J) := SCORE(J) + SCR ;
11245 --                AVAIL(ABS(J)) := FALSE ;
11246 --                NEW_MOVES := NEW_MOVES + 1 ;
11247 --                IF M <= MAX_WID THEN M := M + 1 ;
11248 --                TRY(M) := J ;
11249 --                FOR I := M STEP -1 UNTIL 2
11250 --                DO IF SCORE(J) > SCORE(TRY(I))
11251 11-                  THEN BEGIN
11252 --                     TRY(I+1) := TRY(I) ;
11253 --                     TRY(I) := J ;
11254 -11               END ;
11255 -10             END ;
11256 -9            END ;
11257 --            J := J - K ;
11258 -8          END ;
11259 -7        END ELSE if MONITOR then WRITE("No killer at level ", LEV, R) ;
11260 -6      END ;
11261 --  
11262 --      J := -IN + IP*K ;
11263 --      JJ := NUM ;
11264 6-      FOR I := 0,1 DO BEGIN
11265 --        WHILE M < MAX_WID AND ABS(J) > ABS(IN) - ALL AND ABS(JJ) < TOTAL
11266 7-        DO BEGIN
11267 --                          COMMENT then the moves not yet searched,
11268 --                                  followed by those just searched (if room) ;
11269 --          M := M + 1 ;
11270 --                          COMMENT first the best move
11271 --                                  then the injected "potential refuters" ;
11272 --          JJ := JJ + K ;
11273 --          IF PRINT THEN PRINTLINE(J, 2) ;
11274 --          IF PRINT THEN WRITEON(M, J, JJ) ;
11275 --          MOVEFROM(JJ) := MOVEFROM(J) ;
11276 --          MOVETO(JJ) := MOVETO(J) ;
11277 --          REWARD(JJ) := REWARD(J) ;
11278 --          SCORE(JJ) := SCORE(J) ;
11279 --          QUIES(JJ) := QUIES(J) ;
11280 --          TRY(M) := JJ ;
11281 --          J := J + K ;
11282 -7        END ;
11283 --        J := -IN + K ;
11284 -6      END ;
11285 --      NUM := M ;
11286 --      IF NEW_MOVES > 1
11287 6-      THEN BEGIN
11288 --        if TEST or LEVEL = 1 then
11289 --          write("New_moves in MATE_SOLN ", 
11290 --                IN, JJ, j, TEST, LEVEL, IP, NUM, new_moves) ;
11291 --        TRY(1) := IN ;
11292 --        JJ := IF NUM > WIDTH
11293 --              THEN WIDTH
11294 --              ELSE NUM ;
11295 --        FOR I := 1 UNTIL JJ
11296 7-        DO BEGIN
11297 --          IF TEST OR LEVEL = 1
11298 --          THEN PRINTLINE(TRY(I), 0) ;
11299 --          IF I > 1
11300 --          THEN SCORE(TRY(I)) := SCALE*ONEVAL ;
11301 -7        END ;
11302 --        IF PRINT or LEVEL = 1
11303 --        THEN WRITEON(REPLY, NUM, JJ, K, LEVEL, ONEVAL) ;
11304 --        LIMIT := TRY(0) := TRY(WSIZE) := JJ ;
11305 --        REMAKE(KINGSQ(K), KINGSQ(K)) ;
11306 --        REMAKE(KINGSQ(-K), KINGSQ(-K)) ;
11307 --        SAVE(ROOT) ;
11308 --        MX := SIDE*EIGHTS ;
11309 --        IDONE := NODETO(ROOT,0) := 1 ;
11310 --        NODE := NODETO(ROOT,1) ;
11311 --        IP := 0 ;                     COMMENT try also IP := 1   why repeat PV? ;
11312 --        IF LEVEL = 1
11313 --        THEN REPLY := 1 ;
11314 --        MATER := FALSE ;
11315 -6      END ELSE
11316 6-      BEGIN
11317 --        if MONITOR then
11318 --          WRITEON("No suitable refutation ") ;
11319 --        RESTORE(ROOT) ;
11320 -6      END ;
11321 --      NUM := ABS(NUMBER(K)) ;
11322 -5    END OF_MATE_SOLN ;
11323 --  
11324 --    LOGICAL PROCEDURE TERMINATE ;
11325 5-    BEGIN
11326 --      INTEGER EST_SCR, DEST, LOW_SCR ;
11327 --      INTEGER FROM, TOTO, VAR_TIME, INDEX, FIELD ;
11328 --      LOGICAL PV, display ;
11329 --  
11330 --      LOWER := IF B_SCR > ALPHA THEN B_SCR ELSE ALPHA ;
11331 --      PV := LOWER < SCR AND SCR < BETA ;
11332 --      FROM := M2 ;
11333 --      TOTO := M3 ;
11334 --      EST_SCR := SCR - THRESHOLD ;
11335 --      LOW_SCR := SCORE(TRY(IP+1)) ;
11336 --      IF IP < LIMIT AND LOW_SCR > EST_SCR
11337 --      THEN EST_SCR := LOW_SCR ;
11338 --      IF EST_SCR > BETA
11339 --      THEN EST_SCR := BETA ;
11340 --      IF PARTIAL AND LOW_SCR = BAD
11341 --      THEN LOW_SCR := EST_SCR ;
11342 --      DYNAMIC := FALSE ;
11343 --      display := false ;
11344 --      IF ABS(FINAL-2) ~= 1
11345 6-      THEN BEGIN              comment final = 3(draw) and final = 1(resign) omit ;
11346 --        IF STATES(ROOT,2) ~= 0 AND (OLD OR NODETO(ROOT,0) >= IP)
11347 --        THEN SCR := SCR + LEVEL
11348 --        ELSE IF PP_STATUS > 0
11349 --             THEN IF (CON(-K,M3) ~= 0 OR PP_STATUS > 3) AND ABS(BRD(M3)) = PAWN
11350 7-                  THEN BEGIN
11351 --                    DEST := BACK_ROW(-K, COLS(M3)) ;
11352 --                    DYNAMIC := PP_STATUS > 3 AND CON(-K,M3) ~= 0 ;
11353 --                    IF ~DYNAMIC
11354 --                    THEN SCR := SCR - SCALE*(PP_STATUS DIV
11355 --                                 (IF BOTV(KING, OFFSET(KINGSQ(-K)) -OFFSET(DEST))
11356 --                                       <= BOTV(KING, OFFSET(M3) -OFFSET(DEST)) + 1
11357 --                                  THEN IF K*CON(0,M3) > 0
11358 --                                       THEN 2
11359 --                                       ELSE 1
11360 --                                  ELSE IF CON(-K,M3) = 0
11361 --                                       THEN IF CON(-K,M3+K*FILE) ~= 0
11362 --                                            THEN 1
11363 --                                            ELSE IF CON(K,M3) = 0
11364 --                                                 THEN 2
11365 --                                                 ELSE 4
11366 --                                       ELSE IF K*SEC(0,M3) < 0
11367 --                                            THEN 1
11368 --                                            ELSE 2)) ;
11369 --                    IF TEST or display
11370 --                    THEN WRITEON("PP", PP_STATUS, SCR, DEST,
11371 --                                 BOTV(KING,OFFSET(KINGSQ(-K))-OFFSET(DEST))) ;
11372 --                    IF SCR < BETA AND (PARTIAL OR SCR < EST_SCR)
11373 --                    THEN ANOTHER := TRUE ;
11374 -7        END ;
11375 -6      END ;
11376 --      IF TEST or display
11377 --      THEN WRITE("PV    ", SCR, LOWER, BETA, LEVEL, MAXDEPTH, MAXLEV,
11378 --                 EXTENSION, DYNAMIC, LENGTH, DEEP, FINAL) ;
11379 --      IF FINAL = -6 AND (LEVEL <= MAXDEPTH OR LEVEL <= MAXLEV
11380 --                     AND MAXDEPTH >= 5)
11381 6-      THEN BEGIN                         COMMENT room for capture search ;
11382 --        TOT := TOT + 1 ;
11383 --        IF ~DYNAMIC THEN
11384 --        IF SCR > LOWER OR REWN < 0 AND ABS(CON(-K,KINGSQ(-K))) <= 1
11385 --           OR REWN <= -CHECKING
11386 --           OR PP_STATUS ~= 0 OR LATE_END AND REWN ~= 0
11387 --        THEN DYNAMIC := (REWN < 0 OR LATE_END AND REWN ~= CHECKING
11388 --               OR INCHECK AND REWN ~= 0)
11389 --                  AND LEVEL <= LENGTH
11390 --               OR PV AND (LEVEL > LENGTH OR LEVEL = DEEP) ;
11391 --          IF ((TEST OR EXTENSION AND IP > 1) AND PV or display) and warning
11392 --          THEN WRITE("PVPV  ", SCR, LOWER, BETA, PRINCVAR, REWN,
11393 --                      PP_STATUS, LEVEL, DEEP, SEEN, EXTENSION, IP) ;
11394 --        IF EXTENSION THEN EXTENSION := FALSE
11395 --        ELSE
11396 --        IF DYNAMIC AND SCR < SEVENS
11397 --           AND (ABS(REWN) >= CHECKING OR REWN < 0
11398 --           OR REWN > 0 AND SCR > LOWER
11399 --           OR SKILL(0|8) = "   DEBUG"
11400 --           OR SKILL(0|8) = "   SPEED" OR T_NODES <= PATH*MAXNODES)
11401 --             AND (LEVEL = DEEP AND ~SEEN OR PV AND PRINCVAR)
11402 --           AND SCR > LOWER - THRESHOLD
11403 7-        THEN BEGIN
11404 --          VAR_TIME := TIME(1) ;
11405 --          IF TEST or display THEN WRITEON(VAR_TIME, T_TIME, M_TIMES(0)) ;
11406 --  
11407 --          IF PRINCVAR AND SCR > MOST and VAR_TIME - T_TIME < M_TIMES(0)
11408 8-          THEN BEGIN
11409 --                            COMMENT  note CPU limitation on excessive variation ;
11410 --            DYN := DYN + 1 ;
11411 --            IF TEST or display
11412 --            THEN WRITEON("FLUID ", DYN) ;
11413 --            SAVEBACK(LEVEL, TRUE) ;
11414 --            SAVESTATE(0) ;
11415 --                comment the companion restore at end of BUILD_SACR_TREE ;
11416 --            EST_scr := SCR + THRESHOLD ;
11417 --            SCR := -BUILD_SACR_TREE(0, 2, EST_SCR, -BETA, -LOWER, IDONE) ;
11418 --            if TEST then
11419 --               write("After build_sacr ", 
11420 --                     EST_scr, SCR, QUIES(TRY(IP)), SHAH, BETA, IP) ;
11421 9-            IF ~QUIES(TRY(IP)) THEN BEGIN
11422 --              INDEX := T_SIZE + 2 + MAX_WID + IP ;
11423 --              FIELD := STATES(ROOT, INDEX) ;
11424 --              FIELD := IF FIELD < 0
11425 --                       THEN -(ABS(FIELD) + 65536) ELSE FIELD + 65536 ;
11426 --              STATES(ROOT,INDEX) := FIELD ;
11427 -9            END ;
11428 --            QUIES(TRY(IP)) := TRUE ;
11429 --            IF ~SHAH
11430 --            THEN IF ABS(SCR) = FIVES
11431 --                 THEN SCR := EST_scr - THRESHOLD
11432 --                 ELSE IF (BETA > SEVENS OR SCR > BETA)
11433 9-                      THEN BEGIN
11434 --                        EXTENSION := ANOTHER := TRUE ;
11435 --                        IF IP = 1
11436 --                        THEN B_SCR := -EIGHTS ;
11437 --                        IP := IP - 1 ;
11438 -9                      END ELSE IF SCR > EST_scr
11439 --                               THEN SCR := EST_scr ;
11440 --            if TEST then
11441 --            writeon("scr/ip ", SCR, IP) ;
11442 --            IF SCR < BETA AND SCR < LOW_SCR
11443 --            THEN IF PARTIAL
11444 --                 THEN ANOTHER := TRUE
11445 --                 ELSE IF -SIDE*LOW_SCR > LOWER
11446 --                      THEN ANOTHER := TRUE ;
11447 --            RESTOREBACK(LEVEL, TRUE) ;
11448 --            IF SCR > LOWER
11449 --            THEN REFUTE(1000*M2 + M3) ;
11450 -8          END ;
11451 -7        END ;
11452 -6      END ;
11453 --      RESTORESTATE(ROOT) ;
11454 --      RESTOREBACK(LEVEL, FALSE) ;
11455 --      TAKEBACKMOVE(TRUE) ;
11456 --      IF ~EXTENSION
11457 6-      THEN BEGIN
11458 --        EST_scr := IF FINAL = 3
11459 --                   THEN IF ENDGAME AND ~DRAWS(K) AND DRAWS(-K)
11460 --                        THEN SIDE*3*DRAW
11461 --                        ELSE IF ENDGAME AND ~DRAWS(-K) AND DRAWS(K)
11462 --                             THEN -SIDE*3*DRAW
11463 --                             ELSE -SIDE*(DRAW -(IF EXPECT > 0
11464 --                                          THEN LEVEL
11465 --                                          ELSE LEVEL))
11466 --                   ELSE IF LATE_END AND SCR < DRAW AND MEN(K) <= 2
11467 --                             AND DRAWS(K) AND DRAWS(-K)
11468 --                        THEN -SIDE*(DRAW-LEVEL)
11469 --                        ELSE IF FINAL > 0
11470 --                             THEN SCR
11471 --                             ELSE IF ANOTHER
11472 --                                  THEN -SIDE*SCR
11473 --                                  ELSE IF SIDE = -1
11474 --                    THEN SCR - LEVEL
11475 --                    ELSE IF SCR > SEVENS
11476 --                         THEN SCR - LEVEL
11477 --                         ELSE IF IP = 1 OR FINAL >= -2
11478 --                                   OR DEEPER = 0 AND FINAL > -7
11479 --                              THEN -(LASTSCR)
11480 --                              ELSE -AB(LEVEL) ;
11481 --                      COMMENT if even ply termination, estimate score ;
11482 --        IF TEST or display
11483 --        THEN WRITE("!?", ROOT, IP, STATES(ROOT,T_SIZE+2+IP), EST_scr,
11484 --                 FINAL, SCR, LASTSCR, PASTSCR) ;
11485 --        IF ANOTHER AND PARTIAL AND SCR < BETA
11486 7-        THEN BEGIN
11487 --          PARTIAL := FALSE ;
11488 --          UPPER := EIGHTS ;
11489 --          PLEX := PART := 0 ;
11490 --          LISTLEGALMOVES(FALSE) ;
11491 --          LOW_SCR := SCORE(TRY(IP+1)) ;
11492 --          IP := IF FROM = MOVEFROM(TRY(1)) AND TOTO = MOVETO(TRY(1))
11493 --                      AND IP = 1
11494 --                THEN IP
11495 --                ELSE 0 ;
11496 --                                COMMENT We are at a terminal node and need a
11497 --                                        full evaluation afterall ;
11498 --          IF TEST or display
11499 --          THEN WRITE("NO CUTOFF", LEVEL, IP, SCR, BETA, LOW_SCR) ;
11500 --          MAKE_SPACE(ROOT, IP, -1, packer*LEVEL, MAXTREE) ;
11501 --          HASH := T_HASH ;
11502 --          SAVESTATE(ROOT) ;
11503 -7        END ;
11504 --        IF IP > 0 AND FINAL ~= -7 AND FINAL ~= 1
11505 --        THEN STATES(ROOT, T_SIZE+2+IP) := -SIDE*EST_scr ;
11506 --        IF IP > IDONE
11507 7-        THEN begin
11508 --          if PARTIAL and NODETO(ROOT,IP) > 0 then
11509 --           write("TERMINATE May be losing nodeto(root,0)/IP/root/nodeto(root,ip)",
11510 --                  NODETO(ROOT,0), IP, ROOT, NODETO(ROOT,IP)) ;
11511 --          NODETO(ROOT,0) := IF PARTIAL
11512 --                            THEN IP - 1
11513 --                            ELSE IP ;
11514 -7        end ;
11515 --        IF ~PARTIAL
11516 --        THEN STATES(ROOT,2) := 1 ;
11517 --        IF IP > 0
11518 --        THEN SCORE(TRY(IP)) := EST_scr ;
11519 --        EST_SCR := -SIDE*EST_scr ;
11520 --                                   COMMENT save incase salvaged ;
11521 --        GOOD := -SIDE*MX < EST_scr ;
11522 --        IF GOOD
11523 --        THEN MX := EST_SCR ;
11524 --        IF TEST or display
11525 --        THEN WRITE("  EXIT", LEVEL, IP, FINAL, SIDE, LIMIT, ANOTHER, DYNAMIC,
11526 --                   MEN(1), MEN(-1), MX, AB(LEVEL), SCR, MOST, LOWER, LOW_SCR,
11527 --                   B_SCR, EST_scr) ;
11528 --        IF GOOD AND (IP > 1 OR MATER) AND (FINAL ~= -7 OR SCR ~= -44444)
11529 7-        THEN BEGIN
11530 --          PLEX := 0 ;
11531 --          IF B_SCR < EST_scr OR IP = 1
11532 --          THEN B_SCR := EST_scr ;
11533 --          IF IP > 1 AND (LEVEL > 1 OR MX > MOST)
11534 8-          THEN BEGIN
11535 --            if IP >= IDONE then
11536 --            NODETO(ROOT,0) := IP ;
11537 --            SCORE(TRY(IP)) := -SIDE*MX ;
11538 --            SHIFT(IP, 1, ROOT) ;
11539 --            comment this next small code segment is questionable.
11540 --                    Already IP > 0, so only enter if LEVEL = 1
11541 --                    but is that possible in TERMINATE? ;
11542 --            IF LEVEL = 1 AND MX > MOST
11543 9-            THEN BEGIN
11544 --              comment doubt if this block is ever executed ;
11545 --              write("In TERMINATE mx/most/score(try(ip))/ip",
11546 --                     mx, most, score(try(IP)), IP) ;
11547 --              REPLY := 1 ;
11548 --              MOST := MAXSC(PATH) := MX ;
11549 -9            END ;
11550 -8          END ;
11551 --          IF TEST or display
11552 --          THEN WRITE("#", B_SCR, BETA) ;
11553 -7        END ;
11554 --        IF ALPHA < EST_scr AND EST_scr < BETA
11555 --        THEN ALPHA := EST_scr ;
11556 --        IF ANOTHER
11557 --        THEN IF B_SCR > BETA OR B_SCR < LOWER AND (~DYNAMIC)
11558 --             THEN ANOTHER := FALSE ;
11559 --        IF LEVEL = MINDEPTH AND MINDEPTH < MAXDEPTH
11560 --        THEN ANOTHER := TRUE ;
11561 -6      END ;
11562 --      FINISH := TRUE ;
11563 --      TYPE := IF PARTIAL
11564 --              THEN 1
11565 --              ELSE 0 ;
11566 --      IF ~ANOTHER AND IP < TRY(WSIZE)
11567 --      THEN IF SCR < BETA AND SCR < LOW_SCR
11568 --           THEN ANOTHER := TRUE ;
11569 --      REFTAB(PATH+LEVEL-2,LEVEL) := REFTAB(PATH+LEVEL-1,LEVEL) ;
11570 --      IF LEVEL < MAX_PLIES
11571 --      THEN REFTAB(PATH+LEVEL-2,LEVEL+1) := -1 ;
11572 --  
11573 --      ~ANOTHER OR IP >= TRY(WSIZE)
11574 -5    END OF_TERMINATE ;
11575 --  
11576 --    PROCEDURE LIMITS ;
11577 5-    BEGIN
11578 --      integer Est_scr ;
11579 --                COMMENT auto. expansion for non-quiescent positions, or at
11580 --                        level 1 ;
11581 --      IF (KTEST = 4) OR (MX*SIDE < -SEVENS)
11582 --      THEN SHAH := DYNAMIC := FALSE ;
11583 --      FINAL := 0 ;
11584 --      IF (MX - (IF SIDE < 0
11585 --                THEN SCR
11586 --                ELSE OLDSCR))*SIDE > 1500
11587 --          AND (LEVEL <= 5 OR MIN_WID < 3)
11588 --      THEN ANOTHER := TRUE ;
11589 --      IF SHAH AND (IP > 1) OR ANOTHER AND IP >= MIN_WID
11590 --      THEN MIN_WID := MIN_WID + 1 ;
11591 --      Est_scr := IF (PATH = 1)
11592 --                 THEN MAXSC(1)
11593 --                 ELSE MOST ;
11594 --      IF (Est_scr - EXPECT)*SIDE > 0
11595 --      THEN Est_scr := EXPECT ;
11596 --      IF TEST AND (ABS(MX) > SEVENS)
11597 --      THEN WRITE("MATE", IP, LEVEL, POINT, T_NODES, MX, Est_scr, MOST, B_SCR,
11598 --                         OLD, MAXL, GETNODE(POINT)) ;
11599 --      IF ~ANOTHER AND IP = LIMIT
11600 --      THEN IF (ABS(MX-Est_scr) > LOST OR (PATH > 1)
11601 --               AND ABS(MOST-Est_scr) > LOST) AND (IP < 3*VARS(LEVEL,LENGTH))
11602 --           THEN ANOTHER := IF (MX-Est_scr)*SIDE > 0
11603 --                               AND ((MOST-Est_scr)*SIDE > 0
11604 --                                    OR (AB(LEVEL) -Est_scr)*SIDE > LOST)
11605 --                               AND (T_NODES - INIT_T_NODES < MINTREE(LEVEL)
11606 --                                    OR IP < MIN_WID)
11607 --                           THEN TRUE
11608 --                           ELSE FALSE ;
11609 --      IF SHAH AND (ABS(REWN) >= TWOCHECK) OR (MX*SIDE > SEVENS)
11610 --      THEN ANOTHER := TRUE ;
11611 --      IF IP = LIMIT AND IP < WIDTH AND IP < TRY(WSIZE)
11612 --         AND (ANOTHER OR IP < MIN_WID
11613 --              OR ALPHA < B_SCR AND B_SCR < BETA AND -SIDE*B_SCR < SCORE(TRY(IP+1))
11614 --              OR (LEVEL = 1) AND (LIMIT < IDONE)
11615 --                 AND (B_SCR -MAXSC(IP+1) < THRESHOLD))
11616 --      THEN LIMIT := LIMIT + 1 ;
11617 --      FORCED := ANOTHER OR (IP < IDONE) ;
11618 --      IF TEST AND ((LEVEL < 6) OR ANOTHER OR DYNAMIC)
11619 --      THEN WRITE("  LIMITS-A", LEVEL, DYNAMIC, FORCED, IP, MIN_WID, LIMIT, SIDE, OLDSCR,
11620 --                  SIDE*(MX-Est_scr), ABS(MOST-Est_scr), PATH, ANOTHER, EXPECT,
11621 --                  Est_scr, MX, TARGET, ALPHA, B_SCR, BETA, MOST,
11622 --                  T_NODES - INIT_T_NODES, MAXL - POINT, SCR, LOST) ;
11623 --      Est_scr := (MX - Est_scr)*SIDE ;
11624 --      LARGE := IF MOST > MX
11625 --               THEN MOST
11626 --               ELSE MX ;
11627 --      CONDITION := IF ~ANOTHER AND SIDE*MX < -SEVENS
11628 --                   THEN 0
11629 --                   ELSE
11630 --                   IF FORCED
11631 --                   THEN 1
11632 --                   ELSE
11633 --                   IF DYNAMIC AND IP < MIN_WID AND LEVEL < 3
11634 --                   THEN 2
11635 --                   ELSE
11636 --                   IF EARLY AND SIDE*(LARGE-EXPECT) > -THRESHOLD
11637 --                   THEN 3
11638 --                   ELSE
11639 --                   IF IP < MIN_WID AND (REVERSE OR Est_scr > -THRESHOLD)
11640 --                   THEN 4
11641 --                   ELSE
11642 --                   IF Est_scr > THRESHOLD AND LEVEL <= 5
11643 --                   THEN 5
11644 --                   ELSE
11645 --                   IF (IF SIDE < 0
11646 --                       THEN SCR - MX
11647 --                       ELSE MX - OLDSCR) > LOST
11648 --                   THEN 6
11649 --                   ELSE
11650 --                   IF PATH = 1 AND IP < MIN_WID
11651 --                   THEN 7
11652 --                   ELSE
11653 --                   IF SIDE = -1 AND (TOURNAMENT OR SKILL(0|1) ~= " ")
11654 --                        AND LARGE < EXPECT AND LARGE < MAXSC(PATH) + THRESHOLD
11655 --                   THEN 8
11656 --                   ELSE
11657 --                   IF LEVEL = 2 AND PATH > 1 AND MX > MOST
11658 --                   THEN 9
11659 --                   ELSE
11660 --                   IF LEVEL <= 2 AND SIDE*(LARGE-EXPECT) > -EPSILON
11661 --                   THEN 10
11662 --                   ELSE
11663 --                   IF MX < 0 AND IP < MIN_WID
11664 --                   THEN 11
11665 --                   ELSE
11666 --                   IF LATE_END AND IP < MIN_WID AND LEVEL = 1
11667 --                               AND LARGE - EXPECT < PAWNVALUE
11668 --                   THEN 12
11669 --                   ELSE
11670 --                   IF Est_scr > EPSILON AND LEVEL <= 3
11671 --                   THEN 13
11672 --                   ELSE 0 ;
11673 --      IF TEST
11674 --      THEN WRITE("  LIMITS-B", CONDITION, TARGET, TYPE, STATES(ROOT,2)) ;
11675 --      IF ~AGAIN AND IP < LIMIT
11676 --      THEN IF LEVEL > 1 AND (B_SCR > SEVENS OR CONDITION = 0 AND IP > MIN_WID)
11677 --             OR LEVEL <= 1
11678 --                AND (IP >= WIDTH DIV 2 AND TIME(1) -OLDCPU > M_TIMES(MODE)
11679 --                   OR CONDITION = 0 AND IP >= MIN_WID
11680 --                   AND B_SCR > SCORE(TRY(IP+1)) - 2*PAWNVALUE
11681 --                   OR IP > 1 AND TIME(1) - OLDCPU > 2*M_TIMES(MODE))
11682 --           THEN LIMIT := IP
11683 --           ELSE IF ~FORCED AND ~MORE AND (LEVEL > 1 OR IP >= MIN_WID
11684 --                    AND MOST > EXPECT)
11685 --                THEN IF SIDE = -1 AND (T_NODES - INIT_T_NODES > 3*MINTREE(LEVEL)
11686 --                         OR MAXL - POINT < MINTREE(LEVEL)
11687 --                         AND IP >= MIN_WID AND (LEVEL > 3 OR CONDITION ~= 10))
11688 --                       OR SIDE = 1 AND LENGTH = DEEP AND IP > WIDTH DIV 2
11689 --                         AND T_NODES - INIT_T_NODES > 3*MINTREE(LEVEL)
11690 6-                     THEN BEGIN
11691 --                       FINAL := -7 ;
11692 --                       LIMIT := IP ;
11693 --                       IF TEST
11694 --                       THEN WRITE("NODES", T_NODES, MINTREE(LEVEL),
11695 --                                   MAXL-POINT, SIDE) ;
11696 -6      END ;
11697 --                  COMMENT only continue if sufficient nodes ;
11698 --      IF (LEVEL = 1) AND ~AGAIN
11699 6-      THEN BEGIN
11700 --        IF PATH < LIMIT AND MX > -SEVENS
11701 --        THEN EXPECT := (PATH*EXPECT + MX) DIV (PATH+1) ;
11702 --        MAXSC(PATH) := MX ;
11703 --        IF (MX > MOST)
11704 7-        THEN BEGIN
11705 --          MOST := MX ;
11706 --          REPLY := PATH ;
11707 -7        END ;
11708 -6      END ;
11709 --      Est_scr := IF SIDE = 1
11710 --                 THEN - B_SCR - LASTSCR
11711 --                 ELSE TARGET - B_SCR ;
11712 --      IF ALPHA < B_SCR AND B_SCR < BETA
11713 --         AND -SIDE*B_SCR < KNIGHTVALUE
11714 --      THEN IF IP = LIMIT AND (-B_SCR > SEVENS
11715 --                               OR Est_scr > (IF ENDGAME
11716 --                                             THEN 1200
11717 --                                             ELSE 2400) AND LEVEL <= 5)
11718 --                               OR LEVEL <= 2 AND IP >= 4
11719 --                                  AND (PLY = DEEP OR PLY >= 5)
11720 --                                  AND Est_scr > (IF ENDGAME
11721 --                                                 THEN 900
11722 --                                                 ELSE 1800)
11723 --           THEN IF MATER
11724 --                THEN MATE_SOLN
11725 --                ELSE if MONITOR then
11726 --                     WRITE(COLOR(K), IF ABS(MX) < SEVENS
11727 --                                     THEN " LOSES"
11728 --                                     ELSE " MATED", " IN", LEVEL, Est_scr,
11729 --                                       TARGET, B_SCR, MX) ;
11730 --      IF EXTENSION AND IP ~= 0
11731 --      THEN EXTENSION := FALSE ;
11732 --               Comment 19 July 2008, no indication that IP ever 0, why test now? ;
11733 -5    END OF_LIMITS ;
11734 --  
11735 --  @TITLE, " TREE"
11736 --  
11737 --    ROOT := ROOTNODE(LEVEL) := NODE ;
11738 --    FINISH := FALSE ;
11739 --    SIDE := -SIDE ;
11740 --    MATER := TRUE ;
11741 --    IDONE := NODETO(ROOT,0) ;
11742 --    if PATH = 1 then
11743 --    AGAIN := FALSE ;
11744 --    MX := AB(LEVEL) := SIDE*EIGHTS ;
11745 --    LASTSCR := OLDSCR ;
11746 --    PASTSCR := PREVSCR ;
11747 --    A_SCR := ALPHA ;
11748 --    OLD := FALSE ;
11749 --    PARTIAL := TRUE ;
11750 --    INC_wid := TOT_S := 0 ;
11751 --    INIT_T_NODES := T_NODES ;
11752 --    IF ROOT < 0 OR ROOT = 0 AND IDONE >= 0 OR ROOT > MAXTREE
11753 --    THEN WRITE("TREE TROUBLE", LEVEL, ROOT, IDONE, NUM, NUMBER(K))
11754 --    ELSE
11755 --    IF IDONE >= 0 AND ROOT > 0
11756 5-    THEN BEGIN
11757 --      RESTORESTATE(ROOT) ;
11758 --      IF HASH ~= T_HASH
11759 6-      THEN BEGIN WRITE("QUERY bad HASH ", HASH, T_HASH, ROOT) ;
11760 --        TRACER(1, "?P") ;
11761 --        B_SCR := SIDE*EIGHTS ;
11762 --        FINAL := -3 ;
11763 --        GOTO QUIT ;
11764 -6      END ;
11765 --      IF ~STARTTHISPROBLEM(TRUE)
11766 6-      THEN BEGIN
11767 --        WRITE("RESTART ERROR", ROOT, IDONE, LEVEL) ;
11768 --        PRINTSHORTBRD(-1) ;
11769 -6      END ;
11770 --      OLD := TRUE ;
11771 --      IF IDONE <= 0 THEN IDONE := NODETO(ROOT,0) := 1 ;
11772 --      PARTIAL := PART = 1 ;
11773 --      A_SCR := SCORE(TRY(1)) ;
11774 --      INCHECK := CON(-K,KINGSQ(K)) ~= 0 ;
11775 --      IF LEVEL >= MAXDEPTH
11776 --      THEN STATES(ROOT,2) := 1 ;
11777 --      IF TEST AND PARTIAL
11778 --      THEN WRITE("PART", PARTIAL, PART, A_SCR, BETA, NUM, INCHECK,
11779 --                 STATES(ROOT,5), IDONE, ROOT) ;
11780 -5    END ;
11781 --    IF PARTIAL
11782 --    THEN IF A_SCR <= BETA AND PART = 1 OR ~OLD
11783 5-         THEN BEGIN
11784 --           IF OLD
11785 6-           THEN begin
11786 --             for i := NODETO(ROOT,0) step -1 until 1 do
11787 --                MARK := MARKTREE(NODETO(ROOT,i), ROOT, packer, 0) ;
11788 --             MAKE_SPACE(ROOT, 0, -1, packer*LEVEL, MAXTREE) ;
11789 -6           end ;
11790 --                                COMMENT regain subtree from a partial node ;
11791 --           PARTIAL := DEEPER = 0 AND LEVEL > 2 ;
11792 --           UPPER := IF PARTIAL
11793 --                    THEN BETA + LEVEL
11794 --                    ELSE EIGHTS ;
11795 --           PARTIAL := UPPER ~= EIGHTS ;
11796 --           LISTLEGALMOVES (FALSE) ;
11797 --           IF UPPER = EIGHTS
11798 --           THEN PARTIAL := FALSE ;
11799 --           OLD := FALSE ;
11800 --           PART := IF PARTIAL
11801 --                   THEN 1
11802 --                   ELSE 0 ;
11803 --                             COMMENT array try already filled ;
11804 --           NODETO(ROOT,0) := IDONE := 0 ;
11805 --           CAPT_T := 0 ;
11806 --           HASH := T_HASH ;
11807 --           SAVESTATE(ROOT) ;
11808 -5    END ;
11809 --    EST_cnt := EXCESS := 0 ;
11810 --    MIN_WID := 1 ;
11811 --                             COMMENT no injection at max. depth ;
11812 --    IF ~PRINCVAR AND LEVEL < DEEP AND (~OLD OR LEVEL <= 3)
11813 5-    THEN BEGIN
11814 --      LX := TRY(WSIZE) ;
11815 --      FOR I := 1 UNTIL LX
11816 --      DO REFSAVE(I) := 1000*MOVEFROM(TRY(I)) + MOVETO(TRY(I)) ;
11817 --      IF LX > 1 THEN
11818 --      FOR I := 1 UNTIL REFUT(LEVEL,0)
11819 6-        DO BEGIN
11820 7-           IF (TEST) AND LEVEL < 3 THEN BEGIN
11821 --             IF I = 1
11822 --             THEN WRITE("CANDIDATES ") ;
11823 --             WRITEON(REFUT(LEVEL,I), REFCNT(LEVEL,I)) ;
11824 -7           END ;
11825 --           TMP := EST_cnt - REFCNT(LEVEL,I) ;
11826 --           IF TMP <= 0
11827 --           THEN FOR J := 1 UNTIL LX
11828 --                DO IF REFSAVE(J) = REFUT(LEVEL,I)
11829 --                     AND (TMP < 0 OR J < MIN_WID)
11830 7-                   THEN BEGIN
11831 --                     EST_cnt := REFCNT(LEVEL,I) ;
11832 --                     EXCESS := ABS(TMP) ;
11833 --                     MIN_WID := J ; comment this could reduce MIN_WID to 1 ;
11834 -7                END ;
11835 -6      END ;
11836 -5    END ;
11837 --    IF TEST AND EST_cnt > 0 AND DEEPER > 0 AND LEVEL = 2
11838 5-    THEN BEGIN
11839 --      TRACER(1, "?D") ;
11840 --      WRITE("INJ ", REFSAVE(MIN_WID), EST_cnt, IDONE, LENGTH) ;
11841 -5    END ;
11842 --    IF MIN_WID > 1 AND SCORE(TRY(MIN_WID)) ~= NOSCR
11843 5-    THEN BEGIN
11844 --      LX := IF MIN_WID > WIDTH OR ABS(REWARD(TRY(1))) >= 3 AND EXCESS < 4
11845 --                OR SCORE(TRY(1)) - SCORE(TRY(MIN_WID)) > 900
11846 --            THEN IF SCORE(TRY(2)) - SCORE(TRY(MIN_WID)) > 900
11847 --                 THEN 3
11848 --                 ELSE 2
11849 --            ELSE 1 ;
11850 --                                COMMENT Have just dynamically reordered to
11851 --                                        consider an effective killer move sooner ;
11852 --      IF TEST
11853 --      THEN WRITE("INJECT ", LEVEL, EST_cnt, MIN_WID, LX, NODETO(ROOT,0), LENGTH) ;
11854 --      IF LEVEL > 2
11855 --      THEN INC_wid := 1 ;
11856 --      IF IDONE < MIN_WID AND IDONE >= LX
11857 6-      THEN BEGIN
11858 --        IDONE := IDONE + 1 ;
11859 --        if (warning and MIN_WID = IDONE) and NODETO(ROOT,MIN_WID) > 0 then
11860 --          write("Warning: In TREE delete", NODETO(ROOT,min_wid), min_wid, idone) ;
11861 --        NODETO(ROOT,MIN_WID) := NIL ;
11862 -6      END ;
11863 --      SHIFT(MIN_WID, LX, ROOT) ;
11864 --      IF MIN_WID > TRY(0)
11865 --      THEN TRY(0) := TRY(0) + 1 ;
11866 --      HASH := T_HASH ;
11867 --      SAVESTATE(ROOT) ;
11868 -5    END ;
11869 --    IF ~OLD
11870 --    THEN STATES(ROOT,2) := 0 ;
11871 --    TYPE := IF PARTIAL
11872 --            THEN 1
11873 --            ELSE 0 ;
11874 --    SAVEBACK(LEVEL, FALSE) ;
11875 --    IF (NUM = 0) OR TRY(WSIZE) = 0
11876 5-    THEN BEGIN
11877 --                              COMMENT   rare mate or stalemate condition ;
11878 --      B_SCR := -(NINES - LEVEL + 1) ;
11879 --      IF ~INCHECK
11880 --      THEN B_SCR := -SIDE*DRAW ;
11881 --      FINAL := IF INCHECK
11882 --               THEN 4
11883 --               ELSE 2 ;
11884 --      KTEST := FINAL ;
11885 --      MX := -SIDE*B_SCR ;
11886 --      IP := 0 ;
11887 --      TOT := TOT + 1 ;
11888 --      IF TEST
11889 --      THEN WRITE(REASON(FINAL), " level/b_scr/side", LEVEL, B_SCR, side) ;
11890 --      NUM := 0 ;
11891 --      IF LEVEL = 1
11892 --      THEN GO TO QUIT ;
11893 --              comment return "root" node to available nodes list ;
11894 --              comment do not return "root" to available, need it on exit to TREE ;
11895 --      Reclaim_Node (ROOT, "TREE") ;
11896 --      NODE := ROOTNODE(LEVEL-1) ;
11897 --  
11898 6-      if ROOT ~= NODETO(NODE,NODETO(NODE,0)) then begin
11899 --        write("In Tree, returned root fixed? node/nodeto(node,0)/..>0/root",
11900 --               NODE, NODETO(NODE,0), NODETO(NODE,NODETO(NODE,0)), ROOT) ;
11901 --        for i := NODETO(NODE,0) step -1 until 1 do
11902 --          writeon(NODETO(NODE,i)) ;
11903 -6      end ;
11904 6-      for i := NODETO(NODE,0) step -1 until 1 do begin
11905 --             comment be sure to delete the correct pointer ;
11906 --        if ROOT > 0 then
11907 --          for j := NODETO(ROOT,0) step -1 until 1 do
11908 --            if NODETO(ROOT,j) > 0 then
11909 --              write("TREE-1 Will lose node", NODETO(ROOT,j), j, NODETO(ROOT,0)) ;
11910 --        if NODETO(NODE,i) = ROOT then
11911 --           NODETO(NODE,i) := NIL ;
11912 -6      end ;
11913 --      GO TO QUIT ;
11914 -5    END ;
11915 --               COMMENT IF MONITOR THEN TRACER(1, "?D") ;
11916 --    IF LEVEL = 1
11917 --    THEN TARGET := EXPECTATION
11918 --    ELSE TARGET := IF SIDE = 1
11919 --                   THEN + SCALE*ONEVAL
11920 --                   ELSE SCORE(TRY(1)) ;
11921 --    IF (FINAL ~= 5)
11922 --    THEN FINAL := 0 ;
11923 --    LIMIT := TRY(WSIZE) ;
11924 --    SCR := BETA ;
11925 --    FOR I := 1 UNTIL (IF LIMIT > 8 THEN 8 ELSE LIMIT)
11926 --    DO IF SCR > SCORE(TRY(I))
11927 --       THEN SCR := SCORE(TRY(I)) ;
11928 --    B_SCR := SCORE(TRY(1)) - PAWNVALUE - PAWNVALUE ;
11929 --    IF SCR < B_SCR
11930 --    THEN SCR := B_SCR ;
11931 --    IF PRINCVAR AND SACR_ANAL AND CAPTURE_TREE
11932 --        AND CAPT_T = 0 AND TRY(WSIZE) > 1 AND (LEVEL < LENGTH)
11933 --        AND LEVEL <= 5
11934 5-    THEN begin
11935 --      SCR := BUILD_SACR_TREE(ROOT, MAXPLY+1, SCR, ALPHA, BETA, IDONE) ;
11936 -5    end ELSE DISCARD := FALSE ;
11937 --    IF (LEVEL = 1)
11938 --    THEN FIRSTENTRY(ROOT)
11939 --    ELSE
11940 5-    begin
11941 --      IF (LEVEL = 2)
11942 --      THEN LIMIT := IF ~OPENING AND ~ENDGAME AND TRY(0) > WIDTH DIV 2
11943 --                    THEN TRY(0)
11944 --                    ELSE LIMIT
11945 --      ELSE LIMIT : = VARS(LEVEL, LENGTH) ;
11946 --      if MONITOR then
11947 --         write("setting width in TREE ", "try(0)=", try(0), "level=", LEVEL,
11948 --               "length=", length, "vars(lev,len)=", vars(LEVEL,length)) ;
11949 --      if MONITOR then
11950 --         write("limit=", limit, "width=", width, "try(wsize)=", try(wsize),
11951 --               "max_wid=", MAX_WID) ;
11952 --      if TRY(0) > LIMIT then
11953 --        TRY(0) := LIMIT ;
11954 --      if LIMIT > TRY(WSIZE) then
11955 --        LIMIT := TRY(WSIZE) ;
11956 --      if LIMIT > TRY(WSIZE) or LIMIT < TRY(0) then
11957 --        write("Question width limit/try(0)/try(wsize)/level/vars/length",
11958 --              limit, try(0), try(wsize), LEVEL, vars(LEVEL,length), length) ;
11959 -5    end ;
11960 --    SAVE_WIDTH := WIDTH ;
11961 --    IF PRINCVAR AND LEVEL = 2 AND LENGTH = 5 AND PATH > 1
11962 --        AND WIDTH < MAX_WID and MAX_WID > 12
11963 --    THEN LIMIT := WIDTH := 12 ;
11964 --                      COMMENT width may have been narrowed at previous iteration ;
11965 --    IF MONITOR and LEVEL = 2 AND LENGTH = 5 AND PRINCVAR AND PATH > 1
11966 --       or WIDTH > SAVE_WIDTH
11967 --    THEN WRITE("ITER WIDE", LIMIT, TRY(WSIZE), WIDTH, MAX_WID) ;
11968 --  
11969 --    IF LIMIT = 0 OR LIMIT > TRY(WSIZE)
11970 --    THEN LIMIT := TRY(WSIZE) ;
11971 --    IF IDONE > WIDTH
11972 5-    THEN BEGIN
11973 --      FOR I := IDONE STEP -1 UNTIL WIDTH+1
11974 6-      DO IF NODETO(ROOT,I) > 0 THEN BEGIN
11975 --        MAKE_SPACE(NODETO(ROOT,I), 0, -1, packer*LEVEL, MAXTREE) ;
11976 --        COLLECT(NODETO(ROOT,I), ROOT) ;
11977 --        IF MONITOR or NODETO(ROOT,i) > 0
11978 --        THEN WRITE("SPACE ", ROOT, I, NODETO(ROOT,0), NODETO(ROOT,I)) ;
11979 --        NODETO(ROOT,I) := -1 ;
11980 -6      END ;
11981 --                                COMMENT this just leaves the main line in place ;
11982 --      NODETO(ROOT,0) := IDONE := WIDTH ;
11983 -5    END ;
11984 --    IF (IDONE > LIMIT) AND IDONE <= WIDTH
11985 --    THEN LIMIT := IDONE ;
11986 --    IF LEVEL = 1 AND OLDSCR = FIVES
11987 --    THEN LASTSCR := - SCALE*ONEVAL ;
11988 --    IF (LEVEL < 3)
11989 --    THEN IF (PREVSCR = FIVES)
11990 --         THEN PASTSCR := + SCALE*ONEVAL ;
11991 --    IF LIMIT > WIDTH
11992 --    THEN LIMIT := WIDTH ;
11993 --    IF LEVEL > 2 AND LIMIT = w_size and w_size > 9
11994 --    THEN LIMIT := 9 ;
11995 --    MIN_WID := IF LEVEL > 4
11996 --           THEN 2
11997 --           ELSE IF LEVEL > 2
11998 --                THEN IF LATE_END OR ~QUICK
11999 --                     THEN 3
12000 --                     ELSE 2
12001 --                ELSE IF LATE_END OR ~QUICK OR EXAMINE
12002 --                     THEN LIMIT
12003 --                     ELSE IF LEVEL > 1
12004 --                          THEN LIMIT DIV 2
12005 --                          ELSE WIDTH DIV 2 ;
12006 --    MIN_WID := MIN_WID + INC_wid ;
12007 --                                  COMMENT for move injection ;
12008 --    REVERSE := FORCED := FALSE ;
12009 --    LOOKingAHEAD ; comment EXPAND generates new B_SCR ;
12010 --    WIDTH := SAVE_WIDTH ;
12011 --  QUIT:
12012 --    STATES(ROOT,6) := B_SCR ;
12013 --    IF (IP > TRY(0))
12014 --    THEN STATES(ROOT,T_SIZE+1) := TRY(0) := IP ;
12015 --    TOT_S := T_NODES - INIT_T_NODES + 1 ;
12016 --    STATES(ROOT,4) := TOT_S ;
12017 --    PLEX := IF PARTIAL AND FINISH OR FINAL = -5
12018 --            THEN 0
12019 --            ELSE DEEPER + 1 ;
12020 --    STATES(ROOT,2) := PLEX ;
12021 --    IF STATES(ROOT,5) < 1
12022 --    THEN STATES(ROOT,5) := TYPE ;
12023 --    SIDE := -SIDE ;
12024 --    IF TEST
12025 --    THEN WRITEON(REASON(FINAL), PLEX, TYPE) ;
12026 --    AB(LEVEL) := SIDE*B_SCR ;
12027 --    IF (LEVEL > 1)
12028 5-    THEN BEGIN
12029 --      LEVEL := LEVEL - 1 ;
12030 --      ROOT := ROOTNODE(LEVEL) ;
12031 --      RESTORESTATE(ROOT) ;
12032 --      RESTOREBACK(LEVEL, TRUE) ;
12033 --      TAKEBACKMOVE(TRUE) ;
12034 --      IF BETA > B_SCR AND PRINCVAR
12035 6-      THEN BEGIN
12036 --        IF TYPE = 0
12037 --        THEN REFUTE(1000*M2 + M3) ;
12038 --        IF TEST
12039 --        THEN WRITEON("**", MX, M2, M3) ;
12040 -6      END ;
12041 -5    END
12042 --    ELSE MAXSC(IP) := MX ;
12043 --    ID := IP ;  comment for use by SEARCH? ;
12044 --    B_SCR
12045 -4  END OF_TREE ;
12046 --  
12047 --  @TITLE, "SEARCH"
12048 --  
12049 --    LOST := VALUES(KNIGHT)*SCALE ;
12050 --    SCORES := TRUE ;
12051 --                                COMMENT essential for EXAMINE mode ;
12052 --    IF EXAMINE OR ~CBOTH AND (WHO OR FLAG(1) = 0) and REPLY ~= WSIZE
12053 --    THEN IF (ORIGIN > 0)
12054 --         THEN DEADTREE(REPLY)
12055 --         ELSE INIT_TREE ;
12056 --    IF TOURNAMENT
12057 4-    THEN BEGIN
12058 --      N := TIME_LEFT DIV (MOVES_LEFT + 1) ;
12059 --      WRITE("Time Advisory from SEARCH ", TIME_LEFT, MOVES_LEFT, M_TIMES(MODE),
12060 --             N, MODE, ORIGIN) ;
12061 --      IF MOVES_LEFT <= 0
12062 5-      THEN BEGIN
12063 --                                COMMENT extend time control to 30 in 30 ;
12064 --        MOVES_LEFT := MOVES_LEFT + 30 ;
12065 --        TIME_LEFT := TIME_LEFT + 108000 ;
12066 -5      END ;
12067 --      IF N < M_TIMES(MODE) OR N > M_TIMES(MODE+1)
12068 5-      THEN BEGIN
12069 --        WHILE N > M_TIMES(MODE) AND MODE < 6
12070 --        DO MODE := MODE + 1 ;
12071 --        WHILE N < M_TIMES(MODE) AND MODE > 0
12072 --        DO MODE := MODE - 1 ;
12073 --        IF MODE >= 1 AND MODE <= 6
12074 6-        THEN BEGIN
12075 --          CASE MODE OF
12076 7-          BEGIN
12077 --            BLITZ ;
12078 --           ;
12079 --           ;
12080 --            INTERMEDIATE ;
12081 --            TOURNAMENTS ;
12082 --            EXPERIMENTAL ;
12083 -7          END ;
12084 -6        END ;
12085 -5      END ;
12086 --      WRITEON(ORIGIN, N, MODE) ;
12087 -4    END ;
12088 --                                COMMENT collect opponent tree ;
12089 --    SECOND := SMALL := FALSE ;
12090 --    POINT := 0 ;
12091 --    IF (ORIGIN <= 0)
12092 4-    THEN BEGIN
12093 --      ORIGIN := GETNODE(1) ;
12094 --      NODETO(ORIGIN,0) := -FIVES ;
12095 --      POINT := 1 ;
12096 --      ALPHA := SCALE*ONEVAL ;
12097 -4    END ELSE
12098 4-    BEGIN
12099 --      RESTORESTATE(ORIGIN) ;
12100 --      ALPHA := SCORE(TRY(1)) ;
12101 -4    END ;
12102 --      COMMENT WRITE("SEARCH", ORIGIN, NODETO(ORIGIN,0), POINT, MAXL) ;
12103 --    DEEP := IF EARLY
12104 --              THEN 5
12105 --              ELSE IF ~ENDGAME
12106 --                   THEN 7
12107 --                   ELSE IF TOURNAMENT AND ~QUICK
12108 --                        THEN 9
12109 --                        ELSE 7 ;
12110 --    IF MODE = 6
12111 --    THEN DEEP := IF LATE_END
12112 --                 THEN 9
12113 --                 ELSE IF ENDGAME
12114 --                      THEN 7
12115 --                      ELSE 5 ;
12116 --    IF MODE = 6
12117 --    THEN DEEP := MAXLEV ;
12118 --    IF DEEP > MAXLEV
12119 --    THEN DEEP := MAXLEV ;
12120 --    FOR I := 0 UNTIL ELIMIT
12121 4-    DO BEGIN
12122 --      BACK(0,I) := SQUARE(I) ;
12123 --      BACK(0,I+ELIMIT+1) := LOSS(I) ;
12124 -4    END ;
12125 --    E_NUM := 35 ;
12126 --    KTEST := 0 ;
12127 --    TOTALS := MAXTREE - MAXL ;
12128 --    LIMBS := BRAN ;
12129 --    Best_SCR := 0 ;	comment any value less than SEVENS will do ;
12130 --    SAL := SAL + TOTALS ;
12131 --    PLY := IF POINT = 0 AND DEEP >= 3 AND MAX_WID ~= w_size
12132 --           THEN 3
12133 --           ELSE 1 ;
12134 --    WHILE PLY <= DEEP AND (WHO OR FLAG(1) = 0) AND Best_SCR < SEVENS
12135 --           AND (KTEST = 0 OR REPLY > 0)
12136 4-    DO BEGIN
12137 --      MAXDEPTH := LENGTH := PLY ;
12138 --      EXPECTATION := ALPHA ;
12139 --      BETA := ALPHA + THRESHOLD ;
12140 --      ALPHA := ALPHA - THRESHOLD ;
12141 --      MINDEPTH := MAXDEPTH - 2 ;
12142 --      IF EARLY
12143 --      THEN MINDEPTH := 5 ;
12144 --      IF MINDEPTH < 3
12145 --      THEN MINDEPTH := 3 ;
12146 --      IF (E_NUM < 16) AND TOURNAMENT AND ~EARLY
12147 5-      THEN BEGIN
12148 --        NEWLEVEL := MAXDEPTH ;
12149 --        NEWNODES := MAXL DIV 3 ;
12150 -5      END
12151 --      ELSE IF (E_NUM < 31) OR TOURNAMENT
12152 5-           THEN BEGIN
12153 --             NEWLEVEL := MAXDEPTH - 2 ;
12154 --             NEWNODES := MAXL DIV (IF TOURNAMENT
12155 --                                   THEN 3
12156 --                                   ELSE 5) ;
12157 -5           END
12158 5-           ELSE BEGIN
12159 --             NEWLEVEL := MINDEPTH ;
12160 --             NEWNODES := MAXL DIV 5 ;
12161 -5      END ;
12162 --      IF (MINDEPTH < NEWLEVEL)
12163 --      THEN MINDEPTH := NEWLEVEL ;
12164 --      IF (MAXNODES < NEWNODES)
12165 --      THEN MAXNODES := NEWNODES + 1 ;
12166 --      IF (MAXDEPTH > LENGTH)
12167 --      THEN MAXDEPTH := LENGTH ;
12168 --      IF (MINDEPTH > MAXDEPTH)
12169 --      THEN MINDEPTH := MAXDEPTH ;
12170 --      IF MODE = 6 AND DEEP = 5 AND ~OPENING
12171 --      THEN MINDEPTH := MAXDEPTH ;
12172 --      pass2 := false ;
12173 --  REPEAT:
12174 --      if pass2 then write("Repeat search ", REPLY, alpha, Best_scr, beta) ;
12175 --      pass2 := true ;
12176 --      REPLY := 0 ;
12177 --      FULLWIN := TRUE ;
12178 --      REUSE := MAXL ;
12179 --      FOR LEV := 1 UNTIL MAX_PLIES
12180 5-      DO BEGIN
12181 --        FOR I := 0 UNTIL 10
12182 --          DO REFUT(LEV,I) := REFCNT(LEV,I) := 0 ;
12183 --        FOR I := 1 UNTIL MAX_WID+MAX_PLIES
12184 --          DO REFTAB(I,LEV) := 0 ;
12185 -5      END ;
12186 --      IF MONITOR AND ~TEST
12187 5-      THEN BEGIN
12188 --        write("Turning debug monitoring on.  Output in Awit_Debug.txt") ;
12189 --        TRACER(3, "?NPD") ;
12190 --        write("Debug trace ON-----------------------------------------------") ;
12191 --        MON := TEST := TRUE ;
12192 -5      END ELSE MON := FALSE ;
12193 --      NODE := ORIGIN ;
12194 --      SIDE := 1 ;
12195 --      NEW := 0 ;
12196 --      BRANCHES := BRAN ;
12197 --      MOST := -EIGHTS + 1 ;
12198 --      T_NODES := 0 ;
12199 --      LEVEL := 1 ;
12200 --      PATH := 0 ;
12201 --      IF PAB
12202 --      THEN ALPHA := -EIGHTS ;
12203 --      IF PAB
12204 --      THEN BETA := EIGHTS ;
12205 --      FIRSTONE := 0 ;
12206 --      FOR I := 1 UNTIL MAXTREE
12207 5-      DO BEGIN
12208 --                    COMMENT make sure individual nodes are reclaimed,
12209 --                            not individual subtrees ;
12210 --             comment the following is problematic if parent(i) is -1 ;
12211 --        PARENT(I) := PARENT(I) + packer ;
12212 --        STATES(I, 2) := 0 ;
12213 -5      END ;
12214 --      SACR_ANAL := LENGTH <= 3 AND MAX_WID ~= w_size
12215 --                          OR MAX_WID = w_size AND LENGTH > 3 ;
12216 --      Best_SCR := TREE(ALPHA, BETA, HASH, MINDEPTH-1, PAB, TYPE) ;
12217 --      LEVEL := 1 ;
12218 --      T_NODES := NODETO(ORIGIN,0) ;
12219 --      SAVEL := POINT + 1 ;
12220 --      TOTALS := TOTALS + NEW ;
12221 --      BRANCHES := BRAN - BRANCHES ;
12222 --      E_NUM := IF BRANCHES <= 0 OR NEW <= 0
12223 --               THEN E_NUM
12224 --               ELSE BRANCHES DIV NEW ;
12225 --      IF (TEST)
12226 --      THEN WRITE(LEVEL, MINDEPTH, SAVEL, MAXL, T_NODES, MAXNODES, NOD, DUP,
12227 --                 MOST, OLDSCR, PREVSCR, ORIGIN, NODETO(ORIGIN,REPLY),
12228 --                 GETNODE(POINT), GETNODE(SAVEL)) ;
12229 --      IOCONTROL(2) ;
12230 --      IF MON
12231 5-      THEN BEGIN
12232 --        MON := TEST := FALSE ;
12233 --        write("Turning Debug trace OFF----------------------------------") ;
12234 --        iocontrol(2) ;    comment put newline at end of debug file ;
12235 --        TRACER(1, "?N") ;
12236 --        write("Turning debug monitoring off.  Output to terminal") ;
12237 -5      END ;
12238 --      SECOND := IF TOURNAMENT AND (MOST < EXPECT)
12239 --                THEN TRUE
12240 --                ELSE FALSE ;
12241 --      IF LENGTH > 1
12242 --      THEN IF true 
12243 --              or SKILL > "  BEGINNER" OR EXAMINE OR TEST OR MONITOR OR FLAG(1) = 0
12244 5-           THEN BEGIN
12245 --             T_NODES := ID ;
12246 --             IF ~MONITOR AND ID > 13
12247 --             THEN ID := 13 ;
12248 --             WRITE(Best_SCR, EXPECT, ": ") ;
12249 --             FOR I := 1 UNTIL ID
12250 --               DO WRITEON(MAXSC(I)) ;
12251 --             WRITE(ALPHA, BETA, ": ") ;
12252 --             FOR I := 1 UNTIL ID
12253 --               DO WRITEON(BOX(MOVEFROM(TRY(I))), BOX(MOVETO(TRY(I))), " ") ;
12254 --  
12255 --             WRITE(BRANCHES, "SCORED ", NEW, "/", TOTALS, "POSNS.",
12256 --                   REPLY, "/", T_NODES) ;
12257 --             WRITEON(" DEPTH =", LENGTH, E_NUM, (TIME(1)-OLDCPU) DIV 60)
12258 --              ;
12259 --             IOCONTROL(2) ;
12260 -5      END ;
12261 5-      IF (TEST) and id > 0 THEN BEGIN
12262 --        WRITE("REFUTATIONS-three ", ID, ORIGIN, NODETO(ORIGIN,0)) ;
12263 --        IOCONTROL(2) ;
12264 6-        FOR I := 1 UNTIL ID DO BEGIN
12265 --          INTERIOR := TRUE ;
12266 --          FOR LEV := 1 UNTIL MAX_PLIES
12267 --          DO IF INTERIOR AND REFTAB(I,LEV) > 0
12268 --             THEN WRITEON(REFTAB(I,LEV))
12269 --             ELSE INTERIOR := FALSE ;
12270 --          IOCONTROL(2) ;
12271 -6        END ;
12272 -5      END ;
12273 --      FOR I := 0 UNTIL ELIMIT
12274 5-      DO BEGIN
12275 --        SQUARE(I) := BACK(0,I) ;
12276 --        LOSS(I) := BACK(0,I+ELIMIT+1) ;
12277 -5      END ;
12278 5-      if Best_scr ~= MOST then begin
12279 --        write("In SEARCH length/flag(1)/best_scr ~= most/alpha/beta/reply") ;
12280 --        write("      ", length, flag(1), Best_scr, most, alpha, beta, REPLY) ;
12281 -5      end ;
12282 --      IF LENGTH > 1 AND (WHO OR FLAG(1) = 0)
12283 --      THEN IF Best_SCR ~= MOST OR Best_SCR < ALPHA OR Best_SCR > BETA
12284 5-           THEN BEGIN
12285 --             IF REPLY <= 0
12286 --             THEN WRITE("ALPHA-BETA ERROR: reply -ve? ", Best_SCR, MOST, REPLY,
12287 --               ALPHA, BETA)
12288 6-             ELSE BEGIN
12289 --               comment GAMETREE(ORIGIN, 1, 1) ;
12290 --               comment GAMETREE(ORIGIN, 1, width) ;
12291 --               COMMENT LISTMOVES ;
12292 --               comment TRACER(1, "?D") ;
12293 --               comment write("best_scr != most", 
12294 --                     Best_scr, most, length, who, flag(1)) ;
12295 -6             END ;
12296 --             IOCONTROL(2) ;
12297 --             IF REPLY <= 0
12298 --             THEN REPLY := 1 ;
12299 --             IF Best_SCR <= ALPHA
12300 6-             THEN BEGIN
12301 --               INVALIDATE(ORIGIN) ;
12302 --               BETA := Best_SCR + 1 ;
12303 --               ALPHA := Best_SCR - THRESHOLD ;
12304 --               GOTO REPEAT ;
12305 -6             END ELSE IF Best_SCR >= BETA
12306 6-                      THEN BEGIN
12307 --                        INVALIDATE(ORIGIN) ;
12308 --                        ALPHA := Best_SCR - 1 ;
12309 --                        BETA := Best_SCR + THRESHOLD ;
12310 --                        GOTO REPEAT ;
12311 -6             END ;
12312 -5      END ;
12313 --      ALPHA := SCORE(TRY(1)) ;
12314 --                         COMMENT retrieve nodes (if any) in width+1 ... 2*width ;
12315 --      IF MAX_WID = w_size THEN
12316 --           IF (~LATE_END AND PLY = 3 OR PLY = 7 OR PLY = 5
12317 --                AND (~ENDGAME OR WIDTH = MAX_WID
12318 --                     OR TIME(1)-OLDCPU > M_TIMES(MODE) DIV 3))
12319 --           THEN WIDTH := WIDTH DIV 2 ;
12320 --      IF MODE = 6
12321 --      THEN IF PLY >= 5 AND (E_NUM >= 30 OR TOTALS > MAXTREE)
12322 --              AND (TIME(-1) - SENDTIME > 7200 OR TIME(1) - OLDCPU > 5400)
12323 --              OR TOTALS > 2*MAXTREE
12324 --           THEN DEEP := 5
12325 --           ELSE IF PLY >= 7 AND (E_NUM >= 15 OR PIECES(0) > 12)
12326 --                THEN DEEP := 7 ;
12327 --      IF TRY(WSIZE) = 1
12328 --      THEN PLY := DEEP ;
12329 --      PLY := PLY + 2 ;
12330 -4    END ;
12331 --    LIMBS := BRAN - LIMBS ;
12332 --    WIDTH := MAX_WID ;
12333 --    IF TEST
12334 --    THEN WRITE(TOURNAMENT, MOST, EXPECT, SMALL, REPLY, SECOND, FORCEDREPLY,
12335 --               MINDEPTH, MAXDEPTH) ;
12336 --    IOCONTROL(2) ;
12337 --    WRITE(" ") ;
12338 --    IF (REPLY = 0)
12339 4-    THEN BEGIN
12340 --      REPLY := 1 ;
12341 --                          COMMENT  mate/stalemate detected ;
12342 --      WRITE("ERROR IN SEARCH", TRY(1), NUM, MOST, MAXSC(REPLY),
12343 --            TRY(0), TRY(WSIZE), ORIGIN) ;
12344 -4    END ;
12345 --    LASTORIGIN := ORIGIN ;
12346 --    RTMV := TRY(1) ;
12347 --    IF RTMV = 0 or TRY(WSIZE) = 1
12348 4-    THEN begin
12349 --      WRITE("SEAR", TRY(0), TRY(1), TRY(WSIZE), who, examine, LASTORIGIN) ;
12350 --      writeon(REPLY, rtmv, NODETO(LASTORIGIN,1)) ;
12351 -4    end ;
12352 --    SCORE(RTMV) := MAXSC(REPLY) ;
12353 --    PREDICT := REPLY ;
12354 --    IF WHO OR ~EXAMINE
12355 --    THEN DEADTREE (1)
12356 --    ELSE ORIGIN := NODETO(LASTORIGIN,1) ;
12357 -3  END OF_SEARCH ;
12358 --  
12359 --  @TITLE, "MAIN"
12360 --  
12361 --    WHILE TRUE
12362 --    DO HUB ;
12363 -2  END OF_MAIN ;
12364 --  
12365 --  PROCEDURE ATTENTION (INTEGER ARRAY FLAG(*)) ;
12366 --  FORTRAN "ATTENTION" ;   comment MTS system routine ;
12367 --  
12368 --  PROCEDURE TRANSFER (STRING(140) VALUE RESULT B ; INTEGER VALUE RESULT L ;
12369 --                     INTEGER VALUE M ; INTEGER VALUE RESULT N ; INTEGER VALUE U, RW) ;
12370 --  FORTRAN "TRANSF" ;
12371 --  
12372 --  PROCEDURE DATER (INTEGER VALUE KEY, PR ; STRING(12) RESULT DATE) ;
12373 --  FORTRAN "DATER" ;   comment MTS system routine ;
12374 --  
12375 --  PROCEDURE MMTTS (INTEGER VALUE INDEX ; STRING (140) VALUE RESULT HISTORY) ;
12376 --  FORTRAN "DEPEND" ;
12377 --  
12378 --  PROCEDURE INFLUENCE (LOGICAL VALUE FINAL) ;
12379 2-  BEGIN
12380 --    INTEGER TOP, J, K_FILE, I ;
12381 --  
12382 --    K_FILE := FILES(K) ;
12383 --    IF REMEMBER AND FINAL
12384 3-    THEN BEGIN
12385 --      LSAVE := SQUARE(0) ;
12386 --      ESAVE := SQUARE(ELIMIT) ;
12387 -3    END ;
12388 --    IF (ABS(REWARD(N)) = PFTWO)
12389 --    THEN IF (ABS(BRD(M3-K_FILE)) = ENPRIS)
12390 3-         THEN BEGIN
12391 --           I := LOSS(0) := LOSS(0)+1 ;
12392 --           SQUARE(I) := M3-K_FILE ;
12393 --           LOSS(I) := 0 ;
12394 -3    END ;
12395 --    TOP := LOSS(ELIMIT) ;
12396 --    FOR I := TOP UNTIL SQUARE(ELIMIT)-1
12397 3-    DO BEGIN
12398 --      J := I + 1 ;
12399 --      WHILE (J < ELIMIT)
12400 --      DO IF (SQUARE(J) = SQUARE(I))
12401 4-         THEN BEGIN
12402 --           IF (I >= ESAVE)
12403 5-           THEN BEGIN
12404 --             SQUARE(I) := SQUARE(ESAVE) ;
12405 --             SQUARE(ESAVE) := SQUARE(TOP) ;
12406 --             ESAVE := ESAVE + 1 ;
12407 -5           END ELSE SQUARE(I) := SQUARE(TOP) ;
12408 --           J := ELIMIT ;
12409 --           TOP := TOP + 1 ;
12410 -4      END ELSE J := J + 1 ;
12411 -3    END ;
12412 --    LOSS(ELIMIT) := TOP ;
12413 --    TOP := LOSS(0) ;
12414 --    FOR I := LOSS(0) STEP -1 UNTIL SQUARE(0)+1
12415 3-    DO BEGIN
12416 --                              COMMENT purge duplicated squares from enpris list ;
12417 --      J := I - 1 ;
12418 --      WHILE (J > 0)
12419 --      DO IF (SQUARE(I) = SQUARE(J))
12420 4-         THEN BEGIN
12421 --           IF (I <= LSAVE)
12422 5-           THEN BEGIN
12423 --             SQUARE(I) := SQUARE(LSAVE) ;
12424 --             SQUARE(LSAVE) := SQUARE(TOP) ;
12425 --             LSAVE := LSAVE - 1 ;
12426 -5           END ELSE SQUARE(I) := SQUARE(TOP) ;
12427 --           J := 0 ;
12428 --           TOP := TOP - 1 ;
12429 -4      END ELSE J := J - 1 ;
12430 -3    END ;
12431 --    LOSS(0) := TOP := TOP + 1 ;
12432 --    SQUARE(TOP) := M3 ;
12433 --    LOSS(TOP) := -NINES ;
12434 -2  END OF_INFLUENCE ;
12435 --  
12436 --  LOGICAL PROCEDURE CLEAR (INTEGER VALUE SQA, SQF, SQT) ;
12437 2-  BEGIN
12438 --    INTEGER DIR ;
12439 --    LOGICAL FREE ;
12440 --  
12441 --    FREE := FALSE ;
12442 --    DIR := BOTV(EDGE, OFFSET(SQF)-OFFSET(SQT)) ;
12443 3-    IF DIR ~= 0 THEN BEGIN
12444 --      FREE := TRUE ;
12445 --      IF SQA ~= SQF
12446 --           AND DIR = BOTV(EDGE, OFFSET(SQA)-OFFSET(SQT))
12447 --      THEN FREE := FALSE ;
12448 --      FOR SQ := SQF+DIR STEP DIR UNTIL SQT-DIR
12449 --        DO IF FREE AND BRD(SQ) ~= 0
12450 --           THEN FREE := FALSE ;
12451 -3    END ;
12452 --    FREE
12453 -2  END OF_CLEAR ;
12454 --  
12455 --  PROCEDURE REFLECT (INTEGER ARRAY BRD(*)) ;
12456 2-  BEGIN
12457 --    INTEGER I, J, M, L, PC ;
12458 --    LOGICAL C ;
12459 --  
12460 --    FOR J := 0 UNTIL 3
12461 --    DO FOR I := 11 UNTIL 18
12462 3-    DO BEGIN
12463 --      M := J*10 + I ;
12464 --      L := (7-J)*10 + I ;
12465 --      PC := BRD(M) ;
12466 --      BRD(M) := -BRD(L) ;
12467 --      BRD(L) := -PC ;
12468 -3    END ;
12469 --    K := -K ;
12470 --    FOR I := 1 UNTIL 3
12471 3-    DO BEGIN
12472 --      C := CASTLE(I) ;
12473 --      CASTLE(I) := CASTLE(-I) ;
12474 --      CASTLE(-I) := C ;
12475 -3    END ;
12476 --    PUT(4) ;
12477 --    PUNCHBRD(TRUE, HISTORY(0|140)) ;
12478 --    WRITECARD(HISTORY(0|114)) ;
12479 --    PUT(TTYOUT) ;
12480 -2  END OF_REFLECT ;
12481 --  
12482 --  STRING(6) PROCEDURE INTOCHAR (INTEGER VALUE NUMBER) ;
12483 2-  BEGIN
12484 --    INTEGER X, I, NUM ;
12485 --    STRING(6) TMP ;
12486 --  
12487 --    TMP := IF NUMBER >= 0 THEN "     0" ELSE "-    0" ;
12488 --    NUM := ABS(NUMBER) ;
12489 --    I := 5 ;
12490 --    WHILE NUM > 0
12491 3-    DO BEGIN
12492 --      X := NUM REM 10 ;
12493 --      NUM := NUM DIV 10 ;
12494 --      TMP(I|1) := CODE(X + 240) ;
12495 --      I := I - 1 ;
12496 -3    END ;
12497 --    IF I < 0 THEN
12498 --     WRITE("ERROR, NUM TOO LONG ", NUMBER, TMP, I, X)
12499 3-    ELSE BEGIN
12500 --      TMP(I|1) := TMP(0|1) ;
12501 --      IF I > 0 THEN TMP(0|1) := " " ;
12502 -3    END ;
12503 --    TMP
12504 -2  END OF_INTOCHAR ;
12505 --  
12506 --  INTEGER PROCEDURE CHARTOINT (STRING(6) VALUE NUM) ;
12507 2-  BEGIN
12508 --    INTEGER I, N ;
12509 --    LOGICAL NEGATIVE ;
12510 --  
12511 --    I := 0 ;
12512 --    WHILE NUM(I|1) = " "
12513 --    DO I := I + 1 ;
12514 --    NEGATIVE := NUM(I|1) = "-" ;
12515 --    IF NEGATIVE THEN I := I + 1 ;
12516 --    N := 0 ;
12517 3-    WHILE I < 6 DO BEGIN
12518 --      N := 10*N + DECODE(NUM(I|1)) - 240 ;
12519 --      I := I + 1 ;
12520 -3    END ;
12521 --    IF NEGATIVE THEN N := -N ;
12522 --    N
12523 -2  END OF_CHARTOINT ;
12524 --  
12525 --  
12526 --  INTEGER PROCEDURE NEWHASH (INTEGER ARRAY BRD(*) ; INTEGER VALUE K ;
12527 --                             STRING(2) RESULT KEY) ;
12528 --  ALGOL "NEWHASH" ;
12529 --  
12530 --                           COMMENT start of main program.  First entry is here. ;
12531 --      *{void Init_Support(int argc,char **argv) ;
12532 --          Init_Support(argc,argv) ;
12533 --       } ;
12534 --      COMMENT The above tells the Aw2c converter to put code there that calls the
12535 --              C-based support library.  This way we can initialize the data file,
12536 --              set up the temp filenames, etc. that are needed to pretend we are
12537 --              running on MTS. ;
12538 --    FLAG(1) := 1 ;
12539 --    ATTENTION(FLAG) ;
12540 --    TTYOUT := 6 ;
12541 --    GET(5) ;
12542 --    PUT(TTYOUT) ;
12543 --    S_W := 1 ;
12544 --    MAXCHAR := 118 ;
12545 --    ELIMIT := 31 ;
12546 --    LIM := 29 ;
12547 --    HOLE := -11 ;
12548 --                  COMMENT one word buffer seems necessary ;
12549 --    BAD := -3333 ;
12550 --                      COMMENT see initialize ;
12551 --    WSIZE := 27 ;
12552 --    w_size := WSIZE - 1 ;
12553 --    RLIMIT := 15 ;
12554 --    CONLIM := 8 ;
12555 --    I_W := 3 ;
12556 --    ZEROTIME := TIME(-1) ;
12557 --    MAXTREE := 80 ;
12558 --    MAXPLY := 2 ;
12559 --    MAXLEV := 3 ;
12560 --    TOTAL := 80 ;
12561 --    WIDTH := 5 ;
12562 --    E_Depth := 91 ;	comment generalizing Carey Bloodworth suggestion ;
12563 --    vars_depth := 15 ;
12564 --    packer := 10000 ;
12565 --    default := true ;
12566 --    write("SPEED defaults:", MAXTREE, "Positions per move.",
12567 --          WIDTH, "Moves per position.", MAXLEV, "Ply per move.") ;
12568 --    I_W := 5 ;
12569 --    GO TO ENTER ;
12570 --  ENTRY:
12571 --    default := false ;
12572 --    WRITE("Enter MAXTREE, MAXLEV, TOTAL, WIDTH") ;
12573 --    WRITE("If zeros then defaults of 999, 7, 80 and 12 are used") ;
12574 --    WHILE READU
12575 --    DO ;
12576 --    MAXTREE := CONVERTS(U, INERR) ;
12577 --    IF INERR
12578 --    THEN GO TO ENTRY ;
12579 2-    if MAXTREE > packer then begin
12580 --      MAXTREE := packer ;
12581 --      write ("MAXTREE restricted to ", packer, " nodes.") ;
12582 --      write ("Conflict with packing/unpacking of moves") ;
12583 -2    end ;
12584 --    MAXLEV := CONVERTS(U, INERR) ;
12585 --    IF INERR
12586 --    THEN GO TO ENTRY ;
12587 2-    if MAXLEV > vars_depth - MAXPLY then begin
12588 --      write("MAXLEV restricted to:", vars_depth-maxply) ;
12589 --      write("Increase size of VARS array to", MAXLEV+MAXPLY) ;
12590 --      MAXLEV := vars_depth - MAXPLY ;
12591 -2    end ;
12592 --    TOTAL := CONVERTS(U, INERR) ;
12593 --    IF INERR
12594 --    THEN GO TO ENTRY ;
12595 --    WIDTH := CONVERTS(U, INERR) ;
12596 --    IF INERR
12597 --    THEN GO TO ENTRY ;
12598 --    MAXTREE := IF (MAXTREE < 10)
12599 --               THEN 999
12600 --               ELSE IF MAXTREE > 15
12601 --                    THEN MAXTREE
12602 --                    ELSE 15 ;
12603 --    MAXLEV := IF (MAXLEV <= 0)
12604 --              THEN 7
12605 --              ELSE IF MAXLEV < 3
12606 --                   THEN 3
12607 --                   ELSE MAXLEV ;
12608 --    TOTAL := IF (TOTAL < 20)
12609 --             THEN 80
12610 --             ELSE TOTAL ;
12611 --    WIDTH := IF (WIDTH <= 0)
12612 --             THEN 12
12613 --             ELSE if WIDTH >= w_size
12614 --                  then w_size - 1
12615 --                  else WIDTH ;
12616 --    if MAXTREE <= 15 and WIDTH > 3
12617 --    then WIDTH := 3 ;  comment for DEBUG mode only ;
12618 --    if MAXTREE <= 15 and MAXLEV > 3
12619 --    then MAXLEV := 3 ;  comment for DEBUG mode only ;
12620 --  
12621 --  COMMENT   These are the (January 2009) intended modes of play, with settings
12622 --  Name    Debug   Speed   Beginner        Intermediate    Tournament Experimental
12623 --  
12624 --  Mode        1       2       3               4               5           6
12625 --  Width
12626 --    moves     3       5       9               12              19          25
12627 --  Depth
12628 --    ply       3       3       3               5               7           9
12629 --  Non-quiescent
12630 --    extension
12631 --    ply       0       2       2               2               2           2
12632 --  Node
12633 --    Space     15      80      100             999             999      >1000
12634 --  ;
12635 --  
12636 --  ENTER:
12637 --    DEPTH_LIMIT := MAX_PLIES := MAXLEV + MAXPLY ;
12638 --    T_SIZE := 8 ;
12639 --    S_SIZE := 20 + 2*RLIMIT ;
12640 --    TSIZE := S_SIZE + 83 + 2 + 2*ELIMIT ;
12641 --    CAPT_WID := 14 ;
12642 --    WIDTH_LIMIT := MAX_WID := WIDTH ;
12643 --    W_LIM := 4*(CAPT_WID) ;
12644 2-    if ~ default then begin
12645 --      I_W := 4 ;
12646 --      WRITE("  max_plies=", MAX_PLIES, "max_wid=", MAX_WID, "maxtree=", MAXTREE,
12647 --            "t_size=", T_SIZE, "width=", WIDTH, "  wsize=", WSIZE) ;
12648 --      WRITE("rlimit=", RLIMIT, "maxply=", MAXPLY,
12649 --            MAXLEV-2, "<= depth range <=", MAXLEV, "  quick-?Q=", QUICK) ;
12650 --      WRITE("Tournament-?T=", TOURNAMENT, "lookahead-?L=", LOOKAHEAD,
12651 --             "dumpp-?1=", DUMPP, "ws-?2=", WS) ;
12652 --      WRITE("  test-?7=", TEST, "monitor-?M=", MONITOR,
12653 --            "capture_tree-?J=", CAPTURE_TREE, "examine-?E=", EXAMINE) ;
12654 --      I_W := 5 ;
12655 -2    end ;
12656 --    INITIALIZE ;
12657 --    write("        Awit HistoryFile  LineCount =", COUNT) ;
12658 --  STARTS:
12659 --    ASSERT(WSIZE > CAPT_WID AND TOTAL <= 80 AND RLIMIT <= 15) ;
12660 --    ASSERT(LIM = 29 AND CONLIM = 8 AND ELIMIT = 31 AND WIDTH <= MAX_WID) ;
12661 --    ASSERT(WIDTH <= w_size and E_Depth >= MAX_PLIES) ;
12662 --    LENGTH := MAXLEV ;
12663 --    MAIN ;
12664 --  STOP:
12665 --    COKO := FALSE ;
12666 --    ZEROTIME := TIME(-1) - ZEROTIME ;
12667 --    IF ZEROTIME < 0
12668 --    THEN ZEROTIME := ZEROTIME + 5184000 ;
12669 --    WRITE("PROCESSOR TIME = ", TIME(1) DIV 60,
12670 --          "SECS.  ELAPSED TIME = ", (ZEROTIME) DIV 3600,"MINS.") ;
12671 --    IF BOOK ~= 1
12672 --    THEN GAMERECORD(TRUE) ;
12673 --  
12674 -1  END.
12675 --  COMMENT                   24 Oct 1980
12676 --           credits and debits in MAKEMOVE
12677 --  
12678 --   C(0) to C(13) accumulated for side to move: C(14) & C(15) not.
12679 --  
12680 --   0  -DEBIT(LEVEL-2)
12681 --   1  early pawn structures to encourage Bishop moves  (1,2)
12682 --   2  doubled pawn, not recapturable       (-2)
12683 --   3  pawn capture undoubling pawn        (1)
12684 --   4  phalanx of pawns or back pawn push    (1,2)
12685 --   5  capture of pawn leads to recapture which doubles pawns (1,2)
12686 --   6  unsafe promotion    (-20)
12687 --   7  rook move on/off (half) open file (+-1,+-2)
12688 --      open file for rook upon castling      (1,2)
12689 --   8  pawn capture blocks/unblocks rook on file  (-1,1)
12690 --      doubling/undoubling rooks      (+-1)
12691 --      unless fully blocked file      (0)
12692 --   9  penalize p-r4 if can castle or early and
12693 --         opponent  not castled on that side.    (-2)
12694 --   10 penalize pawn forward two infront of king, except p-k4     (-1)
12695 --   11 penalize queen move in early opening    (-3)
12696 --          or moving king and losing castling priviledge      (-1)
12697 --              fork threat credit          (+3)
12698 --   12 capture backward pawn                 (1)
12699 --   13 tempo loss penalty      (-1)
12700 --   14 take rook on/off column of own passed pawn    (+-1)
12701 --   15 credit for being able to make safe push of passed pawn   (L+1)
12702 --  
12703 --   debits D(0) to D(12) accumulated for opponent: not D(13), .. D(15)
12704 --  
12705 --   0  0
12706 --   1  pawn capture isolates/joins pawns    (+-1)
12707 --   2  credit for pushing secondary passedpawn    (T)
12708 --   3  created passedpawn for opponent      (-T)
12709 --   4  hole creation debit          (-1)
12710 --      fix opponent hole           (2)
12711 --      give up fix on hole        (-2)
12712 --   5  capture of pawn creates a secondary passedpawn    (T)
12713 --   6  captured an isolated pawn       (-1)
12714 --   7  capture advanced, or principal/secondary passed, pawn    (T)
12715 --   8  moving rook onto row adjacent to king      (1)
12716 --      moving rook off row adjacent to king, and not giving check (-1)
12717 --   9  Fill hole with N, P or B             (T)
12718 --   10 blocking own pawn in opening, or central pawn anytime    (-1)
12719 --   11 unblocking backward pawn, own/opponent       (+-1)
12720 --        or capture of backpawn                   (1)
12721 --   12 safe promotion    (MAXLEV-LEVEL+1)
12722 --   13 capture of pawn creates new passed pawn    (T)
12723 --   14 opponent has passed pawn      (T)
12724 --   15 credit for pushing primary passed pawn        (T)
12725 --      credit for having a primary passed pawn      (T)
12726 --   ;
12727 --  COMMENT    definition of tree statistics symbols.
12728 --  
12729 --    BRAN   - # branches in positions considered.
12730 --    BRAN_S - # branches actually scored, BRAN_S <= BRAN
12731 --    NOD    - # positions scored, BRAN/NOD = average tree width.
12732 --    TOT    - # terminal nodes
12733 --    DYN    - # dynamic terminal nodes    DYN <= TOT
12734 --    CAPT   - # positions from capture tree.
12735 --    SAL    - size of trees carried forward at each move.
12736 --    DUP    - # duplicate nodes within tree.
12737 --    REC    - # reclaimed positions from discarded trees.
12738 --    DUP_S  - # positions in duplicated subtree
12739 --    REC_S  - # positions that were in discarded subtree
12740 --    TOT_S  - counter keeping track of subtree size.
12741 --   ;
12742 --  
