Тест миллера рабина python

Тест миллера рабина python

def miller_rabin ( n , k = 10 ):
if n == 2 :
return True
if not n & 1 :
return False
def check ( a , s , d , n ):
x = pow ( a , d , n )
if x == 1 :
return True
for i in xrange ( s — 1 ):
if x == n — 1 :
return True
x = pow ( x , 2 , n )
return x == n — 1
s = 0
d = n — 1
while d % 2 == 0 :
d >>= 1
s += 1
for i in xrange ( k ):
a = randrange ( 2 , n — 1 )
if not check ( a , s , d , n ):
return False
return True
# benchmark of 10000 iterations of miller_rabin(100**10-1); Which is not prime.
# 10000 calls, 11111 per second.
# 74800 function calls in 0.902 seconds

This comment has been minimized.

Copy link Quote reply

deckar01 commented Sep 22, 2017

This comment has been minimized.

Copy link Quote reply

MaLiN2223 commented Apr 14, 2018

It is important to notice that this is non deterministic version

This comment has been minimized.

Copy link Quote reply

AaronM04 commented Aug 17, 2018

Lines 2-3 should be:

This avoids the exception due to randrange(2, 2)

This comment has been minimized.

Copy link Quote reply

phoenix2021 commented Mar 12, 2019

  • © 2020 GitHub, Inc.
  • Terms
  • Privacy
  • Security
  • Status
  • Help

You can’t perform that action at this time.

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.

Блог про алгоритмы и все что с ними связано. Основной инструмент реализации — Python.

среда, 13 апреля 2011 г.

Тест простоты

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

*-Нравится статья? Кликни по рекламе! 🙂

Мы уже разобрали методы выбора всех простых чисел, до определенного, в статье Простые числа. Пришло время рассмотреть ряд алгоритмов, под общим названием — "Тесты простоты":

Обычно перебор делителей заключается в переборе всех целых (как вариант: простых) чисел от 2 до квадратного корня из факторизуемого числа n и в вычислении остатка от деления n на каждое из этих чисел. Если остаток от деления на некоторое число m равен нулю, то m является делителем n. В этом случае либо n объявляется составным, и алгоритм заканчивает работу (если тестируется простота n), либо n сокращается на m и процедура повторяется (если осуществляется факторизация n). По достижении квадратного корня из n и невозможности сократить n ни на одно из меньших чисел, n объявляется простым.
Примечание: если у n есть некоторый делитель p, то n/p так же будет делителем, причем одно из этих чисел не превосходит .

Реализация на Python:

2.) Теорема Вильсона
Теорема теории чисел, которая утверждает, что

p — простое число тогда и только тогда, когда (p − 1)! + 1 делится на p

Практическое использование теоремы Вильсона для определения простоты числа нецелесообразно из-за сложности вычисления факториала. Таким образом, время выполнения данного алгоритма = поиску факториала. Алгоритм поиска факториала мы уже рассматривали.
Реализация:

3.) Тест простоты Ферма

Простое число удовлетворяет тесту Ферма. Составной объект может пройти тест Ферма с вероятностью . Сложность разрядной операции испытания Ферма равна сложности алгоритма, который вычисляет возведение в степень.Поскольку вычисление (mod N) довольно быстрая операция, у нас возникает быстрый тест, проверяющий, является ли данное число составным. Его называют тестом Ферма по основанию а. Заметим, что тест Ферма может лишь убедить нас в том, что число N имеет делители, но не в состоянии доказать его простоту. Действительно, рассмотрим составное число N = 11 · 13 = 341, а основание в тесте Ферма выберем равным 2. Тогда = 1 mod 341, в то время как число 341 не простое. В этом случае говорят, что N — псевдопростое число (в смысле Ферма) по основанию 2. Существует бесконечно много псевдопростых чисел по фиксированному основанию, хотя они встречаются реже, чем простые. Можно показать, что для составного N вероятность неравенства
≠ 1 (mod N).
больше 1/2. Подводя итог сказанному, выпишем алгоритм теста Ферма.
Если на выходе этого алгоритма напечатано «составное, а», то мы с определенностью можем заявить, что число n не является простым, и что а свидетельствует об этом факте, т. е. чтобы убедиться в истинности высказывания, нам достаточно провести тест Ферма по основанию а. Такое а называют свидетелем того, что n составное.
Если же в результате работы теста мы получим сообщение: «правдоподобно простое», то можно заключить: n — составное с вероятностью ≤ существуют составные числа, относительно которых тест Ферма выдаст ответ правдоподобно простое, для всех взаимно простых с n оснований а. Такие числа называются числами Кармайкла. К сожалению, их бесконечно много. Первые из них — это 561, 1105 и 1729. Числа Кармайкла обладают следующими свойствами:

  • они нечетны,
  • имеют по крайней мере три простых делителя,
  • свободны от квадратов1,
  • если р делит число Кармайкла N, то р — 1 делит N — 1.

