В App Store снова появилось приложение Telegram для Apple Watch

Telegram вернул приложение для Apple Watch в App Store с поддержкой сообщений, голосовых и текстовых сообщений, гифок и стикеров. После переиздания приложения в сторе можно ожидать запуска таргетированной рекламы в Telegram ADS, что открывает возможности для тестирования MVA-приложений на iOS через новый канал трафика.

➡️ Читайте на сайте: https://aff.top/blog/v-app-store-snova-poiavilos-prilozhenie-telegram-dlia-apple-watch

🧠 Ещё больше инсайтов → в канале AFF.top

DeepSeek в проде ломается не на модели, а на плохом пайплайне инференса

DeepSeek часто берут ради сильного reasoning и хорошего соотношения качество/цена, но в реальном сервисе решает не только чекпоинт.

— Сначала проверь формат задачи: если это короткие ответы, то длинный контекст и тяжелый reasoning только съедают throughput.
— Для batch-генерации и очередей почти всегда выгоднее vLLM; если нужен простой локальный запуск или CPU/GPU-микс, смотри в сторону llama.cpp.
— Квантизация ниже fp16 обязана проходить свой набор тестов: на code, math и extraction модели могут вести себя по-разному.
— Для API-сервиса отдельно меряй prompt prefill и decode, а не только общий tokens/sec: именно prefill часто убивает latency на длинных промптах.
— Не смешивай в одном endpoint задачи с разной длиной контекста без лимитов: один «монстр»-запрос портит очередь всем остальным.

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

vLLM и TGI ломаются не на модели, а на неправильном профиле нагрузки

Если у тебя короткие запросы, высокий параллелизм и нужен агрессивный batching — vLLM обычно даёт выше throughput за счёт paged attention и более гибкого управления KV-cache. Если важнее предсказуемость, интеграция в уже собранный inference-пайплайн и контроль за serving-логикой — TGI часто проще в эксплуатации.

Смотри не на «лучший фреймворк», а на три числа: tokens/sec на одну GPU, p95 latency и объём контекста при реальной очереди. В синтетике оба сервера выглядят бодро, но при длинных промптах и mixed load начинает решать не маркетинг, а то, как движок режет память, собирает batch и пережёвывает prefill.

Практика такая:
• vLLM — если у тебя много одновременных сессий, streaming и постоянная смена длины запросов.
• TGI — если важны стабильность, понятный deployment и интеграция с HF-стеком.
• Оба нужно тестировать на своём распределении: короткие саппорт-реплики, длинные RAG-запросы, tool-calls, несколько одинаковых пиковых окон.

Не делай вывод по одному прогону на 512 токенов. Прогони хотя бы 3 профиля: short chat, long context, burst traffic. Тогда выбор между vLLM и TGI станет не религией, а инженерным решением.

Арбитраж на вертикаль астрологии: как начать с ней работать

Астрология — белая вертикаль с низким порогом входа для CPA-арбитража. Можно создать собственного астробота через конструктор или нейросеть, подключив платежи через сервисы вроде Tribute, либо работать через партнёрки с готовыми ботами и SP-офферами. Также доступны нишевые площадки типа Bongacams с эзотериками (A. W. Empire). Трафик заливают со стандартных источников без клоачинга — Яндекс Директ, МТС Ads, ВК. Вертикаль привлекательна скромной к…

➡️ Читайте на сайте: https://aff.top/blog/arbitrazh-na-vertikal-astrologii-kak-nachat-s-nei-rabotat

🧠 Ещё больше инсайтов → в канале AFF.top

DeepSeek в проде: где модель реально экономит токены, а где её лучше не ставить

DeepSeek часто берут как «дешёвую замену», но в проде смотреть надо не на бренд, а на профиль задачи: генерация, код, классификация, длинный контекст.

— Для structured generation и code-heavy сценариев сильнее всего обычно работает связка: умеренный размер модели + жёсткий system prompt + low temperature.
— Для длинных диалогов важнее не «128k на бумаге», а реальная деградация после нескольких десятков тысяч токенов: у многих моделей качество ответов падает раньше, чем заканчивается окно.
— Для RAG DeepSeek полезен там, где нужен хороший follow-up по найденным кускам текста, но retrieval всё равно решает больше, чем сама LLM.
— Для массового API-сервиса считайте не только качество, но и throughput на вашей GPU: если модель даёт меньше токенов/sec, дёшево на токен она может стать дорогой на инфраструктуру.

Практика такая: сначала гоняете модель на своём наборе промптов, потом сравниваете quality / latency / cost / license. Если задача — чат и извлечение фактов, берите smaller variant. Если нужен сложный reasoning или код с многослойным контекстом, проверяйте старшую, но обязательно на своём железе.

