function negamax(newBoard, player, depth, a, b, hash, restrictions, last_i, last_j) {
  ...
   if (checkwin(newBoard, last_i, last_j)) {
        return -2000000 + (MaximumDepth - depth) //Прибавляем текущую глубину, чтобы мотивировать алгоритм выигрывать более быстрым способом/проигрывать более медленным
    }
  ...
}

function checkwin(Board, x, y) {
    const Directions = get_directions(Board, x, y)
    for (let i = 0; i < 4; i++) { //Проверяем все 4 направления
        if (check_directions(Directions[i])) {
            return true
        }
    }
}

function get_directions(Board, x, y) { //Генерируем направления
    const Directions = [[], [], [], []];
    for (let i = -4; i < 5; i++) {
        if (x + i >= 0 && x + i <= Rows - 1) {
            Directions[0].push(Board[x + i][y])
            if (y + i >= 0 && y + i <= Columns - 1) {
                Directions[2].push(Board[x + i][y + i])
            }
        }
        if (y + i >= 0 && y + i <= Columns - 1) {
            Directions[1].push(Board[x][y + i])
            if (x - i >= 0 && x - i <= Rows - 1) {
                Directions[3].push(Board[x - i][y + i])
            }
        }
    }
    return Directions
}

function check_directions(arr) {
    for (let i = 0; i < arr.length - 4; i++) {
        if (arr[i] !== 0) {
            if (arr[i] === arr[i + 1] && arr[i] === arr[i + 2] && arr[i] === arr[i + 3] && arr[i] === arr[i + 4]) {
                return true
            }
        }
    }
}

function Table_init() {
  for (let i = 0; i < Rows; i++) {
    Table[i] = [];
    for (let j = 0; j < Columns; j++) {
      Table[i][j] = []
      Table[i][j][0] = random32(); //1
      Table[i][j][1] = random32(); //2
    }
  }

function hash(board) { //Хеширование всей доски с нуля
  let h = 0;
  let p;
  for (let i = 0; i < Rows; i++) {
    for (let j = 0; j < Columns; j++) {
      const Board_value = board[i][j];
      if (Board_value !== 0) { //игнорируем пустые клетки
        if (Board_value === -1) {
          p = 0  //игрок 0
        } else {
          p = 1 //игрок 1
        }
        h = h ^ Table[i][j][p];
      }
    }
  }
  return h;
}

function update_hash(hash, player, row, col) { //Обновляем хэш
    if (player === -1) {
        player = 0
    } else {
        player = 1
    }
    hash = hash ^ Table[row][col][player];
    return hash
}

function BoardGenerator(restrictions, Board, player) {
  const availSpots_score = []; //c is j  r is i;
  const min_r = restrictions[0];
  const min_c = restrictions[1];
  const max_r = restrictions[2];
  const max_c = restrictions[3];;
  for (let i = min_r - 2; i <= max_r + 2; i++) {
    for (let j = min_c - 2; j <= max_c + 2; j++) {
      if (Board[i][j] === 0 && !remoteCell(Board, i, j)) {
        const move = {}
        move.i = i;
        move.j = j;
        move.score = evaluate_move(Board, i, j, player) //С помощью функции оценки мы определяем насколько ход перспективен, присваиваем ему score.
        if (move.score === WIN_DETECTED) {
          return [move]
        }
        availSpots_score.push(move)
      }
    }
  }
  availSpots_score.sort(compare) //Затем сортируем ходы по score
  //  return availSpots_score.slice(0,10)
  return availSpots_score;
}

function evaluate_move(Board, x, y, player) {
  let score = 0;
  const Directions = get_directions(Board, x, y);
  let temp_score;
  for (let i = 0; i < 4; i++) {
    temp_score = evaluate_direction(Directions[i], player);
    if (temp_score === WIN_DETECTED) { //если данный ход выигрывает игру, сразу же возвращаем его
      return WIN_DETECTED
    } else {
      score += temp_score
    }
  }
  return score;
}

function evaluate_direction(direction_arr, player) {
  let score = 0;
  for (let i = 0; (i + 4) < direction_arr.length; i++) {
    let you = 0;
    let enemy = 0;
    for (let j = 0; j <= 4; j++) {
      if (direction_arr[i + j] === player) {
        you++
      } else if (direction_arr[i + j] === -player) {
        enemy++
      }
    }
    score += evalff(get_seq(you, enemy));
    if ((score >= 800000)) {
      return WIN_DETECTED;
    }
  }
  return score
}

function evalff(seq) {
    switch (seq) {
        case 0:
            return 7;
        case 1:
            return 35;
        case 2:
            return 800;
        case 3:
            return 15000;
        case 4:
            return 800000;
        case -1:
            return 15;
        case -2:
            return 400;
        case -3:
            return 1800;
        case -4:
            return 100000;
        case 17:
            return 0;
    }
}
function get_seq(y, e) {
    if (y + e === 0) {
        return 0;
    }
    if (y !== 0 && e === 0) {
        return y
    }
    if (y === 0 && e !== 0) {
        return -e
    }
    if (y !== 0 && e !== 0) {
        return 17
    }
}

function evaluate_state(Board, player, hash, restrictions) {
    const  black_score = eval_board(Board, -1, restrictions);
    const  white_score = eval_board(Board, 1, restrictions);
    let score = 0;
    if (player == -1) {
        score = (black_score - white_score);
    } else {
        score = (white_score - black_score);
    }
    StateCache.set(hash,score);
    StateCachePuts++;
    return score;
}

const LiveOne = 10;
const DeadOne = 1;
const LiveTwo = 100;
const DeadTwo = 10;
const LiveThree = 1000;
const DeadThree = 100;
const LiveFour = 10000;
const DeadFour = 1000;
const Five = 100000;

function MTDF(root : node_type; f : integer; d : integer) : integer;
      g := f;
      upperbound := +INFINITY;
      lowerbound := -INFINITY;
      repeat
            if g == lowerbound then beta := g + 1 else beta := g;
            g := AlphaBetaWithMemory(root, beta - 1, beta, d);
            if g < beta then upperbound := g else lowerbound := g;
      until lowerbound >= upperbound;
      return g;

//  return availSpots_score.slice(0,10)