С ctrl: Сочетания клавиш в приложениях — Служба поддержки Майкрософт

Содержание

Что может Ctrl в Visual Studio / Хабр

skim1776

Время на прочтение
2 мин

Количество просмотров 230K

Visual Studio *

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

Далее список того, что можно делать с клавишей Ctrl.


Редактирование и печать:

Ctrl+C, Ctrl+V, Ctrl+X, Ctrl+S — самое очевидное

Ctrl+P — мало ли, вдруг кому-то захочется распечатать свой код

Ctrl+Del, Ctrl+Backspace — удаление слова справа от курсора, слева от курсора

Ctrl+Enter, Ctrl+Shift+Enter — добавление строки над текущей, под текущей

Ctrl+J — завершение ввода выражения

Ctrl+U — перевод символа перед курсором в нижний регистр

Ctrl+Shift+U — перевод символа перед курсором в верхний регистр

Ctrl+= — выделение кода до предыдущего положения курсора

Ctrl+Left, Ctrl+Right — переход к предыдущему слову, следующему

Ctrl+Shift+Left, Ctrl+Shift+Right — выделение слова слева от курсора, справа от курсора

Ctrl+K, Ctrl+C(комбинация) — закомментирование строки

Ctrl+K, Ctrl+U(комбинация) — раскомментирование строки

Поиск и навигация:

Ctrl+F, Ctrl+Shift+F — поиск в документе, поиск в файлах

Ctrl+H, Ctrl+Shift+H — поиск с заменой в документе, поиск с заменой в файлах

Ctrl+F3, Ctrl+Shift+F3 — поиск выделенного текста в прямом и обратном направлениях

Ctrl+F4 — закрытие текущего окна

Ctrl+F6, Ctrl+Shift+F6 — переход к следующему окну, предыдущему(по принципу последний использовавшийся)

Ctrl+Tab, Ctrl+Shift+Tab — тот же эффект, только с отображением окон

Ctrl+Alt+Up, Ctrl+Alt+Down — выпадающий список открытых окон

Ctrl+- — переход к предыдущему положению курсора

— на панели инструментов

Ctrl+Up, Ctrl+Down — переход к следующей группе инструментов, предыдущей

Ctrl+PageUp, Ctrl+PageDown — переход к следующему окну, предыдущему

Компиляция и отладка:

Ctrl+F5 — запуск без отладки

Ctrl+Shift+B — сбилдить решение

Ctrl+D, Ctrl+E(комбинация) — список исключений при отладке

Ctrl+Shift+F9 — удалить все брейкпоинты

Рефакторинг:

Ctrl+R, Ctrl+M(комбинация) — выделение метода

Ctrl+R, Ctrl+E(комбинация) — инкапсуляция метода

Ctrl+R, Ctrl+I(комбинация) — выделение интерфейса

Ctrl+R, Ctrl+V(комбинация) — удаление параметра

Ctrl+R, Ctrl+O(комбинация) — изменить порядок параметров

Другое:

Ctrl+I — превращает курсор в бинокль, который при наведении на объект, выдает всплывающую подсказку о нем

Ctrl+Space — вывод подсказок IntelliSense

Ctrl+Alt+A — открытие командной строки

Ctrl+K, Ctrl+I(комбинация) — всплывающие подсказки

Ctrl+K, Ctrl+X(комбинация) — вставка шаблонов

Ctrl+K, Ctrl+F(комбинация) — форматирование выделенного текста

Ctrl+Alt+Space — вывод параметров функции при наборе

Ctrl+Shift+A — добавить новые item

— закладки(все в комбинации)

Ctrl+K, Ctrl+K — установить закладку

Ctrl+K, Ctrl+N — переход к следующей закладке

Ctrl+K, Ctrl+P — возврат к предыдущей закладке

Ctrl+K, Ctrl+L — удалить все закладки

И наконец, мое самое любимое — Ctrl+’. ‘(плюс точка на латинице)

Самая часто встречающаяся неточность — попытка использовать какой-то класс, который еще не создан, либо который не был подключен. Именно для этого и существует комбинация Ctrl+. Достаточно нажать после имени класса, как всплывающее окно предложит либо заинклюдить необходимую библиотеку, либо создать новый класс.

На этом, пожалуй, список завершен. Просьба сообщить, если что-то важное было упущено, да и неважное тоже.

Теги:

  • visual studio
  • ctrl
  • комбинации клавиш

Хабы:

  • Visual Studio

