* @return number of moves played from the beginning of the game. */

* Build a symetric base 3 key. Two symetric positions will have the same key. * * This key is a base 3 representation of the sequence of played mo

* Plays a possible move given by its bitmap representation * * @param move: a possible move given by its bitmap representation * only

* Store a value for a given key * @param key: must be less than key_size bits. * @param value: must be less than value_size bits. null (0) value

* Indicates whether a column is playable. * @param col: 0-based index of column to play * @return true if the column is playable, false if the c

* return true if current player can win next move */

* Indicates whether the current player wins by playing a given column. * This function should never be called on a non-playable column. * @param

* util functions to compute next prime at compile time */

* Plays a playable column. * This function should not be called on a non-playable column or a column making an alignment. * * @param col: 0-b

* Add a move in the container with its score. * You cannot add more than Position::WIDTH moves */

* Explore and print all possible position under a given depth. * symetric positions are printed only once. */

* Read scored positions from stdin and store them in an opening book * * Input lines must be a valid position (possibly empty string), a space and a

* Get next move * @return next remaining move with max score and remove it from the container. * If no more move is available return 0 */

* tells if an integer n has a a divisor between min (inclusive) and max (exclusive) */

* @return a compact representation of a position on WIDTH*(HEIGHT+1) bits. */

Empty opening book * Opening book file format: * - 1 byte: board width * - 1 byte: board height * - 1 byte: max stored position depth

log2(1) = 0; log2(2) = 1; log2(3) = 1; log2(4) = 2; log2(8) = 3

* Score a possible move. * * @param move, a possible move given in a bitmap format. * * The score we are using is the number of winning sp

return next prime number greater or equal to n. n must be >= 2

* Return a bitmap of all the possible next moves the do not lose in one turn. * A losing move is a move leaving the possibility for the opponent to

* Build an empty container */

* Default constructor, build an empty position. */

Constructor

return a bitmask containg a single 1 corresponding to the bottom cell of a given column

return a bitmask 1 on all the cells of a given column

* @parmam position, a bitmap of the player to evaluate the winning pos * @param mask, a mask of the already played spots * * @return a bitmap

* Get the value of a key * @param key: must be less than key_size bits. * @return value_size bits value associated with the key if present, 0 ot

* If used with a max depth parameter: generate all uniquepsoition upto max depth * If no parameter: read scoredposition from standard input to store

* Main function. * Reads Connect 4 positions, line by line, from standard input * and writes one line per position to standard output containing: *

* Reccursively score connect 4 position using negamax variant of alpha-beta algorithm. * @param: position to evaluate, this function assumes nobody a

* Return a bitmask of the possible winning positions for the opponent */

* Compute a partial base 3 key for a given column */

* counts number of bit set to one in a 64bits integer */

* Bitmap of the next possible valid moves for the current player * Including losing moves. */

* reset (empty) the container */

* Empty the Transition Table. */

return a bitmask containg a single 1 corresponding to the top cel of a given column

* Return a bitmask of the possible winning positions for the current player */