Различные способы выигрыша шашек

…с виду несложная игра (шашки) представляет древнейшее и подлинно научное развлечение человеческого ума. Поистине она задает умственным способностям серьезнейшую работу! — Гюг Эган

Тактика в шашках для начинающих

Эта информация поможет новичкам в шашках научиться во время игры находить и проводить простые комбинации.

В предыдущих материалах сайта начинающие игроки могли узнать простые советы о том, как играть в шашки, чтобы выигрывать. Среди разнообразных приемов достижения победы в игре особое место занимает комбинация, с ее помощью можно добиться разных результатов: выиграть одну или несколько шашек соперника, пройти в дамки — все это поможет выиграть в шашки (или хотя бы не проиграть в трудной позиции).

О том, что такое комбинация и как важно уметь пользоваться в игре этим грозным оружием, Вы можете узнать, прочитав один из предыдущих выпусков, посвященных комбинации в шашках.

Для тех, кто только начинает учиться играть в шашки, найти комбинацию в игре поначалу кажется сложной задачей. Но, оказывается, если знать некоторые приемы и хитрости можно легко научиться проводить в игре тактические удары – простые комбинации. Самое главное для новичков – это помнить, что именно изучение комбинационных приемов (начиная с простейших) является одним из первых важных этапов освоения шашечной игры и способов достижения выигрыша.

В чем хитрости простейшей тактики в шашках? Начнем с того, что любая комбинация в шашках основана на правиле игры «бить обязательно». Именно поэтому у одного из игроков появляется возможность, отдавая свои шашки, управлять шашками соперника для достижения своих целей в игре. Но комбинация не получится, если жертвовать свои шашки бессмысленно. Для проведения простейшего тактического удара в шашках нужно научиться следующим хитростям:

• использование ударной группы шашек,
• использование ситуации, когда соперник нападает на Ваши шашки,
• вскрытие нужных полей.

Овладение этими приемами поможет провести простейшую комбинацию в шашках, далее рассмотрим указанные приемы на практике.

Для проведения комбинации используем ударные группы шашек

Одним из видов ударной группы шашек является колонна, колонну из шашек нетрудно заметить и построить во время игры.

В этой ситуации колонна из шашек позволяет белым быстро выиграть: 1.gf6 e:g5 2.ef4 g:e3 3.f:d8 x

Еще пример ударной группы шашек, при помощи которой белые проводят простой тактический удар: 1.ab6 a:c5 2.cd4 c:e3 3.d:f8 и выигрывают: 3… hg3 4.fc5 gh2 5.cg1 x

Ударная группа необязательно должно состоять из большого количества шашек, комбинационный удар могут осуществить даже две шашки: 1.dc5 b:d4 2.dc3 b:d2 3.c:g5 x

Вывод: важно уметь найти или построить ударную группу шашек, способную нанести комбинационный удар, идея такого удара будет зависеть от расположения шашек соперника.

И еще важный момент: искать возможности для проведения в игре тактического удара обязательно нужно и со стороны соперника. Вот простой пример:

Белые, увидев возможность прохода в дамки, поспешили ей воспользоваться, не оценив комбинационных возможностей соперника: 1.а5-b6? Но черные только этого и ждали: 1… dc5! 2.b:d4 hg5 3.h:f6 g:e1 x

Просто, не правда ли? Если для Вас это слишком просто, то не теряйте времени и приступайте к изучению более сложных комбинаций, о том, как подготовить и провести такие комбинации в шашках — в других материалах сайта, следите за новостями. Интерактивный тест со сложными комбинациями можно пройти здесь.

Нападение соперника на Ваши шашки – прекрасный повод для комбинации

Черные напали сразу на все шашки белых, и будь сейчас ход черных, они уничтожили бы соперника одним ударом. Но очередь хода за белыми и выигрывают именно они: 1.ba3 a:c5 2.b:h6 х

Вот пример немного сложнее:

Здесь белые, пользуясь тем, что следующий ход черных будет обязательным, успевают расположить свои шашки нужным образом и нанести победный удар:

1.cb2! h:d4 2.bc3 d:b2 3.a:c7 с выигрышем.

Еще один небольшой совет: прежде, чем проводить комбинацию в шашках не забудьте оценить, к чему это приведет. Не каждая комбинация позволит выиграть в шашки.