Ctrl+C и Ctrl+V — не работают горячие клавиши на клавиатуре, почему? — NIBBL

  • О сайте
  • Контакты

войти в систему

Добро пожаловат!Войдите в свой аккаунт

Ваше имя пользователя

Ваш пароль

Вы забыли свой пароль?

завести аккаунт

Зарегистрироваться

Добро пожаловат!Зарегистрируйтесь для создания учетной записи

Ваш адрес электронной почты

Ваше имя пользователя

Пароль будет выслан Вам по электронной почте.

восстановление пароля

Восстановите свой пароль

Ваш адрес электронной почты

Изменена:

В данной статье вы узнаете почему у вас могут перестать работать комбинации горячих клавиш на клавиатуре компьютера или ноутбука под Windows 7 или 10, а также на MacBook горячие клавиши Ctrl+C и Ctrl+V (копировать и вставить) при работе в офисных приложениях Microsoft Office (Word или Excel), браузерах или других программах или приложениях.

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

  • Почему не работает комбинация клавиш Ctrl+C
  • Почему у меня не копируется и не вставляется текст
  • Не копируется картинка через ctrl c
  • Не работает копировать вставить
  • В ворде не работает сочетание клавиш ctrl
  • В excel не работают горячие клавиши ctrl
  • не работают ctrl shift

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

1 Вчера все работало, а сегодня нет

1.1 Грязь под кнопкой

1.2 Перехват горячих клавиш сторонними программами

1.3 Как проверить работоспособность клавиатуры?

1.4 Настройка залипания клавиш в windows 7 и 10

1.5 Ошибка или глюк Windows

2 Видео инструкция

Вчера все работало, а сегодня нет

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

  1. В прошлый рабочий день горячие клавиши работали?
  2. Что произошло в интервал между тем когда все работало и перестало

в этих пунктах всегда кроется разгадка которая с вероятностью 99% решает все проблемы.

Грязь под кнопкой

Самая банальная проблема при которой не работает функция  Копировать — Вставить:

  • это залипшая клавиша CTRL в которой либо скопилось огромное кол-во грязи b
  • либо просто кто то пролил сладкий чай или кофе и она залипла.

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

Перехват горячих клавиш сторонними программами

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

  • Punto switcher
  • Skype

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

  • Ctrl+C
  • Ctrl+V
  • Ctrl+Я
  • CTRL + Shift
  • ALT + Shift

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

 Как проверить работоспособность клавиатуры?

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

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

  1. подключить новую клавиатуру и на ней проверить нажатие кнопок
  2. проверить стандартным приложением windows – Экранная клавиатура

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

Настройка залипания клавиш в windows 7 и 10

След по списку вариант это отключение через настройки функции – “Использование залипания клавиш”

  • Для windows 10 – Пуск – > Настройки -> Специальные возможности -> Клавиатура – > “Использование залипания клавиш”
  • Для windows 7 – Пуск – > Панель управления -> Центр Специальных возможностей- > Облегчение работы с клавиатурой > “Включить залипания клавиш”

Ошибка или глюк Windows

Самый последний вариант который может влиять на работу клавиатуры это “кривая” установка обновлений  Windows после которых просто необходимо сделать перезагрузку компьютера.

Видео инструкция

Все!

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

Popular

python — Невозможно завершить многопроцессорную программу с помощью ctrl + c

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

  1. Вызовите signal.signal(signal.SIGINT, signal.SIG_IGN) в каждом процессе в вашем пуле процессов, чтобы полностью игнорировать прерывание и оставить обработку к основному процессу и
  2. Используйте вместо этого метод Pool.imap (или Pool.imap_unordered ) вместо Pool.map , который лениво оценивает ваш итерируемый аргумент для отправки задач и обработки результатов. Таким образом, он (а) не блокирует ожидание всех результатов и (б) экономит память, поскольку не нужно создавать фактический список для value_n_list , а вместо этого использовать выражение генератора.
  3. Основной процесс должен периодически и часто выводить отчеты о печати, например, сообщать о ходе выполнения отправленных задач. Это необходимо для восприятия прерывания клавиатуры. В коде ниже tqdm индикатор выполнения используется, но вы можете просто распечатать количество завершений через каждые N завершений задачи, где выбрано N, чтобы вам не приходилось слишком долго ждать, пока прерывание вступит в силу после нажатия Ctrl-c:
 из многопроцессорного пула импорта