Чтобы получить представление об их распределении, посмотрим на числа, не превосходящие . Среди них окажется примерно 2, 7 • простых чисел, но только 246 683 ≈ 2,4 • чисел Кармайкла. Следовательно, они встречаются не очень часто, но и не настолько редко, чтобы их можно было игнорировать.

4.)Тест Миллера — Рабина

Вероятностный полиномиальный тест простоты. Тест Миллера — Рабина позволяет эффективно определять, является ли данное число составным. Однако, с его помощью нельзя строго доказать простоту числа. Тем не менее тест Миллера — Рабина часто используется в криптографии для получения больших случайных простых чисел.
Алгоритм был разработан Гари Миллером в 1976 году и модифицирован Майклом Рабином в 1980 году.

В этом листке мы будем работать с большими целыми числами. Оказывается, что проверить простоту числа можно очень быстро (правда существует почти нулевая вероятность ошибки), а вот разложить число на простые множители сложно. Не в полной мере разбираясь, как и почему оно работает, мы реализуем достаточно быстрые алгоритмы проверки простоты (меньше 1с для чисел из 400 цифр), а также достаточно быстрый алгоритм факторизации (разложения на множители), работающий за время порядка $sqrt[4]$ (даже быстрее: за время порядка $sqrt

Читайте также:  Как сохранить текст с компьютера на флешку

$, где $p$ — максимальный простой делитель числа).

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

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

A: Тест Ферма

Вам уже известна малая теорема Ферма: если число (n) — простое, то для любого числа (1 le a le (n — 1)) выполнено сравнение (a^ equiv 1pmod). Отсюда следует, что если мы найдём такое (a), что это сравнение не выполнено, то число (n) заведомо не простое. Такая проверка простоты числа называется тестом Ферма.

Даны два натуральных числа: a и n . Напишите функцию fermat_test(a, n) , возвращающую True если число (a) проходит тест Ферма для (n), и False иначе.

Для ускорения работы с большими числами в Python существует возможность возводить в степень по модулю некоторого числа: функция pow(a, k, n) вычислит (a^k mod).

B: Тест Ферма —2

Дано число N . Выведите в первой строке слово «Prime», если число N простое, и «Composite» иначе. Выведите во второй строке количество чисел от 1 до (N-1), проходящих тест Ферма.

C: Качество теста Ферма

Очевидно, что если число (n) — простое, то любое число (a) пройдёт тест Ферма. Докажите, что если число (n) — составное, то все числа не взаимно простые с (n) тест не пройдут. Кроме того докажите, что если хотя бы одно из чисел, взаимно простых с (n) не пройдёт тест Ферма, то хотя бы половина чисел, взаимно простых с (n) его не пройдут. Таким образом, если число (n) составное, а число (a) случайное из диапазона от (2) до (n-1), то с вероятностью (dfrac12) оно не пройдёт тест Ферма. Однако это утверждение не совсем верно, см. задачу D.

D: Числа Кармайкла

Числом Кармайкла называется всякое составное число (n), которое удовлетворяет сравнению (b^equiv 1pmod) для всех целых (b), взаимно простых с (n). В 1994 году доказали, что чисел Кармайкла бесконечно много, более того, при (ngg0) среди чисел от 1 до (n) по крайне мере (n^<2/7>) кармайкловых чисел. Из-за этого тест Ферма работает не идеально, хотя вероятность встретить число Кармайкла с ростом (n) стремится к нулю.