Главная ошибка — выбирать DeepSeek по общему впечатлению. В проде выигрывает не «лучшая модель», а та, у которой совпали качество ответа, скорость и стоимость обслуживания.

Llama в проде: 6 проверок, которые спасают от дорогого и медленного инференса

Llama часто берут “по умолчанию”, а потом удивляются просадке по latency и качеству. Перед запуском проверьте четыре вещи: размер контекста, тип квантизации, формат сервинга и реальную длину промптов в вашем трафике. Если 90% запросов укладываются в короткий контекст, не переплачивайте за огромный KV-cache и лишнюю VRAM.

Для 8B-моделей рабочая база — fp16 для качества, int8 как компромисс, int4/gguf для дешёвого CPU или одной GPU с ограниченной памятью. На практике важнее не “максимальный размер”, а tokens/sec на вашей карте и стабильность под параллельной нагрузкой. vLLM обычно выигрывает на батчинге, TGI удобен в продакшене, llama.cpp нужен там, где критична автономность.

Отдельно смотрите на prompting: у Llama чувствительность к шаблону ответа выше, чем кажется. Один и тот же чекпоинт может давать разный output при смене system prompt, stop tokens и температуры. Если делаете fine-tune под нишу, сначала фиксируйте формат входа и метрику ошибки, а уже потом крутите LoRA.

Ещё одна типовая ошибка — сравнивать модель в вакууме. Считайте не только качество, но и стоимость 1M токенов на вашем железе, p95 latency, объём памяти под контекст и цену простоя. Брать Llama имеет смысл там, где вы готовы управлять инференсом как продуктом, а не как “чёрным ящиком”.

DeepSeek для продакшена: как не промахнуться с выбором модели и инференса

DeepSeek часто берут за сильный reasoning и нормальную цену входа, но в проде смотреть надо не на хайп, а на профиль нагрузки.

— Для чата и RAG важны не только ответы, но и поведение на длинном контексте: у больших контекстов деградация начинается раньше паспортного окна.
— Если нужен поток запросов, сравнивайте не «качество на глаз», а tokens/sec, p95 latency и max batch size на своём железе.
— Для задач с жёсткой стоимостью токена считайте throughput на одной GPU в разных квантизациях: fp16, int8, int4. Разница по экономике часто важнее разницы в бенчмарке.
— Если планируется fine-tune, проверьте, как модель держит LoRA на вашем домене: у reasoning-моделей иногда проседает стиль, даже если метрика на тесте растёт.
— Лицензия и режим использования важнее красивого демо: сначала проверяем, можно ли модель легально встраивать в коммерческий стек.

Практика простая: тестируйте DeepSeek не на одном промпте, а на пачке из 50–200 реальных запросов, где есть короткие, длинные и «грязные» кейсы. И только после этого решайте, брать ли её как основную или оставить для узкого класса задач.

vLLM и TGI ломают prod по-разному: где у каждого свой скрытый лимит

Если у тебя один и тот же промпт на 8k летает, а на 32k внезапно сыпется latency — проблема часто не в модели, а в сервере. vLLM и TGI оба умеют отдавать LLM в проде, но оптимизируют разные узкие места: один чаще выигрывает на динамическом батчинге и высокой утилизации GPU, другой — на предсказуемом пайплайне и простом прод-обвязке.

Смотри на 4 вещи:
— throughput в tokens/sec на одной GPU, а не “сколько RPS держит”
— p95/p99 latency при смешанном трафике, а не только среднее
— поведение на длинном контексте: 16k/32k/64k часто деградируют неравномерно
— memory fragmentation: если сервис живёт под постоянным churn запросов, часть VRAM просто уходит в мусор

vLLM обычно лучше, когда важна плотная загрузка железа и много параллельных сессий с разной длиной промптов. TGI удобнее, когда нужен более прямолинейный деплой, стабильный API и меньше сюрпризов в эксплуатационке. Но оба проиграют, если ты не ограничил max_tokens, не настроил batching и не посчитал, сколько контекста реально нужно бизнес-задаче.

Правило простое: сначала замерь на своём профиле трафика, потом выбирай движок. Иначе можно получить “быстрый” сервер, который в проде сжирает VRAM, режет контекст и делает cost/token хуже, чем у внешнего API.

Mistral и Gemma в проде: как выбрать модель под свои GPU и не убить latency

Если нужен open-source стек без OpenAI-зависимости, Mistral и Gemma закрывают разные задачи. Сначала смотрим не на «качество в вакууме», а на 4 оси: качество, скорость, цена инференса и лицензия.