сигнал импорта
импорт tqdm
определение init_pool():
    сигнал.сигнал(сигнал.SIGINT, сигнал.SIG_IGN)
def process_number (число: int):
    время импорта
    # обрабатывает номер
    время сна (.001)
если __name__ == '__main__':
    контроль = 1
    размер_списка = 100000
    # Нет причин создавать пул снова и снова:
    с пулом (инициализатор = init_pool) как p:
        пытаться:
            с tqdm.trange(list_size) как progress_bar:
                пока верно:
                    #value_n_list = (n вместо n в диапазоне (управление, управление + размер_списка))
                    value_n_list = диапазон (управление, управление + размер_списка)
                    progress_bar. reset()
                    результат = []
                    # Итерируемый объект, возвращаемый `imap`, должен быть повторен.
                    # Если вам не важно значение, не сохраняйте его и используйте вместо него `imap_unordered`:
                    для return_value в p.imap(process_number, value_n_list):
                        progress_bar.update(1)
                        результат.добавлять(возвращаемое_значение)
                    управление += размер_списка
        кроме KeyboardInterrupt:
            print('Ctrl-c введен.')

Обновление

Вы не указали, на какой платформе вы работаете (вы должны всегда помечать свой вопрос платформой, когда вы помечаете вопрос multiprocessing ), но я предположил, что это была Windows. Однако, если вы работаете под Linux, должно работать следующее более простое решение:

 из многопроцессорного пула импорта
сигнал импорта
определение init_pool():
    сигнал.сигнал(сигнал. SIGINT, сигнал.SIG_IGN)
def process_number (число: int):
    время импорта
    # обрабатывает номер
    время сна (.001)
если __name__ == '__main__':
    контроль = 1
    размер_списка = 100000
    # Нет причин создавать пул снова и снова:
    с пулом (инициализатор = init_pool) как p:
        пытаться:
            пока верно:
                value_n_list = [n для n в диапазоне (control, control + list_size)]
                результат = p.map (номер_процесса, список_значений_n)
                управление += размер_списка
        кроме KeyboardInterrupt:
            print('Ctrl-c введен.')

См. Прерывания клавиатуры с многопроцессорным пулом Python

Обновление

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

  1. Функция без многопроцессорной обработки выполняет 10 итераций (а не бесконечный цикл по очевидным причинам) 10000 циклов, вызывая номер_процесса и сохраняя все возвращаемые значения в результат .

  2. Функция multiprocessing_1 использует многопроцессорность для выполнения вышеуказанного, но создает пул только один раз (8 логических ядер, 4 физических ядра).

  3. Функция multiprocessing_2 повторно создает пул для каждой из 10 итераций.

  4. Функция multiprocessing_3 включена как «проверка работоспособности» и идентична multiprocessing_1 , за исключением того, что она имеет код проверки Linux Ctrl-c.

Тайминги каждого распечатаны.

 из многопроцессорного пула импорта
время импорта
сигнал импорта
определение init_pool():
    сигнал.сигнал(сигнал.SIGINT, сигнал.SIG_IGN)
def process_number (число: int):
    # обрабатывает номер
    номер возврата * номер
N_ПРОБНЫХ = 10
размер_списка = 100_000
определение non_multiprocessing():
    т = время. время()
    контроль = 1
    для _ в диапазоне (N_TRIALS):
        результат = [номер_процесса (n) для n в диапазоне (управление, управление + размер_списка)]
        печать (управление, результат [0], результат [-1])
        управление += размер_списка
    время возврата.время() - т
определение многопроцессорности_1():
    т = время.время()
    # Нет причин создавать пул снова и снова:
    с Pool() как p:
        контроль = 1
        для _ в диапазоне (N_TRIALS):
            value_n_list = [n для n в диапазоне (control, control + list_size)]
            результат = p.map (номер_процесса, список_значений_n)
            печать (управление, результат [0], результат [-1])
            управление += размер_списка
    время возврата.время() - т
определение многопроцессорности_2():
    т = время.время()
    контроль = 1
    для _ в диапазоне (N_TRIALS):
        # Создавайте пул снова и снова:
        с Pool() как p:
            value_n_list = [n для n в диапазоне (control, control + list_size)]
            результат = p. map (номер_процесса, список_значений_n)
            печать (управление, результат [0], результат [-1])
            управление += размер_списка
    время возврата.время() - т
определение init_pool():
    сигнал.сигнал(сигнал.SIGINT, сигнал.SIG_IGN)