Даны числа a, b . Выведите все числа Кармайкла на отрезке [a, b] (или пустую строчку, если их нет).

E: Числа Кармайкла и невероятные совпадения

Напишите программу, которая вычисляет два числа: наименьшее число, представимое в виде суммы двух квадратов четырьмя способами; наименьшее число, представимое в виде суммы двух кубов двумя способами;

F: Тест простоты Ферма

Тест простоты, основанный на тесте Ферма, заключается в следующем. Пусть мы хотим проверить простоту числа (n). Зафиксируем для себя натуральное число (m), выберем (m) случайных чисел от (2) до (n-1), и для каждого проведём тест Ферма из задачи A. Если хотя бы одно число не прошло тест, то число (n) заведомо составное. Если же все тесты пройдены, то либо число (n) — число Кармайкла, либо с вероятностью по крайней мере (frac<1><2^m>) является простым. Среди чисел от 1 до 1000000000 существует 50847534 простых чисел и всего 646 чисел Кармайкла. То есть вероятность наткнуться на число Кармайкла всего (646/50847534 approx 1.27 cdot 10^ <-5>approx 1/100000). При выборе (m=20) вероятность того, что составное число, не являющееся числом Кармайкла, пройдёт тест, будет равна (frac<1><2^<20>>approx 1/1000000).

Напишите функцию fermat_primality_test(n) , проверяющую простоту числа при помощи 20 раундов теста Ферма. Функция должна возвращать False , если число (n) составное, и True , если число (n) скорее всего простое. Число (n) может содержать до 400 десятичных знаков.

Для того, чтобы выбрать случайные числа из диапазона, используйте функцию randint(a, b) из модуля random , возвращающую случайное число из отрезка ([a,b]).

FT: Доказательство теста Ферма

Пусть число $n$ — составное, а число $1

G: Свидетели простоты в тесте Миллера — Рабина

Тест Миллера — Рабина является усовершенствованием теста Ферма. Числа Кармайкла не проходят тест Миллера — Рабина, поэтому он является универсальным.

Пусть (n) — некоторое нечётное простое число. Представим число (n-1) в виде (n-1 = 2^s cdot u), где (s) натуральное, а (u) — нечётное. Возьмём любое число (a) от (2) до (n-1). Тогда из малой теоремы Ферма следует, что (a^ = a^ <2^s u>equiv 1pmod ). Кроме того, по простому модулю (n) существуют ровно два квадратных корня из единицы: (1) и (-1). Поэтому число (a^ <2^u>), являясь квадратным корнем из единицы, равно либо (1), либо (-1). Если (a^ <2^u>equiv 1pmod), то мы снова можем извлечь корень. Мы можем продолжать это действие до тех пор, пока либо не закончится (s), либо очередной корень не будет равен (-1).

Число (a) называется свидетелем простоты числа (n), если либо (a^equiv 1pmod), либо в последовательности (a^, a^<2^1 u>, ldots, a^ <2^u>) встречается (-1) по модулю (n). Ясно, что если некоторое число (a) не является свидетелем простоты, то число (n) заведомо составное. Оказывается, что для составного числа (n) не более ((n-1)/4) чисел от (1) до (n-1) являются свидетелями простоты (n).

Читайте также:  Пропали листы в эксель 2007

Даны два натуральных числа: a и n . Напишите функцию miller_rabin_test(a, n) , возвращающую True если число (a) является свидетелем простоты для (n), и False иначе.

H: Количество свидетелей простоты

Дано число N . Выведите в первой строке слово «Prime», если число N простое, и «Composite» иначе. Выведите во второй строке количество чисел от 2 до (N-2), являющихся свидетелями простоты числа N .

I: Тест простоты Миллера — Рабина

Пусть мы хотим проверить простоту нечётного числа (n). Зафиксируем для себя натуральное число (m), выберем (m) случайных чисел от (2) до (n-1). Если хотя бы одно из чисел не является свидетелем простоты, то число (n) заведомо составное. Иначе число (n) с вероятностью по крайней мере (frac<1><4^m>) является простым.