Следует отметить, что для рассмотренных выше случаев комбинационный дар был возможен благодаря тому, что шашки соперника были расположены так, что между ними были свободные поля для удара. Такое расположение шашек, называемое еще «решетчатым» или «дырявым», может служить хорошим признаком для возможного проведения комбинации.

Тактический удар можно осуществить путем вскрытия нужного игрового поля

Под вскрытием поля понимается принудительное удаление шашки соперника с определенного игрового поля (посредством жертвы своих шашек). На практике это выглядит так:

Если белые заметят, что отсутствие черной шашки d6 поможет им легко пройти в дамки и выиграть, то они без труда смогут осуществить свой замысел: 1.hg5 h:f4 2.g:e5 d:f4 3.b:b8 и дальнейшее сопротивление бесполезно, например : 3…fe3 4.cb4 hg7 5.ba7 x

Здесь очевидно, что белым нужно убрать черную шашку f6, но сделать это можно даже двумя способами. Хотя оба они выигрывают, но надо выбирать, конечно, вариант, который доставит меньше хлопот с реализацией преимущества.

1.ab4 [можно и 1.dc5 f:b6 2.h:d8 или 2.h:h8 и белые должны выиграть]

1…a:c3 2.d:b2 f:d4 3.h:h8 (или 3.h:d8 х) 3…de3 4.he5 ab6 5.bc3 ba5 6.cb2 x

Рассмотренные способы вскрытия нужных полей просты и очевидны, часто для осуществления комбинации со вскрытием приходиться приложить в игре гораздо больше усилий.

И опять о главном для новичков: начинающим игрокам необходимо как можно больше решать заданий с комбинациями, такие задания без труда можно найти, шашечной литературы на тему тактики в шашках достаточно много. Часть книг и журналов, позволяющих развивать комбинационное мышление, можно найти в разделе скачать.

Также для изучения тактических приемов рекомендуем интерактивные шашечные тесты, размещенные на нашем сайте, некоторые из которых посвящены только комбинациям в шашках. Тесты с самыми простыми заданиями для игры в русские шашки Вы найдете здесь: Комбинации-русские шашки-1 и Комбинации-русские шашки-2, а в международные шашки здесь: Комбинации-международные шашки.

В завершение предлагаем посмотреть небольшой видеоролик из которого Вы узнаете, какой эффект на соперника может произвести даже простая комбинация в шашках. Желаем удачных комбинаций, подписывайтесь на рассылку, чтобы не пропустить новую интересную информацию: комбинациям в шашках и советам для начинающих будет посвящен целый ряд выпусков.

Источник

Попытки открытия новой шашечной тактики или Что делать с несбыточной мечтой

Введение

Реализация алгоритма для решений комбинационных задач

Первая попытка была предпринята в конце 2-го курса. После качественного изучения языка Си, я считал, что не помешало бы изучить С++. После просмотра большого количества лекций по данному языку, я хотел взяться за какой-нибудь проект. И взялся за шашки. Более тонкая работа с переменными позволила более рационально тратить время на просчёт позиций. Если данные действия уподобить действиям с графами, то этот алгоритм можно было бы назвать поиском в ширину. Остановкой работы алгоритма являлось полное прохождение по графу.

Один объект описывал сложившуюся ситуацию на доске. В одном объекте хранилось:

Так как здесь был реализован алгоритм поиска в ширину, то данные можно было складировать в двусвязный лист, где pnr и ppr указатели реализующие эту коллекцию.

pdb — Указатель на расстановку доски.
action – данные о ходе совершённом родителем, для того, чтобы достичь эту позицию. Она выглядела как обычная запись ходов в шашках «c3–d4» при передвижении шашки или «c3:e5» при срубе. Переменная была необходима для более точной отладки сложившейся ситуации.
pp, pfc – указатели на родителя и на первую порождённую позицию. Т.к. алгоритм поиска был реализован в ширину, то все порождённые позиции в двусвязном списке располагались рядом, один за другим. Поэтому для того, чтобы сохранить данные в виде дерева достаточно хранить указатель на первого дитя, а все остальные последующие дети ссылались на одного и того же родителя. Данный алгоритм позволял извлекать родителю результаты детей, то есть анализировать текущую ситуацию, смотря лишь на то, к чему может привести тот или иной ход породивший ребёнка.
nmd – Число показывающее, сколько ходов осталось, до того, как партия будет считаться ничейной. Например, при ситуации 3-ёх дамок против 1-ой, на завершение партии выделяется лишь 15 ходов. При изменении количества шашек, а также после становления шашки дамкой данное число пересчитывается.
color – Чей сейчас ход.