• Mistral обычно удобнее там, где важны короткий latency и хороший instruction-following на средних контекстах.
• Gemma чаще берут, когда нужен аккуратный баланс качества и размера модели, особенно для локального запуска на ограниченной VRAM.
• Для обеих семейств критичен формат инференса: vLLM даёт лучший throughput на батчах, TGI удобен для сервинга, llama.cpp выигрывает на CPU и GGUF, но теряет в пропускной способности на больших нагрузках.

Типовая ошибка — сравнивать fp16 и int4 как будто это одна и та же постановка. Квантизация меняет не только память, но и поведение на длинном контексте, особенно если у вас RAG, tool-calling и длинные промпты. На практике сначала проверяют: помещается ли модель в VRAM с запасом под KV-cache, а уже потом гонят бенчмарк.

Для продакшена полезен такой порядок:
— 1) выбрать целевой сценарий: чат, извлечение, классификация, генерация креативов;
— 2) измерить tokens/sec на одной GPU в вашем фреймворке;
— 3) прогнать промпты с длинным контекстом;
— 4) сравнить стоимость 1M токенов с self-hosted альтернативой.

Если модель не укладывается в ваш SLA по latency, «лучшее качество» становится бесполезным. Брать надо ту, что стабильно держит ваш сценарий, а не абстрактный бенчмарк.

DeepSeek в проде ломается не на «качестве», а на неправильном режиме запуска

DeepSeek-R1 и его дистилляты часто берут за reasoning, но в реальном пайплайне решают три вещи: контекст, скорость и стабильность промпта. Если задача — короткий ответ или строгий JSON, не гоняйте модель в цепочке размышлений без нужды: длинный hidden-thought съедает токены и увеличивает latency.

Для self-hosted важны не «размер модели», а режим инференса:
— vLLM: лучший выбор, если нужен высокий throughput и батчинг;
— TGI: удобен для стандартного serving и контроля очереди;
— llama.cpp: берите для CPU/GGUF и экономии VRAM, но не ждите рекордной скорости;
— SGLang/аналогичные движки: полезны, когда много длинных диалогов и сложный роутинг.

На практике DeepSeek лучше ставить как отдельный слой: один маршрут для reasoning, другой — для extraction и классификации. Иначе вы платите за дорогую генерацию там, где хватило бы компактной модели. Для RAG это особенно заметно: retrieval должен быть дешёвым, а reasoning — включаться только на спорных кейсах.

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

Вывод простой: DeepSeek — не «одна модель на всё», а инструмент для маршрутизации. Сначала отделите reasoning от обычных задач, потом уже считайте throughput и стоимость токена.

DeepSeek для продакшена: как не промахнуться с размером, контекстом и квантизацией

DeepSeek-модели часто берут за «умную» генерацию и сильный код, но в проде смотреть надо не на хайп, а на 4 вещи: качество, скорость, цена, лицензия.

— Если нужен быстрый чат/автоматизация, маленькая модель на int4 часто выгоднее большой в fp16: latency ниже, GPU проще, а throughput выше.
— Для длинного контекста не верьте рекламному числу вслепую: после определённого окна качество начинает падать, особенно на многошаговых задачах и RAG без хорошего ретривала.
— Для кодовых задач важнее не только perplexity, но и поведение на репозиториях: генерация патчей, соблюдение API, устойчивость к длинным промптам.
— Если берёте модель под API-сервис, сразу считайте токены: vLLM даёт хороший throughput на батчинге, llama.cpp — проще для CPU/GPU-микса и edge, TGI удобен, когда важна стандартная эксплуатация.
— Квантизация — не “дешёвый fp16”, а отдельный режим с потерей качества. Для extraction и классификации это обычно терпимо, для сложного reasoning — уже риск.

Перед внедрением прогоните свой мини-набор: 20–50 реальных запросов, 3 режима инференса, 2 квантизации. И только потом решайте, брать ли модель в прод.

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

Llama для продакшена: 5 проверок до запуска, чтобы не сжечь бюджет

Llama часто берут как «дешёвую замену API», но в проде модель ломается не на бенчмарке, а на деталях инференса. Смотрите не только на качество, а на 4 оси: лицензия, длина контекста, latency и стоимость 1M токенов на вашем железе.

1) Проверьте лицензию на коммерческое использование и ограничения по продукту. Для self-hosted это критично: одна и та же архитектура может быть ок для внутреннего инструмента, но спорной для внешнего SaaS.