Напишите функцию miller_rabin_primality_test(n) , реализующую эту идею. В качестве числа (m) используйте битовую длину числа (n) ( n.bit_length() ) (какова вероятность того, что проверив все k-битовые числа, мы хоть раз ошибёмся?). Функция должна возвращать False , если число (n) составное, и True , если число (n) скорее всего простое. Число (n) может содержать до 400 десятичных знаков.

J: Ближайшее простое число

Профилирование программы в Python

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

Нет нужны помнить всю эту конструкцию, достаточно помнить ключевое слово cProfile .

Построчное профилирование программы в Python

Также возможно построчное профилирование. Однако для его использования потребуется установить библиотеку line_profiler . Это может оказаться не так просто. Скорее всего команда pip install line_profiler —user потерпит неудачу из-за отсутсвия компилятора языка C. Поэтому можно сразу отправиться на страницу собранных для windows пакетов и скачать оттуда подходящий whl -файл (в имени line_profiler‑2.1.2‑cp36‑cp36m‑win_amd64.whl 36 — это версия питона 3.6, win32/win_amd64 — это битность ОС). Дальше для установки пакета нужно будет из anaconda prompt выполнить команду вида pip install "Y:path owhlline_profiler‑2.1.2‑cp36‑cp36m‑win_amd64.whl" —user , и дело в шляпе!

Наконец-таки, если библиотека установлена, то воспользоваться ей можно так:

На выходе будет вот такой отчёт:

Здесь видно, что 90.0% времени уходит на строчку res = glue(res, str(i)) , которая вызывается 50000 раз. Внутри функции glue 93.6% времени уходит на склейку строк. И действительно, так строки клеить нельзя: это приводит к квадратичному времени работы. Склейка при помощи join работает в 20 раз быстрее.

K: Случайные простые числа

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

  1. При помощи решета Эратосфена получаем список простых чисел от 2 до 65537;
  2. Берём случайное число от (2^) до (2^k — 1);
  3. Если оно делится на одно из простых от 2 до 65537, то переходим к пункту 2;
  4. Иначе проводим k тестов Миллера — Рабина;
  5. Если число не прошло хотя бы один тест, то переходим к пункту 2, иначе принимаем данное случайное число как простое;
  6. Повторяем пункты 2-5 до тех пор, пока не накопится необходимое количество простых чисел.

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

Теорема Рабина

Пусть (n) — натуральное число, большее 3. Представим число (n-1) в виде (n-1 = 2^s cdot u), где (s) натуральное, а (u) — нечётное. Число (a) называется свидетелем простоты числа (n), если либо (a^equiv 1pmod), либо в последовательности (a^, a^<2^1 u>, ldots, a^ <2^u>) встречается (-1) по модулю (n).

Теорема Рабина гласит, что у составного числа (n>4) — не более ((n-1)/4) свидетелей простоты.

Это непростая теорема, однако отдельные её части не такие уж и сложные.

В задачах будет использоваться функция Эйлера — $varphi(n)$ — равна количеству натуральных чисел, меньших $n$ и взаимно простых с ним.

L1: Теорема Рабина — 1

Пусть $n=2^k$ и $k>2$. Докажите, что только 1 проходит тест Ферма, а значит является единственным является свидетелем простоты.

L2: Теорема Рабина — 2

Пусть $n$ — чётное, но не степень двойки. Докажите, что не более $(n/2-1)/2$ чисел являются свидетелями простоты.

Первообразные корни

Пусть $n=p^k$ — степень нечётного простого числа. Тогда, во-первых, существует в точности $varphi(n)=p^(p-1)$ остатков $a$ (по модулю $n$) взаимно простых с $n$; А во-вторых, существует такой остаток $g$ (он называется первообразным корнем), что любой остаток $a$, взаимнопростой с $n$, является его степенью.
Например, если $n=5$, то $varphi(n)=4$, $g=2$: $2^0=1$, $2^1=2$, $2^2=4$, $2^3=3$.
Если $n=3^2=9$, то $varphi(n)=6$, $g=2$: $2^0=1$, $2^1=2$, $2^2=4$, $2^3=8$, $2^4=7$, $2^5=5$.
Если $n=17$, то $varphi(n)=16$, $g=3$: $3^0=1$, $3^1=3$, $3^2=9$, $3^3=10$, $3^4=13$, $3^5=5$, $3^6=15$, $3^7=11$, $3^8=16$, $3^9=14$, $3^<10>=8$, $3^<11>=7$, $3^<12>=4$, $3^<13>=12$, $3^<14>=2$, $3^<15>=6$.
Если $n=5^2$, то $varphi(n)=20$, $g=2$: $2^0=1$, $2^1=2$, $2^2=4$, $2^3=8$, $2^4=16$, $2^5=7$, $2^6=14$, $2^7=3$, $2^8=6$, $2^9=12$, $2^<10>=24$, $2^<11>=23$, $2^<12>=21$, $2^<13>=17$, $2^<14>=9$, $2^<15>=18$, $2^<16>=11$, $2^<17>=22$, $2^<18>=19$, $2^<19>=13$.