Я очень боялся переполнения стека и считал, что передавать указатели в функции будет всё же лучше, поэтому решил избегать прямой передачи объекта в качестве параметра. Реализация была проста: берём элемент из очереди, рассматривает его, порождая последующие позиции, затем брали следующий элемент из очереди и так по кругу.

Результат:

Просмотрено: 61.133 позиций
Хранится записей в очереди: 264.050 позиций
Оперативная память (2 ГБ) закончилась лишь на таких данных. Такие результаты подходят лишь для коротких комбинационных задач.
Зато такой способ работы с шашечными позициями позволил тщательно отладить работу «ядра» программы.

Переход к «системе контроля версий»

В алгоритме очень много памяти уходило на сохранение данных о доске. Каждая позиция требовала выделить участок памяти. Тем более, как закодировать текущую шашечную расстановку лучше, я не придумал:

color – Цвет шашки. Чёрная, белая, либо пусто.
ptrCheckers – Если шашки на данном поле нет, то не выделяем память.
status – Дамка или шашка.
live – Жива ли шашка. Лишь для того, чтобы не срубить эту шашку повторно.

Понимаю, что вместо coordinate[8][8] можно было обойтись лишь coordinate[8][4], но понимание собственного кода бы весьма сильно пострадало.

В общем, очень много памяти требовалось на сохранение позиции, поэтому я решил возложить ответственность за идентификацию позиций шашек на action – запись о ходе родителя, в которой содержались данные типа «c3-d4».

Теперь, когда берём элемент из очереди, мы, начиная с самого начала. Берём исходную позицию шашек и от неё уже по обратному пути, выполняем ходы, привлёкшие к этому ребёнку. Так строилась расстановка шашек на доске для каждого элемента очереди.

Результат:

Просмотрено: 1.845.265 позиций
Хранится записей в очереди: 8.209.054 позиций

Отказ от «системы контроля версий»; переход к поиску в глубину

К сожалению, у поиска в ширину было как минимум несколько существенны проблем: Иногда он создавал одинаковые расстановки партий. А распознать, уже созданную партию, при большом количестве данных, было трудоёмко. Также не понятно было, что делать, когда нам не хватало памяти. Все хранящиеся данные были необходимы, чтобы восстановить идеологическую цепочку, так что при необходимости «черпнуть» откуда-нибудь памяти, её не оказывалось.

Поиск “в глубину” позволил перейти от задач локального характера (решений комбинационных задач) к глобальным (просчёт всей партии). Данный алгоритм рассматривает текущую расстановку шашек, порождая потомков, выбирает из них первого и назначает его на роль текущего. Если потомков нет, то указываем, что в данной позиции мы проиграли и переходим рассматривать следующую расстановку у родителя.

Также дабы не просчитывать повторные позиции при наличии дамок, было решено просматривать все позиции-родители. При наличии таковой я не рассматриваю её, а перехожу к следующей.

Было решено убирать из памяти правнуков у расстановки, у которой был известен результат. Тем самым можно было избежать её переполнения. Если же переполнения не произойдёт при поиске самого глубинного элемента.

Также было решено добавить новый способ хранения позиции – список из фигур:

При помощи него мы стали более быстро находить возможность сруба, а также перебирать шашки для проверки возможности хода. Теперь наш объект «позиция» хранившийся в очереди, имел такие поля:

Я никак не ожидал, что команда free не гарантирует 100% освобождения памяти. При отладке выяснилось, что после выполнения команды free память не освобождалась вовсе. Где-то в потёмках форумов я узнал, что free лишь подаёт инструкцию ОС об освобождении памяти, а уже ОС сама решает, освобождать ли память или нет. В общем, ОС у меня оказалась “жадной”, поэтому пришлось работать с памятью по-другому. Я выделял память по мере необходимости для удержания цепочки из первых «детей». А вместо удаления «первого» ребёнка, которого мы просмотрели, данные о нём перезаписывались данными о следующем ребёнке.

Для этого был разработан элемент отвечающий за динамическую работу с памятью:

Результат:

За 1 день непрерывной работы:
создано было 2.040.963 партии
просмотрено было 1.241.938 партии
Занимаемое место на оперативной памяти: 1.378 МБ

Работа с файлами

К сожалению, при таком выборе следующего элемента мы подолгу бы «подвисали» с одинаковыми позициями. Особенно при просчётах для дамок. Поэтому хотелось реализовать базу данных, где хранились бы результаты уже просмотренных позиций. Поэтому я решил хранить данные о каждой партии.

Уходя от проблемы с памятью, я снова с ней столкнулся. Так как оперативной памяти мне не хватало, я решил использовать внешний носитель. Все позиции я записывал в файл index.txt и queue.txt. В queue.txt у меня хранились данные о каждой партии. А в index.txt – идентификатор партии и расположение информации о этой партии в queue.txt, то есть смещение. Хотелось сжать данные, но оставить их в читабельном виде. Потому что я считал, что до финиша было всё равно далеко. Поэтому я сохранял данные в таком виде:

На доске игровая клетка может принимать 5 состояний: белая/чёрная шашка, белая/чёрная дамка, либо пусто. Значит, у двух клеток будет 25 состояний в различных комбинациях. Заметим, что в латинском алфавите 26 букв и он вполне подходит, для того, чтобы одной буквой описать состояние сразу 2-ух игровых клеток. Значит, что всю доску с 32-мя игровыми клетками можно описать 16-ю буквами латинского алфавита, которые имеют более-менее читабельный вид. Также необходимо сохранить, чей в данной позиции ход. Тогда, если первая буква будет заглавной, то ход сейчас чёрных. Также нам следует запомнить количество ходов от текущей расстановки, до принятия позиционной ничьи. А также и результат: W-win, L-lose, D-draw, U-unknown. И отлаживаться не стало сложней.

Результат:

За два часа программа потребовала лишь 4 MB оперативной памяти, но партий просчитала крайне мало. В queue.txt находилось 2918 записей и равен был 401 КB. Файл index.txt содержал 6095 записей и весил 232 KB. С такими темпами получится просчитать лишь 500 млн = 5*10^8 позиций и мой диск в 1TB сообщил, что памяти у него не достаточно. Да и произойдёт это весьма и весьма не скоро. Мои просчитанные позиции слабо скажутся на всю игру в целом.

Сжатие данных

Я смог придумать лишь 3 варианта продвижения проекта:

5^32 – различных расстановок фигур,
2*5^32 – учитывая, чей ход
2*(2*5^32) – максимальное количество занимаемого места

9,32 * 10^22 бит при условии, что достаточно будет у каждой расстановки указать результат равным в 2 бита.
Причём, в обычной партии имеется 5*10^20 различных позиций.
А значит, около 2*(2*5*10^20) = 2*10^21 бит будут информационными, а остальные

(9,12*10^21) будут обозначать, что такой расстановки шашек в данной партии не существует.

В распоряжении имеется 1TB = 8*10^12 бит
Необходимо разработать алгоритм сжатия для данной задачи, сохранив быструю индексацию данных.

В обычной партии имеется 5*10^20 различных позиций.
Для быстрой индексации сохраним у каждой позиции её «детей», а также результат. В среднем у позиции около Y потомков.

Закодируем «ссылки» на потомков в Х бит, а результат в 2 бита, а также разделитель между записями в Z. Получаем (Х*Y+2+Z) бит на каждую позицию. Итого (Х*Y+2+Z)*5*10^20 бит требуется выделить для хранения всех позиций, используемых в начальной расстановке.

В распоряжении имеется 1TB = 8*10^12 бит
Необходимо разработать алгоритм сжатия для данной задачи, сохранив быструю индексацию данных.

Попробуем найти повторяющиеся закономерности в записях и реализовать замену повторов на более короткие записи. Идейно алгоритм похож на код Хаффмана.

Отрицательно скажется на не столь быстрой индексации.

Итого нужно сжать данные c ≈10^22 до 10^13 бит. А значит, необходимо было написать алгоритм, который позволил бы сжимать данные всего лишь на 99.9999999914163%. Сомневаюсь, что какой-либо алгоритм на это способен, причём, не учитывая ещё, что необходимо сохранить быструю индексацию.

Результат:

Сохранение каких-либо данных обо всех партиях совсем не применимо.