определение многопроцессорности_3():
    т = время.время()
    # Нет причин создавать пул снова и снова:
    с пулом (инициализатор = init_pool) как p:
        пытаться:
            контроль = 1
            для _ в диапазоне (N_TRIALS):
                value_n_list = [n для n в диапазоне (control, control + list_size)]
                результат = p.map (номер_процесса, список_значений_n)
                печать (управление, результат [0], результат [-1])
                управление += размер_списка
        кроме KeyboardInterrupt:
            print('Ctrl-c введен.')
    время возврата.время() - т
если __name__ == '__main__':
    print('non_multiprocessing:', non_multiprocessing(), end='\n\n')
    print('многопроцессорность_1:', многопроцессорность_1(), конец='\n\n')
    print('многопроцессорность_2:', многопроцессорность_2(), конец='\n\n')
    print('многопроцессорность_3:', многопроцессорность_3(), конец='\n\n')

Распечатки:

 1 1 10000000000
100001 10000200001 40000000000
200001 40000400001 
000000
300001 
600001 160000000000
400001 160000800001 250000000000
500001 250001000001 360000000000
600001 360001200001 4
000000
700001 4
400001 640000000000
800001 640001600001 810000000000

1 810001800001 1000000000000
non_multiprocessing: 0,11899852752685547
1 1 10000000000
100001 10000200001 40000000000
200001 40000400001 
000000
300001 
600001 160000000000
400001 160000800001 250000000000
500001 250001000001 360000000000
600001 360001200001 4
000000
700001 4
400001 640000000000
800001 640001600001 810000000000

1 810001800001 1000000000000
многопроцессорность_1: 0,48778581619262695
1 1 10000000000
100001 10000200001 40000000000
200001 40000400001 
000000
300001 
600001 160000000000
400001 160000800001 250000000000
500001 250001000001 360000000000
600001 360001200001 4
000000
700001 4
400001 640000000000
800001 640001600001 810000000000

1 810001800001 1000000000000
многопроцессорность_2: 2.
 4370007514953613
1 1 10000000000
100001 10000200001 40000000000
200001 40000400001 
000000
300001 
600001 160000000000
400001 160000800001 250000000000
500001 250001000001 360000000000
600001 360001200001 4
000000
700001 4
400001 640000000000
800001 640001600001 810000000000

1 810001800001 1000000000000
многопроцессорность_3: 0,4850032329559326

Даже с однократным созданием пула многопроцессорная обработка заняла примерно в 4 раза больше времени, чем прямая реализация без многопроцессорной обработки. Но он работает примерно в 5 раз быстрее, чем версия, которая пересоздает пул для каждой из 10 итераций. Как и ожидалось, время работы multiprocessing_3 по существу идентичен времени выполнения для multiprocessing_1 , т. е. код Ctrl-c не влияет на поведение выполнения.

Выводы

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

многопоточность — остановить скрипт Python с помощью ctrl + c

спросил

Изменено
2 года, 11 месяцев назад

Просмотрено
3к раз

У меня есть скрипт, который использует потоки, но не может перехватить Ctrl + C.

Вот пример кода для воспроизведения этой ошибки:

 потоки импорта
время импорта
сигнал импорта
класс DummyThread (threading.Thread):
    защита __init__(сам):
        threading.Thread.__init__(self)
        self._running = Истина
        signal.signal(signal.SIGINT, self. stop)
        signal.signal(signal.SIGTERM, self.stop)
    стоп-защита (я, знак = нет, кадр = нет):
        self._running = Ложь
    деф запустить (самостоятельно):
        в то время как self._running:
            время сна(1)
            печать("Выполняется")
если __name__ == "__main__":
    пытаться:
        т = DummyThread()
        т.старт()
        пока верно:
            print("Выполняется основной поток")
            время сна (0,5)
    кроме KeyboardInterrupt:
        print("Это никогда не будет напечатано")
        т.стоп()
    окончательно:
        распечатать("Выход")

Когда я запускаю python3 script.py , он запускается, но не перехватывает ctrl+c. Я гуглил, но не нашел решения. Мне нужно завершить сценарий с помощью SIGTERM, но я хочу, чтобы DummyThread корректно остановился.

  • Python
  • многопоточность
  • сигналы

9

 класс DummyThread(threading. Thread):
    защита __init__(сам):
        threading.Thread.__init__(self)
        self._running = Истина
        signal.signal(signal.SIGINT, self.stop)
        signal.signal(signal.SIGTERM, self.stop)

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