L3: Теорема Рабина — 3

Пусть $n = p^k$, где $p$ — простое. Докажите, что тест Ферма пройдут ровно $p-1$ число, следовательно не более $p-1$ чисел являются свидетелями простоты.

L4★: Теорема Рабина — 4

Пусть $n$ — нечётное и имеет по крайней мере три различных простых делителя. Докажите, что не более $varphi(n)/4$ чисел являются свидетелями простоты.

L5★: Теорема Рабина — 5

Пусть $n = p^m cdot q^l$, где $p$ и $q$ — простые. Докажите, что не более $varphi(n)/2$ чисел проходят тест Ферма, и что не более половины из них являются свидетелями простоты.

M: Числа Мерсенна

Числа Мерсенна — это числа вида (M_n = 2^n — 1), где n — натуральное число. Докажите, что если число Мерсенна (M_n) является простым, то и число (n) также является простым.

Читайте также:  Преимущества смарт тв перед обычным тв

N: Тест Люка — Лемера

Оказывается, что для проверки простоты чисел Мерсенна существуют крайне эффективный алгоритм. Он называется тестом простоты Люка — Лемера, благодаря которому простые числа Мерсенна давно удерживают лидерство как самые большие известные простые числа. На январь 2015 года самым большим известным человечеству простым числом является число (M_<57885161>), в котором 17425170 десятичных знаков. Это простое число было обнаружено 25 января 2013 и удерживает первое место уже почти два года.

Разберитесь с алгоритмом по страничке в Википедии. Напишите программу, которая по числу k вычисляет k-е простое число Мерсенна. Гарантируется, что это число не превосходит (M_<3000>).

O: ρ-aлгоритм Полларда для поиска делителей

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

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

Пусть (n) — нечётное составное число, а (p) — его наименьший простой делитель.

Наивный алгоритм потребует порядка (p) операций для его нахождения. Пусть, например, число (n) содержит 30 десятичных цифр и является произведением двух больших простых чисел (по 15 знаков в каждом). Наивному алгоритму потребуется порядка (10^<15>) операций. Если выполнять по (10^9) операций в секунду, то на поиск делителя уйдёт порядка 11 дней. Не слишком шустро. Оказывается можно найти делитель за время порядка (sqrt

) (правда не обязательно наименьший). Если в нашем примере (10^9) операций в секунду заменить на более реальные (10^6) операций в секунду для Python, то потребуется порядка 30 секунд.

Основная идея алгоритма прячется за идеей парадокса дней рождения: если в группе хотя бы 23 человека, то с вероятностью хотя бы 50% у двух из них совпадают дни рождения. Никакого парадокса в этом утверждении нет, однако утверждение может показаться неочевидным, так как вероятность совпадения дней рождения двух человек в любой день года (1/365 = 0,27%), помноженная на число человек в группе из 23, даёт лишь 23/365 = 6,3%. Весь секрет в том, что для совпадения дней рождения необходимо совпадения хотя бы в одной из пар чисел, а их не 23, а (23cdot 22 / 2 = 253). А для 50% вероятности совпадения только номера дня в месяце достаточно всего 7 человек.

Теперь ближе к алгоритму: рассмотрим последовательность случайных чисел (x_1, x_2, ldots, x_k). Будем смотреть на неё как на последовательность чисел по модулю (n), и как на последовательность чисел по модулю (p) (пока нам неизвестному). Очевидно, что вероятность того, что два числа совпадут по модулю (p) больше, чем вероятность совпадения по модулю (n). Пусть числа (x_i) и (x_j) совпали по модулю (p), но не по модулю (n). Тогда ((x_i — x_j),vdots, p) и НОД ((x_i — x_j, n)) делится на (p), но не совпадает с (n), то есть мы нашли делитель числа (n).