Возврат к работе проекта только на оперативной памяти. Создание «процессора»

Было принято хранить данные, которые хранились в файлах, в оперативной памяти. Для этого было решено изменить структуру хранения данных:

А также изменён принцип хранения объекта Queue. После того, как перезаписывался MainQueue, перезаписывается и объект Queue, на который указывает MainQueue.

Поле «pcs» предназначенное для хранения «детей» теперь реализовано как односвязный список с данными типа «Aaaaaaeaaacaaaaa», расширяющийся по мере необходимости. Дабы использовать выделенную память повторно (при перезаписи) поля с данными становились равными ‘\0’ – нулю, для обозначения того, что поля не содержат важную информацию. Т.к. «объект» изменился.

Результат:

Максимальное занимаемое место на оперативной памяти: 844 КБ. Запуск на 7 часов позволил просмотреть 8.865.798.818 позиций. Но, позиции могут повторяться. Данные результаты являются недостаточным, для достижения полного просчёта партии за приемлемое время выполнения.

Теперь можно сказать, что есть «процессор», который будет перемалывать позиции и ему потребуется лишь 844 КБ оперативной памяти, а значит, оставшуюся память можно потратить с пользой, например, реализовать «cache-память», дабы не просчитывать позиций, которые уже просчитаны.

Создание «cache-памяти»

Для наиболее быстрой выборки данных из памяти была выбрана hash-таблица, заполоняющая максимально-возможное пространство в оперативной памяти. В качестве hash-функции были выбраны последние числа алгоритма md5, на вход которой подавалась закодированное описанное позиции. То есть позиция «Aaauaueaaacckaaa» с md5 0237d0d0b76bcb8872ecc05a455e5dcf будет хранится по адресу: f * 2^12 + c * 2^8 + d * 2^4 + 5 = 15*4096 + 12*256 + 13*16 + 5 = 64725.

Единицей хранения записи в hash-таблице была ячейка. Данный подход позволяет удалять данные из «устаревших» ячеек и использовать их пространство повторно. «Устаревание» реализовано при помощи кольцевого буфера:

По первому адресу в cache-памяти хранятся ячейки №1 и №5, во второй №3… А в кольцевом буфере ячейки хранятся в хронологическом порядке. Если бы максимум мы могли хранить 5 ячеек, то ячейку с №1 «выдернули» из того места, где находится сейчас и поместили бы на место 6-ой ячейки. Причём, теперь в cache-памяти по первому адресу будет храниться только ячейка №5.

Поле condition необходимо для идентификации искомой расстановки шашек, потому что различные расстановки могут храниться по одному и тому же адресу cache-памяти.

Поле draw необходимо для выявления совпадения запроса. Если в памяти хранится ничейный результат позиции, для которой было выделено лишь 3 хода, то при наличии большего количества ходов можно как добиться выигрыша, так и успеть проиграть.

Результат:

Запуск на 1 час позволил просмотреть 10.400.590 позиций. Необходимо реализовать что-то, позволяющее ускорять данный просчёт. Но, если производить расчёты, то мой компьютер, в лучшем случае, будет вычислять 10^20 позиций в течении: 10^20 / 10.400.590 = 9,6 * 10^12 часов = 4*10^11 дней.

Посмотрим, какой кусок кода является «узким горлышком». Для этой цели я использовал профилировщик OProfile:

Проверка различности элементов очереди. Вызывается при добавлении нового элемента в очередь для проверки троекратного повторения позиции. Проверка производится со всеми элементами, которые привели к текущей позиции.

Оптимизация: При изменении количества шашек на доске или их статуса, отметить. Для того чтобы с позициями, которые имеют другой набор фигур, не производить проверку.

Используется для преобразования элемента шашечной позиции в букву. Необходим для функции Board_to_String(Map*, char*, chcolor).

Оптимизация: Для начала уменьшить количество вызова функции Board_to_String(Map*, char*, chcolor)

Вызываются достаточно часто. А значит необходимо уменьшить количество обращений к ним.
String_to_Lcheckers необходим для преобразования текста в коллекцию из данных о шашках.
Board_to_String необходим для перевода позиции в текст, который можно хранить в ОП.

Оптимизация: Так как для представления одной и той же позиции на доске мне необходимо работать с тремя структурами данных:

Lcheckers – список шашек на поле. Необходим для быстрого выбора шашки для просмотра возможности хода. Map или “Board” – массив [8][8]. Содержит в себе полную расстановку сил.
stringMap или “String” – строка для хранения данных. Значит необходимо уменьшить количество конвертаций из одного представления данных, в другой или попытаться уменьшить количество структур данных.

Магические bitBoard’ы

Неожиданно для себя я нашёл решение на habrahabr: Магические битборды и русские шашки. В котором автор статьи предлагает закодировать информацию о доске при помощи 4-ёх 32-битных слов.

1) позиции всех фигур белого цвета
2) позиции всех фигур черного цвета
3) позиции шашек белого цвета
4) позиции шашек чёрного цвета

Причём позиции фигур нумеруются следующим образом:

Теперь для выяснения возможности сруба хотя бы одной шашкой достаточно позиции всех шашек передвинуть в соответствующем направлении:

Тем самым ускоряется поиск возможности, как сруба, так и простого хода. К своему большому сожалению, я так и не понял автора данной статьи, как он решил работать с дамкой. У меня на данный момент стоит не красивый for, который, конечно, в дальнейшем нужно исправить.

Тем самым можно заменить 3 структуры данных, описанных выше на одну:

Также, это изменение позволило не использовать md5 для нахождения номера в hash-таблице. Эта миссия была поручена данной формуле:

Где ReverseBits – это разворот бит. Пример: было число 0x80E0, стало 0x0701.

Результат:

Считаю, что алгоритм проекта реализован. Поэтому, можно сделать упор на ускорении работы функций.

Ускорение работы функций

Начитавшись о likely/unlikely я решил проверить его «ускорение» кода. В общем говоря, likely/unlikely указывает какие инструкции следует загружать процессору во время выполнения оператора if. Либо те, которые находятся после then, либо после else. При неудачном выборе инструкций, например then, процессор простаивает, ожидая инструкций, указанных после else. Под компилятор от МS такая инструкция называется __assume.

Реализовав каждый if этим способом, я решил затестить:

Результат:

К своему большому удивлению, код ускорился действительно на много. За первый час было просчитано 16.750.000 позиций.

Реализовывать ассемблерные вставки я не решился. Код у меня становится сразу нечитаемым, а это является для меня важным аспектом. Так как перерывы в проекте у меня иногда достигали несколько месяцев.

Ограничитель количества просчитанных ходов в глубь

К сожалению, это можно назвать так: со временем, я действительно осознал, что просчитать все позиции пока невозможно. Поэтому я добавил ограничитель ходов с результирующей функцией:
шашка = +1 балл, дамка = +3 балла. Я осознаю, что такой подход не совсем верен, но в большинстве своём он будет выдавать валидные значения. Поэтому я решил остановиться на этом.

Результат:

Я вернулся к тому, с чего начал. С ограничителем количества просчитанных ходов моя программа на данный момент является программой для решений комбинационных задач. Но это не страшно, ограничитель можно отдалить.

Общий результат:

За первый час просчитывается ≈17 млн. позиций.
Что делать дальше? Непонятно. Можно использовать CUDA, распараллелить вычисления… Но не думаю, что с помощью этого можно добиться просчёта хотя бы 50 ходов для каждого игрока на одном компьютере. Знать бы ещё сколько позиций перебрать придётся…

Нужно менять алгоритм… Как? Идей нет… Может использовать разрекламированные нейронные сети? Не думаю, что нейронная сеть оценит по достоинству потерю шашки в начале партии.

Пока что подожду грядущее время появление/удешевления более быстрых компьютеров. Авось, тогда уже появятся более продвинутые технологии в ускорении кода. А я пока пойду изучать нейронные сети, возможно я не прав и они будут во главе вычислительного алгоритма… Поживём-посмотрим.

Немного данных:
Максимальная глубина просчёта — Количество просматриваемых позиций
1 — 7
2 — 56 (Совершаем первый ход белых. После чего порождаем 7 новых позиций для чёрных. Смотрим каждую из них, удостоверяемся, что дальше просчитывать не нужно. Делаем второй ход белых… 7+7*7)
3 — 267
4 — 1017
5 — 3570
6 — 11 460
7 — 34 455
8 — 95 921
9 — 265 026
10 — 699 718
11 — 1 793 576
12 — 4 352 835
13 — 10 571 175

Источник