2) Тестируйте не «среднюю скорость», а p95 latency при вашем промпте и batch size. Для Llama на одной GPU разница между fp16, int8 и int4 может быть не только в памяти, но и в стабильности длинных ответов.

3) Не верьте заявленному 128k без собственного прогона. На длинном контексте важны KV-cache, rope scaling и деградация качества после определённой длины. Если модель начинает терять инструкции на середине диалога — это не баг приложения, а предел режима.

4) Сравнивайте не только vLLM, но и TGI, llama.cpp, Ollama: где-то выиграете в throughput, где-то в простоте деплоя, а где-то — в цене владения на слабом железе.

Если Llama не проходит ваш реальный сценарий по latency и памяти, «открытость» не спасает. Брать стоит только после прогона на своих промптах, своих длинах и своей экономике.

Anthropic отменили доступ к Claude Fable 5

Fable 5, нейросетевая модель, которая должна была революционизировать индустрию, была отключена через три дня после релиза из-за ограничений на использование для граждан США и найденной уязвимости в безопасности. Компания не смогла технически реализовать географические ограничения и вынуждена была отозвать публично опубликованную модель со всех аккаунтов — первый такой прецедент. Это может стать предвестником нового тренда, когда компании будут …

➡️ Читайте на сайте: https://aff.top/blog/anthropic-otmenili-dostup-k-claude-fable-5

🧠 Ещё больше инсайтов → в канале AFF.top

Арбитраж трафика для новичков в 2026: стоит ли начинать?

Три опытных арбитражника — Дима Leto, Михаил Харди и Роман Croyman — развенчивают миф о лёгких деньгах в CPA-арбитраже. Главный вывод: успех требует серьёзного бюджета (минимум $1000, реально больше), года работы с убытками и постоянного тестирования. Маркетинговое образование помогает, но не критично — важнее опыт в конкретной нише. Кейсы с миллионными прибылями создают завышенные ожидания, но без них новичок не верит в возможность вообще. Лучш…

➡️ Читайте на сайте: https://aff.top/blog/arbitrazh-trafika-dlia-novichkov-v-2026-stoit-li-nachinat

🧠 Ещё больше инсайтов → в канале AFF.top

vLLM или TGI: как не выбрать движок инференса вслепую и не потерять throughput

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

— vLLM обычно выигрывает там, где важны continuous batching и высокая утилизация GPU на mixed workload.
— TGI чаще выбирают за более предсказуемую эксплуатацию, удобный production-пайплайн и понятную интеграцию вокруг Hugging Face-экосистемы.
— На коротких запросах разница может быть небольшой, а на длинном контексте и большом concurrency уже решает scheduler, KV-cache и политика батчинга.

Смотрите на 4 метрики: tokens/sec на GPU, p95 latency, стабильность под пиками и расход VRAM на один активный диалог. Если модель ест память агрессивно, любой красивый throughput быстро превращается в OOM.

Отдельно проверьте:
— насколько движок держит большой batch без деградации;
— как ведёт себя при stream-ответах;
— можно ли ограничить max context и max new tokens на уровне сервера;
— что будет при рестарте и прогреве модели.

Для продакшена критичен не максимальный, а устойчивый throughput. Один и тот же LLM может выглядеть одинаково на бенчмарке, но в реальном трафике один движок даст меньше хвостов по latency и меньше срывов по памяти.

Если у вас смешанный поток запросов и важна загрузка GPU до упора — начинайте с vLLM. Если важнее простая и предсказуемая эксплуатация в Hugging Face-стеке — смотрите в сторону TGI.

vLLM или TGI: 4 ошибки при выборе inference-стека для Llama и Qwen

Если нужен высокий throughput на батчах и много одновременных запросов, vLLM обычно выигрывает за счёт paged attention и агрессивного continuous batching. Если важнее предсказуемость, tight control над пайплайном и интеграция в Hugging Face-экосистему, TGI часто проще в эксплуатации. Ошибка №1 — сравнивать их на одном промпте: оба стека раскрываются только под нагрузкой.

Ошибка №2 — игнорировать длину контекста. На 8k всё выглядит «быстро», но при 32k+ растёт KV-cache, и узкое место уезжает либо в VRAM, либо в деградацию latency. Для длинных диалогов и RAG сначала считайте память: размер модели, число параллельных сессий, max_tokens, затем уже выбирайте сервер.

Ошибка №3 — мерить только tokens/sec. Для продакшена важнее p95 latency, время до первого токена и поведение под burst-трафиком. vLLM обычно лучше держит микс коротких и длинных запросов, TGI часто стабилен на ровном потоке, но хуже переносит резкие пики без правильной очереди и лимитов.