Однако пока эта идея в реальности работает плохо, так как нужно слишком часто считать НОД (порядка квадрата количества случайных чисел). Для дальнейшей оптимизации требуется идея, от которой алгоритм и получил имя «ρ-алгоритм». Рассмотрим какую-нибудь функцию (F(x)) такую, что её во-первых можно легко вычислять, во-вторых, для любого числа (p) если (xequiv ypmod

), то (F(x)equiv F(y)pmod

), в-третьих, последовательность чисел (F(F(ldots F(x)ldots))) выглядит достаточно случайной, и наконец (F(x)) не взаимно однозначна. Джон Поллард использовал (F(x) = (x^2 — 1)pmod), однако сейчас принято использовать (F(x) = (x^2 + 1)pmod). Выберем в качестве (x_1) какое-нибудь случайное число, и будем далее строить последовательность по правилу (x_k = F(x_)). Пусть на каком-то очередном шаге после добавления числа (x_l) возникло совпадение остатка по модулю (p) с более ранним числом (x_s). Тогда для любого натурального (t) имеем (x_ equiv x_pmod

). Если нарисовать картинку, то получится как раз греческая буква «ро»: сначала какой-то уникальный префикс, а затем остатки будут повторяться с периодом $l-s$.

Теперь воспользуемся трюком от Роберта Флойда для экономного поиска этого самого цикла из буквы «ро». Для этого заметим, что найдется такое число (w), не превосходящее (l), что (x_wequiv x_<2w>pmod

) (покажите это, явно указав такое (w)). Поэтому мы можем взять две равных переменных, к первой последовательно применять (F(x)), а ко второй — (F(F(x))), до тех пор, пока не возникнет совпадения по модулю какого-нибудь делителя (которое мы обнаружим НОД’ом), либо по модулю самого числа (n), если не повезло. Отсюда уже следует наш алгоритм:

  1. В качестве x берём случайное число, берём y=x ;
  2. Заменяем x на F(x) , а y — на F(F(y)) (таким образом, если (x=x_i), то (y=x_<2i>));
  3. Вычисляем d = НОД(x — y, n) ;
  4. Если d = 1 , то переходим к шагу 2, если d = n , то переходим к шагу 1, иначе возвращаем d .

Пример работы алгоритма при факторизации числа 11021:

Делитель 107 числа 11021 найден всего за 7 шагов. Вот пример с факторизацией числа 112313779:

Реализуйте ρ-aлгоритм Полларда для поиска делителей числа в виде функции pollards_rho_divisor(n) , принимающей на вход составное число и возвращающей любой его нетривиальный делитель.

В алгоритме выше есть неточность. В некоторых случаях функция (F(x) = (x^2 + 1)pmod) не позволяет найти делитель ни при каком начальном числе. Найдите несколько таких (n), что в них общего? При первом зацикливании рекомендуется заменить 1 на какое-нибудь другое желательно небольшое по модулю число, но не 0, и не 2.

Ссылка на основную публикацию
Тарифы мтс смарт 400 руб
С того момента как тариф «Смарт» стал доступен для активации, он претерпел множество изменений. Они касаются размера абонентской платы, количества...
Сталкер зов припяти лучшее оружие в игре
S.T.A.L.K.E.R.: Call of Pripyat 4,260 уникальных посетителей 105 добавили в избранное "Уникальная модель пистолета СИП-т М200. Была выпущена малой партией...
Сталкер зов припяти много оружия
Для Всех любителей отличного отечественного шутера S.T.A.L.K.E.R.Зов Припяти представлен новый Оружейный мод Автоматы Штурмовые винтовки:1. АК-472. АКS-47 тактический3. АК-113 "Монгол"4....
Тарифы ростелекома на домашний интернет
Полный список актуальных тарифов Ростелеком для города Москва. Подключай тарифы Rostelecom в Москве бесплатно и пользуйся качественными услугами интернета и...
Adblock detector