Причина в том, что если вы нажмете Ctrl-C , сигнал SIGINT будет обработан обработчиком сигнала, который настроен с помощью signal.signal и self.stop . Таким образом, поток должен фактически остановиться.

Но в основном потоке цикл while True все еще выполняется. Так как сигнал уже обработан, будет нет Исключение KeyboardInterrupt , вызванное средой выполнения Python. Поэтому вы никогда не доберетесь до части , кроме части .

 если __name__ == "__main__":
    пытаться:
        т = DummyThread()
        т. старт()
        while True: # вы застряли в этом цикле
            print("Выполняется основной поток")
            время сна (0,5)
    кроме KeyboardInterrupt: # такого никогда не бывает
        print("Это никогда не будет напечатано")
        т.стоп()

Для вызова метода stop должен быть настроен только один обработчик сигнала. Таким образом, есть два варианта решения проблемы:

  1. Неявно обрабатывать сигнал, перехватывая исключение KeyboardInterrupt . Это достигается простым удалением двух строк signal.signal(...) .

  2. Настройте явный обработчик сигнала (как вы сделали, используя signal.signal в DummyThread.__init__ ), но удалите , пока True: из основного потока и не пытайтесь обрабатывать KeyboardInterrupt . Вместо этого просто подождите, пока DummyThread завершится самостоятельно, используя метод join :

     если __name__ == "__main__":
    т = DummyThread()
    т. старт()
    т.присоединиться()
    распечатать("Выход")

0

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

Согласно документации Python:

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

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

 из потокового импорта Thread, Event
время импорта
класс DummyThread (поток):
    def __init__(я, событие: событие):
        Поток. __init__(сам)
        self.stop_event = событие
    деф запустить (самостоятельно):
        # мы следим за событием в Main Thread
        пока не self.stop_event.is_set():
            время сна(1)
            печать("Выполняется")
        # только основной поток может сделать точку доступной
        print("Я готов!")
если __name__ == "__main__":
    пытаться:
        е = событие ()
        t = DummyThread(e)
        т.старт()
        пока верно:
            print("Выполняется основной поток")
            время сна (0,5)
    кроме KeyboardInterrupt:
        e.set()
    окончательно:
        распечатать("Выход")

Другой возможный вариант — использовать daemon Thread для таких задач, как в вашем примере кода (когда вы просто печатаете что-то на экране каждую секунду, а не, например, закрываете соединение с базой данных или какую-то подобную задачу). Если основной поток остановлен, демон Thread также остановится.

Как показано в вашем коде, вы использовали KeyboardInterrupt для вызова функции stop() . Посмотрите, как Listener выполняет ту же задачу и останавливает выполнение, которое не удалось отловить с Ctrl + C . Вам больше не нужно убивать скрипт с помощью SIGTERM 

 import threading
время импорта
сигнал импорта
импорт ОС
из pynput.keyboard импортировать ключ, прослушиватель
класс DummyThread (threading.Thread):
    защита __init__(сам):
        threading.Thread.__init__(self)
        self._running = Истина
        signal.signal(signal.SIGINT, self.stop)
        signal.signal(signal.SIGTERM, self.stop)
    стоп-защита (я, знак = нет, кадр = нет):
        self._running = Ложь
        печать («До свидания. . .»)
        os._exit(1)
    деф запустить (самостоятельно):
        в то время как self._running:
            время сна(1)
            печать("Выполняется")
если __name__ == "__main__":
    т = DummyThread()
    определение функции2():
        пытаться:
            т.старт()
            пока верно:
                print("Выполняется основной поток")
                время сна (0,5)
        кроме KeyboardInterrupt:
            print("Это не нужно")
            т. стоп()
        окончательно:
            распечатать("Выход")
    определение функции1():
        с Listener(on_press = t.stop) в качестве слушателя:
            слушатель.присоединиться()
    threading.Thread(target=func1).start()
    threading.Thread(target=func2).start()

2

Зарегистрируйтесь или войдите в систему

Зарегистрируйтесь с помощью Google

Зарегистрироваться через Facebook

Зарегистрируйтесь, используя электронную почту и пароль

Опубликовать как гость

Электронная почта

Требуется, но не отображается

Опубликовать как гость

Электронная почта

Требуется, но не отображается

Нажимая «Опубликовать свой ответ», вы соглашаетесь с нашими условиями обслуживания и подтверждаете, что прочитали и поняли нашу политику конфиденциальности и кодекс поведения.