Ошибка №4 — запускать FP16 там, где int4 или int8 уже закрывают задачу. На одной GPU квантизация часто даёт кратный рост пропускной способности и позволяет поднять batch size без смены железа. Для саппорта, классификации и черновиков текста это обычно выгоднее, чем «максимальное качество любой ценой».

Выбирайте стек не по хайпу, а по профилю нагрузки: если важны максимальный throughput и гибкость — стартуйте с vLLM; если нужен аккуратный production-пайплайн вокруг HF-моделей — смотрите TGI.

Drupal не «тяжёлый», если не тащить в него хаос: 5 правил для живого проекта

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

За неделю в репах обычно всплывают одни и те же ошибки:
— слишком много типов сущностей без понятной модели;
— поля и view-слои смешаны с бизнес-логикой;
— права доступа настраиваются «по месту», а не по матрице ролей;
— кастомный код дублирует то, что уже умеют модули.

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

Для mid-стека Drupal особенно хорош там, где есть:
— много ролей и уровней доступа;
— сложные формы и редакторские workflow;
— несколько витрин, языков или каналов публикации;
— интеграции с CRM, DAM, поиском, PIM.

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

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

Drupal не «тяжёлый», если не тащить в него хаос: 5 правил для живого проекта

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

За неделю в репах обычно всплывают одни и те же ошибки:
— слишком много типов сущностей без понятной модели;
— поля и view-слои смешаны с бизнес-логикой;
— права доступа настраиваются «по месту», а не по матрице ролей;
— кастомный код дублирует то, что уже умеют модули.

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

Для mid-стека Drupal особенно хорош там, где есть:
— много ролей и уровней доступа;
— сложные формы и редакторские workflow;
— несколько витрин, языков или каналов публикации;
— интеграции с CRM, DAM, поиском, PIM.

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

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

Claude скоро станет по паспорту

С 8 июля 2026 года все модели Claude потребуют верификации личности через паспорт и селфи. Это произошло после закрытия доступа к Fable 5, выпущенной в открытый доступ буквально на неделю. Ограничение касается веб-версии на сайте Anthropic, но остаётся неясным, будут ли верификацию требовать API и AI-агенты вроде Codex. Решение выглядит излишне строгим в свете качества моделей, однако компания явно ужесточает контроль над доступом к своим продук…

➡️ Читайте на сайте: https://aff.top/blog/claude-skoro-stanet-po-pasportu

🧠 Ещё больше инсайтов → в канале AFF.top

Почему RU-CMS ломаются не на коде, а на типовых настройках и привычках команды

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

Что проверять в первую очередь:
• права на файлы и директории отдельно от прав админов;
• где хранится конфиг и кто может его менять;
• не правят ли шаблон прямо в проде без копии;
• есть ли понятный порядок бэкапа перед любым вмешательством;
• одинаково ли ведут себя тест и боевой контур.

Отдельная зона риска — модули и интеграции. Любой внешний пакет, импорт, обмен с 1С или CRM может тихо ломать поведение сайта, если нет схемы отката и списка зависимостей. Поэтому полезно держать простое правило: одна задача — одна точка изменения, иначе потом никто не найдет, где именно всё поехало.

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

Надежная RU-CMS-сборка начинается не с «быстрого запуска», а с регламента: что можно менять, где хранится логика и как откатывать неудачную правку.

Mistral и Gemma — когда брать малую модель вместо «побольше» и не проиграть в проде

Если задача — классификация, извлечение полей, короткий RAG-ответ или черновик текста, маленькая open-source модель часто выигрывает не качеством, а экономикой.

Смотреть надо не на «размер», а на 4 вещи:
— качество на вашем домене;
— latency на целевом контексте;
— throughput на одном GPU;
— лицензия, которую можно использовать в коммерции.

Mistral обычно удобен там, где важны скорость и предсказуемость инференса: хороший вариант для высокочастотных запросов, роутинга, суммаризации и простых агентных шагов.
Gemma часто берут, когда нужен аккуратный компромисс между качеством и компактностью: для FAQ, извлечения структурированных данных, подсказок оператору, light-RAG.

Практическое правило:
— если у вас длинный контекст и много параллельных запросов, сначала считайте tokens/sec/GPU;
— если нужна стабильная генерация по шаблону, тестируйте на temperature=0 и на «грязных» входах;
— если модель ломается на вашем языке или в вашей нише, добивать её лучше LoRA, а не увеличением размера.

Главная ошибка — брать модель «с запасом» и потом платить за лишнюю latency и VRAM. Малые модели хорошо живут в проде, если у них есть узкая роль и понятный SLA.

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