REMARKS=freev2.net
vless://<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=Edge"><meta name="robots" content="noindex,nofollow"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="content-security-policy" content="default-src &#39;none&#39;; script-src &#39;nonce-PQU0yiBoyz50uG3uDCVdeH&#39; &#39;unsafe-eval&#39; https://challenges.cloudflare.com; script-src-attr &#39;none&#39;; style-src &#39;unsafe-inline&#39;; img-src &#39;self&#39; https://challenges.cloudflare.com; connect-src &#39;self&#39; https://challenges.cloudflare.com; frame-src &#39;self&#39; https://challenges.cloudflare.com blob:; child-src &#39;self&#39; https://challenges.cloudflare.com blob:; worker-src blob:; form-action http: https:; base-uri &#39;self&#39;"><style>*{box-sizing:border-box;margin:0;padding:0}html{line-height:1.15;-webkit-text-size-adjust:100%;color:#313131;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"}body{display:flex;flex-direction:column;height:100vh;min-height:100vh}.main-content{margin:8rem auto;padding-left:1.5rem;max-width:60rem}@media (width <= 720px){.main-content{margin-top:4rem}}#challenge-error-text{background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI0IyMEYwMyIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMTMgMTNBMTMuMDE1IDEzLjAxNSAwIDAgMCAxNiAzbTAgMjRhMTEgMTEgMCAxIDEgMTEtMTEgMTEuMDEgMTEuMDEgMCAwIDEtMTEgMTEiLz48cGF0aCBmaWxsPSIjQjIwRjAzIiBkPSJNMTcuMDM4IDE4LjYxNUgxNC44N0wxNC41NjMgOS41aDIuNzgzem0tMS4wODQgMS40MjdxLjY2IDAgMS4wNTcuMzg4LjQwNy4zODkuNDA3Ljk5NCAwIC41OTYtLjQwNy45ODQtLjM5Ny4zOS0xLjA1Ny4zODktLjY1IDAtMS4wNTYtLjM4OS0uMzk4LS4zODktLjM5OC0uOTg0IDAtLjU5Ny4zOTgtLjk4NS40MDYtLjM5NyAxLjA1Ni0uMzk3Ii8+PC9zdmc+");background-repeat:no-repeat;background-size:contain;padding-left:34px}</style><meta http-equiv="refresh" content="360"></head><body><div class="main-wrapper" role="main"><div class="main-content"><noscript><div class="h2"><span id="challenge-error-text">Enable JavaScript and cookies to continue</span></div></noscript></div></div><script nonce="PQU0yiBoyz50uG3uDCVdeH">(function(){window._cf_chl_opt = {cFPWv: 'g',cH: '9Ch63PM31XvycSZls5BxdCQ09e.b21O7Q3bQ1fBZLx4-1789715830-1.2.1.1-GzqlHPCZEJH4AK8uX0leLbClt1FDzzH2OmHxWm8qr3INC7aZyfbATZZ3c6AgowSa',cITimeS: '1789715830',cN: 'PQU0yiBoyz50uG3uDCVdeH',cRay: 'a3ce91c57d87cf3b',cTplB: '0',cTplC:0,cTplO:0,cTplV:5,cType: 'managed',cUPMDTk:"/uuid?__cf_chl_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",cvId: '3',cZone: 'dl.freev2.net',fa:"/uuid?__cf_chl_f_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",md: 'uq7gKkfa46Qna81MkX_I66XWXGfeHpCgb7o8bV2t2Lw-1789715830-1.2.1.1-ZxvPh8iZxSYJKKjYekxP8dIBO1w_sMBDpkzY76xrQUrYIraYMNr7L_FIOcAQb7NUUk3zJJ24SROuzvMXDmPZCnCEgoRYZfPOIuSvP7Mx8BJSjMcUyhK7pHmiqw21euZR9u2XTEA2LtfMX_qVKskWxYbi115XNHgxUy5At75s9jsW_5jW.PygluGYI01_Vz4JzlbpSymE3uTC2NVy2b296UBHaQa6wPq4IZHJgy6rV4Y7HmA9BE0GQNj.9R5IhgpEHA2rdIm6eYZsuggBzZzhLsgxMy9Ij3vL33aB0OOrRRgs4.EfVt3ZR59Se6jSVHBmq0NJLK..oGhI9CZBwXM22p04u02VNRPgDbjrZlBx.wqsnOxd2WkbOobNK.DmUI.AeLef5vVgF7_3bfeOKQ2YWzVewfzO9wYg5A8ksMedDzggXqTl3C0D7fMljNSh7PUiH19sp7pqrdki4K7xA2ATCBbM1pvabfpKQeiMbiFYTV1hHZq7fktZC5kCVQs7_MONIVTOmf49xqKAHd4FwLCShJneGrX0dMCLrrUdvFsweu.TAYe_gSwYS8CAJw8R95u_XkaLwsUbYSn2nNeYAD1n60jDEBctBELQXteNDlP4pYQjdeshb8hhvFExSSE0IoBdvBQG_LdYALLW2.9T5ECUXUDR3x8XgK7Zcak1p8NS_cRBp0XwjVApY8OgmZ8n56d_F26VfjYazKnt2FzxLIiF.dih67HQ6ryRUlxmanp.Cr5Ex15RuNphV6McofCD3qSyOpZbldp4PR1xP1jQt75rWICIuI5l9E9aTEDvLhHdnJEALitMn1xfuI0VdiqGvArjYpmC1nB_85JxUaLtmLrrhsoIOFo6s._MHBcJyUfTQ6Ksv31W4LkryKp154SeEWdUWD.mlxtSSvIOoHjh7Qo2Fw',mdrd: 'ByxHFZzWXqVEI7Fc5Yar2WHR6JKg7jlrZiiBlezt2dc-1789715830-1.2.1.1-yHNqbJdBsiaOh_._GI7MN_PCClAUlcTbJwjZR3hqtpjqglMqUUW6cpRQx_oFydujPKZd1v3np92y4E0qrCNqJ.MXtjSJThJVODMQieGRLCsZYrUfVc7hS.lY7A_kZFVn2QHbgfZP6k9zgoA.GyFLAfpE8O51K_qa046s0wJMYTu0F1cbdBdjeyZr5YqoPcH0v3pVS7p1NIOk9bwe1fQvBkyltLVv8ZWbEh3uAGAEifFCoaEuArqrmH8L1ZTuhBZd',};var a = document.createElement('script');a.nonce = 'PQU0yiBoyz50uG3uDCVdeH';a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a3ce91c57d87cf3b';window._cf_chl_opt.cOgUHash = location.hash === '' && location.href.indexOf('#') !== -1 ? '#' : location.hash;window._cf_chl_opt.cOgUQuery = location.search === '' && location.href.slice(0, location.href.length - window._cf_chl_opt.cOgUHash.length).indexOf('?') !== -1 ? '?' : location.search;if (window.history && window.history.replaceState) {var ogU = location.pathname + window._cf_chl_opt.cOgUQuery + window._cf_chl_opt.cOgUHash;history.replaceState(null, null,"/uuid?__cf_chl_rt_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ"+ window._cf_chl_opt.cOgUHash);a.onload = function() {history.replaceState(null, null, ogU);}}document.getElementsByTagName('head')[0].appendChild(a);}());</script></body></html>@ct.877774.xyz:443?encryption=none&security=tls&sni=us-lax.xhs152.shop&fp=random&type=ws&host=us-lax.xhs152.shop&path=%2Fannouncement%3Fed%3D2048#US-LN
vless://<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=Edge"><meta name="robots" content="noindex,nofollow"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="content-security-policy" content="default-src &#39;none&#39;; script-src &#39;nonce-PQU0yiBoyz50uG3uDCVdeH&#39; &#39;unsafe-eval&#39; https://challenges.cloudflare.com; script-src-attr &#39;none&#39;; style-src &#39;unsafe-inline&#39;; img-src &#39;self&#39; https://challenges.cloudflare.com; connect-src &#39;self&#39; https://challenges.cloudflare.com; frame-src &#39;self&#39; https://challenges.cloudflare.com blob:; child-src &#39;self&#39; https://challenges.cloudflare.com blob:; worker-src blob:; form-action http: https:; base-uri &#39;self&#39;"><style>*{box-sizing:border-box;margin:0;padding:0}html{line-height:1.15;-webkit-text-size-adjust:100%;color:#313131;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"}body{display:flex;flex-direction:column;height:100vh;min-height:100vh}.main-content{margin:8rem auto;padding-left:1.5rem;max-width:60rem}@media (width <= 720px){.main-content{margin-top:4rem}}#challenge-error-text{background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI0IyMEYwMyIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMTMgMTNBMTMuMDE1IDEzLjAxNSAwIDAgMCAxNiAzbTAgMjRhMTEgMTEgMCAxIDEgMTEtMTEgMTEuMDEgMTEuMDEgMCAwIDEtMTEgMTEiLz48cGF0aCBmaWxsPSIjQjIwRjAzIiBkPSJNMTcuMDM4IDE4LjYxNUgxNC44N0wxNC41NjMgOS41aDIuNzgzem0tMS4wODQgMS40MjdxLjY2IDAgMS4wNTcuMzg4LjQwNy4zODkuNDA3Ljk5NCAwIC41OTYtLjQwNy45ODQtLjM5Ny4zOS0xLjA1Ny4zODktLjY1IDAtMS4wNTYtLjM4OS0uMzk4LS4zODktLjM5OC0uOTg0IDAtLjU5Ny4zOTgtLjk4NS40MDYtLjM5NyAxLjA1Ni0uMzk3Ii8+PC9zdmc+");background-repeat:no-repeat;background-size:contain;padding-left:34px}</style><meta http-equiv="refresh" content="360"></head><body><div class="main-wrapper" role="main"><div class="main-content"><noscript><div class="h2"><span id="challenge-error-text">Enable JavaScript and cookies to continue</span></div></noscript></div></div><script nonce="PQU0yiBoyz50uG3uDCVdeH">(function(){window._cf_chl_opt = {cFPWv: 'g',cH: '9Ch63PM31XvycSZls5BxdCQ09e.b21O7Q3bQ1fBZLx4-1789715830-1.2.1.1-GzqlHPCZEJH4AK8uX0leLbClt1FDzzH2OmHxWm8qr3INC7aZyfbATZZ3c6AgowSa',cITimeS: '1789715830',cN: 'PQU0yiBoyz50uG3uDCVdeH',cRay: 'a3ce91c57d87cf3b',cTplB: '0',cTplC:0,cTplO:0,cTplV:5,cType: 'managed',cUPMDTk:"/uuid?__cf_chl_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",cvId: '3',cZone: 'dl.freev2.net',fa:"/uuid?__cf_chl_f_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",md: 'uq7gKkfa46Qna81MkX_I66XWXGfeHpCgb7o8bV2t2Lw-1789715830-1.2.1.1-ZxvPh8iZxSYJKKjYekxP8dIBO1w_sMBDpkzY76xrQUrYIraYMNr7L_FIOcAQb7NUUk3zJJ24SROuzvMXDmPZCnCEgoRYZfPOIuSvP7Mx8BJSjMcUyhK7pHmiqw21euZR9u2XTEA2LtfMX_qVKskWxYbi115XNHgxUy5At75s9jsW_5jW.PygluGYI01_Vz4JzlbpSymE3uTC2NVy2b296UBHaQa6wPq4IZHJgy6rV4Y7HmA9BE0GQNj.9R5IhgpEHA2rdIm6eYZsuggBzZzhLsgxMy9Ij3vL33aB0OOrRRgs4.EfVt3ZR59Se6jSVHBmq0NJLK..oGhI9CZBwXM22p04u02VNRPgDbjrZlBx.wqsnOxd2WkbOobNK.DmUI.AeLef5vVgF7_3bfeOKQ2YWzVewfzO9wYg5A8ksMedDzggXqTl3C0D7fMljNSh7PUiH19sp7pqrdki4K7xA2ATCBbM1pvabfpKQeiMbiFYTV1hHZq7fktZC5kCVQs7_MONIVTOmf49xqKAHd4FwLCShJneGrX0dMCLrrUdvFsweu.TAYe_gSwYS8CAJw8R95u_XkaLwsUbYSn2nNeYAD1n60jDEBctBELQXteNDlP4pYQjdeshb8hhvFExSSE0IoBdvBQG_LdYALLW2.9T5ECUXUDR3x8XgK7Zcak1p8NS_cRBp0XwjVApY8OgmZ8n56d_F26VfjYazKnt2FzxLIiF.dih67HQ6ryRUlxmanp.Cr5Ex15RuNphV6McofCD3qSyOpZbldp4PR1xP1jQt75rWICIuI5l9E9aTEDvLhHdnJEALitMn1xfuI0VdiqGvArjYpmC1nB_85JxUaLtmLrrhsoIOFo6s._MHBcJyUfTQ6Ksv31W4LkryKp154SeEWdUWD.mlxtSSvIOoHjh7Qo2Fw',mdrd: 'ByxHFZzWXqVEI7Fc5Yar2WHR6JKg7jlrZiiBlezt2dc-1789715830-1.2.1.1-yHNqbJdBsiaOh_._GI7MN_PCClAUlcTbJwjZR3hqtpjqglMqUUW6cpRQx_oFydujPKZd1v3np92y4E0qrCNqJ.MXtjSJThJVODMQieGRLCsZYrUfVc7hS.lY7A_kZFVn2QHbgfZP6k9zgoA.GyFLAfpE8O51K_qa046s0wJMYTu0F1cbdBdjeyZr5YqoPcH0v3pVS7p1NIOk9bwe1fQvBkyltLVv8ZWbEh3uAGAEifFCoaEuArqrmH8L1ZTuhBZd',};var a = document.createElement('script');a.nonce = 'PQU0yiBoyz50uG3uDCVdeH';a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a3ce91c57d87cf3b';window._cf_chl_opt.cOgUHash = location.hash === '' && location.href.indexOf('#') !== -1 ? '#' : location.hash;window._cf_chl_opt.cOgUQuery = location.search === '' && location.href.slice(0, location.href.length - window._cf_chl_opt.cOgUHash.length).indexOf('?') !== -1 ? '?' : location.search;if (window.history && window.history.replaceState) {var ogU = location.pathname + window._cf_chl_opt.cOgUQuery + window._cf_chl_opt.cOgUHash;history.replaceState(null, null,"/uuid?__cf_chl_rt_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ"+ window._cf_chl_opt.cOgUHash);a.onload = function() {history.replaceState(null, null, ogU);}}document.getElementsByTagName('head')[0].appendChild(a);}());</script></body></html>@freev2.cloudflare.182682.xyz:443?encryption=none&security=tls&sni=jp-osa.xhs152.shop&fp=random&type=ws&host=jp-osa.xhs152.shop&path=%2Fannouncement%3Fed%3D2048#JP-LN
vless://<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=Edge"><meta name="robots" content="noindex,nofollow"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="content-security-policy" content="default-src &#39;none&#39;; script-src &#39;nonce-PQU0yiBoyz50uG3uDCVdeH&#39; &#39;unsafe-eval&#39; https://challenges.cloudflare.com; script-src-attr &#39;none&#39;; style-src &#39;unsafe-inline&#39;; img-src &#39;self&#39; https://challenges.cloudflare.com; connect-src &#39;self&#39; https://challenges.cloudflare.com; frame-src &#39;self&#39; https://challenges.cloudflare.com blob:; child-src &#39;self&#39; https://challenges.cloudflare.com blob:; worker-src blob:; form-action http: https:; base-uri &#39;self&#39;"><style>*{box-sizing:border-box;margin:0;padding:0}html{line-height:1.15;-webkit-text-size-adjust:100%;color:#313131;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"}body{display:flex;flex-direction:column;height:100vh;min-height:100vh}.main-content{margin:8rem auto;padding-left:1.5rem;max-width:60rem}@media (width <= 720px){.main-content{margin-top:4rem}}#challenge-error-text{background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI0IyMEYwMyIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMTMgMTNBMTMuMDE1IDEzLjAxNSAwIDAgMCAxNiAzbTAgMjRhMTEgMTEgMCAxIDEgMTEtMTEgMTEuMDEgMTEuMDEgMCAwIDEtMTEgMTEiLz48cGF0aCBmaWxsPSIjQjIwRjAzIiBkPSJNMTcuMDM4IDE4LjYxNUgxNC44N0wxNC41NjMgOS41aDIuNzgzem0tMS4wODQgMS40MjdxLjY2IDAgMS4wNTcuMzg4LjQwNy4zODkuNDA3Ljk5NCAwIC41OTYtLjQwNy45ODQtLjM5Ny4zOS0xLjA1Ny4zODktLjY1IDAtMS4wNTYtLjM4OS0uMzk4LS4zODktLjM5OC0uOTg0IDAtLjU5Ny4zOTgtLjk4NS40MDYtLjM5NyAxLjA1Ni0uMzk3Ii8+PC9zdmc+");background-repeat:no-repeat;background-size:contain;padding-left:34px}</style><meta http-equiv="refresh" content="360"></head><body><div class="main-wrapper" role="main"><div class="main-content"><noscript><div class="h2"><span id="challenge-error-text">Enable JavaScript and cookies to continue</span></div></noscript></div></div><script nonce="PQU0yiBoyz50uG3uDCVdeH">(function(){window._cf_chl_opt = {cFPWv: 'g',cH: '9Ch63PM31XvycSZls5BxdCQ09e.b21O7Q3bQ1fBZLx4-1789715830-1.2.1.1-GzqlHPCZEJH4AK8uX0leLbClt1FDzzH2OmHxWm8qr3INC7aZyfbATZZ3c6AgowSa',cITimeS: '1789715830',cN: 'PQU0yiBoyz50uG3uDCVdeH',cRay: 'a3ce91c57d87cf3b',cTplB: '0',cTplC:0,cTplO:0,cTplV:5,cType: 'managed',cUPMDTk:"/uuid?__cf_chl_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",cvId: '3',cZone: 'dl.freev2.net',fa:"/uuid?__cf_chl_f_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",md: 'uq7gKkfa46Qna81MkX_I66XWXGfeHpCgb7o8bV2t2Lw-1789715830-1.2.1.1-ZxvPh8iZxSYJKKjYekxP8dIBO1w_sMBDpkzY76xrQUrYIraYMNr7L_FIOcAQb7NUUk3zJJ24SROuzvMXDmPZCnCEgoRYZfPOIuSvP7Mx8BJSjMcUyhK7pHmiqw21euZR9u2XTEA2LtfMX_qVKskWxYbi115XNHgxUy5At75s9jsW_5jW.PygluGYI01_Vz4JzlbpSymE3uTC2NVy2b296UBHaQa6wPq4IZHJgy6rV4Y7HmA9BE0GQNj.9R5IhgpEHA2rdIm6eYZsuggBzZzhLsgxMy9Ij3vL33aB0OOrRRgs4.EfVt3ZR59Se6jSVHBmq0NJLK..oGhI9CZBwXM22p04u02VNRPgDbjrZlBx.wqsnOxd2WkbOobNK.DmUI.AeLef5vVgF7_3bfeOKQ2YWzVewfzO9wYg5A8ksMedDzggXqTl3C0D7fMljNSh7PUiH19sp7pqrdki4K7xA2ATCBbM1pvabfpKQeiMbiFYTV1hHZq7fktZC5kCVQs7_MONIVTOmf49xqKAHd4FwLCShJneGrX0dMCLrrUdvFsweu.TAYe_gSwYS8CAJw8R95u_XkaLwsUbYSn2nNeYAD1n60jDEBctBELQXteNDlP4pYQjdeshb8hhvFExSSE0IoBdvBQG_LdYALLW2.9T5ECUXUDR3x8XgK7Zcak1p8NS_cRBp0XwjVApY8OgmZ8n56d_F26VfjYazKnt2FzxLIiF.dih67HQ6ryRUlxmanp.Cr5Ex15RuNphV6McofCD3qSyOpZbldp4PR1xP1jQt75rWICIuI5l9E9aTEDvLhHdnJEALitMn1xfuI0VdiqGvArjYpmC1nB_85JxUaLtmLrrhsoIOFo6s._MHBcJyUfTQ6Ksv31W4LkryKp154SeEWdUWD.mlxtSSvIOoHjh7Qo2Fw',mdrd: 'ByxHFZzWXqVEI7Fc5Yar2WHR6JKg7jlrZiiBlezt2dc-1789715830-1.2.1.1-yHNqbJdBsiaOh_._GI7MN_PCClAUlcTbJwjZR3hqtpjqglMqUUW6cpRQx_oFydujPKZd1v3np92y4E0qrCNqJ.MXtjSJThJVODMQieGRLCsZYrUfVc7hS.lY7A_kZFVn2QHbgfZP6k9zgoA.GyFLAfpE8O51K_qa046s0wJMYTu0F1cbdBdjeyZr5YqoPcH0v3pVS7p1NIOk9bwe1fQvBkyltLVv8ZWbEh3uAGAEifFCoaEuArqrmH8L1ZTuhBZd',};var a = document.createElement('script');a.nonce = 'PQU0yiBoyz50uG3uDCVdeH';a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a3ce91c57d87cf3b';window._cf_chl_opt.cOgUHash = location.hash === '' && location.href.indexOf('#') !== -1 ? '#' : location.hash;window._cf_chl_opt.cOgUQuery = location.search === '' && location.href.slice(0, location.href.length - window._cf_chl_opt.cOgUHash.length).indexOf('?') !== -1 ? '?' : location.search;if (window.history && window.history.replaceState) {var ogU = location.pathname + window._cf_chl_opt.cOgUQuery + window._cf_chl_opt.cOgUHash;history.replaceState(null, null,"/uuid?__cf_chl_rt_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ"+ window._cf_chl_opt.cOgUHash);a.onload = function() {history.replaceState(null, null, ogU);}}document.getElementsByTagName('head')[0].appendChild(a);}());</script></body></html>@freev2.cloudflare.182682.xyz:443?encryption=none&security=tls&sni=nl-ams.xhs152.shop&fp=random&type=ws&host=nl-ams.xhs152.shop&path=%2Fannouncement%3Fed%3D2048#NL-LN
vless://<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=Edge"><meta name="robots" content="noindex,nofollow"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="content-security-policy" content="default-src &#39;none&#39;; script-src &#39;nonce-PQU0yiBoyz50uG3uDCVdeH&#39; &#39;unsafe-eval&#39; https://challenges.cloudflare.com; script-src-attr &#39;none&#39;; style-src &#39;unsafe-inline&#39;; img-src &#39;self&#39; https://challenges.cloudflare.com; connect-src &#39;self&#39; https://challenges.cloudflare.com; frame-src &#39;self&#39; https://challenges.cloudflare.com blob:; child-src &#39;self&#39; https://challenges.cloudflare.com blob:; worker-src blob:; form-action http: https:; base-uri &#39;self&#39;"><style>*{box-sizing:border-box;margin:0;padding:0}html{line-height:1.15;-webkit-text-size-adjust:100%;color:#313131;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"}body{display:flex;flex-direction:column;height:100vh;min-height:100vh}.main-content{margin:8rem auto;padding-left:1.5rem;max-width:60rem}@media (width <= 720px){.main-content{margin-top:4rem}}#challenge-error-text{background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI0IyMEYwMyIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMTMgMTNBMTMuMDE1IDEzLjAxNSAwIDAgMCAxNiAzbTAgMjRhMTEgMTEgMCAxIDEgMTEtMTEgMTEuMDEgMTEuMDEgMCAwIDEtMTEgMTEiLz48cGF0aCBmaWxsPSIjQjIwRjAzIiBkPSJNMTcuMDM4IDE4LjYxNUgxNC44N0wxNC41NjMgOS41aDIuNzgzem0tMS4wODQgMS40MjdxLjY2IDAgMS4wNTcuMzg4LjQwNy4zODkuNDA3Ljk5NCAwIC41OTYtLjQwNy45ODQtLjM5Ny4zOS0xLjA1Ny4zODktLjY1IDAtMS4wNTYtLjM4OS0uMzk4LS4zODktLjM5OC0uOTg0IDAtLjU5Ny4zOTgtLjk4NS40MDYtLjM5NyAxLjA1Ni0uMzk3Ii8+PC9zdmc+");background-repeat:no-repeat;background-size:contain;padding-left:34px}</style><meta http-equiv="refresh" content="360"></head><body><div class="main-wrapper" role="main"><div class="main-content"><noscript><div class="h2"><span id="challenge-error-text">Enable JavaScript and cookies to continue</span></div></noscript></div></div><script nonce="PQU0yiBoyz50uG3uDCVdeH">(function(){window._cf_chl_opt = {cFPWv: 'g',cH: '9Ch63PM31XvycSZls5BxdCQ09e.b21O7Q3bQ1fBZLx4-1789715830-1.2.1.1-GzqlHPCZEJH4AK8uX0leLbClt1FDzzH2OmHxWm8qr3INC7aZyfbATZZ3c6AgowSa',cITimeS: '1789715830',cN: 'PQU0yiBoyz50uG3uDCVdeH',cRay: 'a3ce91c57d87cf3b',cTplB: '0',cTplC:0,cTplO:0,cTplV:5,cType: 'managed',cUPMDTk:"/uuid?__cf_chl_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",cvId: '3',cZone: 'dl.freev2.net',fa:"/uuid?__cf_chl_f_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",md: 'uq7gKkfa46Qna81MkX_I66XWXGfeHpCgb7o8bV2t2Lw-1789715830-1.2.1.1-ZxvPh8iZxSYJKKjYekxP8dIBO1w_sMBDpkzY76xrQUrYIraYMNr7L_FIOcAQb7NUUk3zJJ24SROuzvMXDmPZCnCEgoRYZfPOIuSvP7Mx8BJSjMcUyhK7pHmiqw21euZR9u2XTEA2LtfMX_qVKskWxYbi115XNHgxUy5At75s9jsW_5jW.PygluGYI01_Vz4JzlbpSymE3uTC2NVy2b296UBHaQa6wPq4IZHJgy6rV4Y7HmA9BE0GQNj.9R5IhgpEHA2rdIm6eYZsuggBzZzhLsgxMy9Ij3vL33aB0OOrRRgs4.EfVt3ZR59Se6jSVHBmq0NJLK..oGhI9CZBwXM22p04u02VNRPgDbjrZlBx.wqsnOxd2WkbOobNK.DmUI.AeLef5vVgF7_3bfeOKQ2YWzVewfzO9wYg5A8ksMedDzggXqTl3C0D7fMljNSh7PUiH19sp7pqrdki4K7xA2ATCBbM1pvabfpKQeiMbiFYTV1hHZq7fktZC5kCVQs7_MONIVTOmf49xqKAHd4FwLCShJneGrX0dMCLrrUdvFsweu.TAYe_gSwYS8CAJw8R95u_XkaLwsUbYSn2nNeYAD1n60jDEBctBELQXteNDlP4pYQjdeshb8hhvFExSSE0IoBdvBQG_LdYALLW2.9T5ECUXUDR3x8XgK7Zcak1p8NS_cRBp0XwjVApY8OgmZ8n56d_F26VfjYazKnt2FzxLIiF.dih67HQ6ryRUlxmanp.Cr5Ex15RuNphV6McofCD3qSyOpZbldp4PR1xP1jQt75rWICIuI5l9E9aTEDvLhHdnJEALitMn1xfuI0VdiqGvArjYpmC1nB_85JxUaLtmLrrhsoIOFo6s._MHBcJyUfTQ6Ksv31W4LkryKp154SeEWdUWD.mlxtSSvIOoHjh7Qo2Fw',mdrd: 'ByxHFZzWXqVEI7Fc5Yar2WHR6JKg7jlrZiiBlezt2dc-1789715830-1.2.1.1-yHNqbJdBsiaOh_._GI7MN_PCClAUlcTbJwjZR3hqtpjqglMqUUW6cpRQx_oFydujPKZd1v3np92y4E0qrCNqJ.MXtjSJThJVODMQieGRLCsZYrUfVc7hS.lY7A_kZFVn2QHbgfZP6k9zgoA.GyFLAfpE8O51K_qa046s0wJMYTu0F1cbdBdjeyZr5YqoPcH0v3pVS7p1NIOk9bwe1fQvBkyltLVv8ZWbEh3uAGAEifFCoaEuArqrmH8L1ZTuhBZd',};var a = document.createElement('script');a.nonce = 'PQU0yiBoyz50uG3uDCVdeH';a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a3ce91c57d87cf3b';window._cf_chl_opt.cOgUHash = location.hash === '' && location.href.indexOf('#') !== -1 ? '#' : location.hash;window._cf_chl_opt.cOgUQuery = location.search === '' && location.href.slice(0, location.href.length - window._cf_chl_opt.cOgUHash.length).indexOf('?') !== -1 ? '?' : location.search;if (window.history && window.history.replaceState) {var ogU = location.pathname + window._cf_chl_opt.cOgUQuery + window._cf_chl_opt.cOgUHash;history.replaceState(null, null,"/uuid?__cf_chl_rt_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ"+ window._cf_chl_opt.cOgUHash);a.onload = function() {history.replaceState(null, null, ogU);}}document.getElementsByTagName('head')[0].appendChild(a);}());</script></body></html>@ct.877774.xyz:443?encryption=none&security=tls&sni=ap-south.xhs152.shop&fp=random&type=ws&host=ap-south.xhs152.shop&path=%2Fannouncement%3Fed%3D2048#SG-LN
vless://<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=Edge"><meta name="robots" content="noindex,nofollow"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="content-security-policy" content="default-src &#39;none&#39;; script-src &#39;nonce-PQU0yiBoyz50uG3uDCVdeH&#39; &#39;unsafe-eval&#39; https://challenges.cloudflare.com; script-src-attr &#39;none&#39;; style-src &#39;unsafe-inline&#39;; img-src &#39;self&#39; https://challenges.cloudflare.com; connect-src &#39;self&#39; https://challenges.cloudflare.com; frame-src &#39;self&#39; https://challenges.cloudflare.com blob:; child-src &#39;self&#39; https://challenges.cloudflare.com blob:; worker-src blob:; form-action http: https:; base-uri &#39;self&#39;"><style>*{box-sizing:border-box;margin:0;padding:0}html{line-height:1.15;-webkit-text-size-adjust:100%;color:#313131;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"}body{display:flex;flex-direction:column;height:100vh;min-height:100vh}.main-content{margin:8rem auto;padding-left:1.5rem;max-width:60rem}@media (width <= 720px){.main-content{margin-top:4rem}}#challenge-error-text{background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI0IyMEYwMyIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMTMgMTNBMTMuMDE1IDEzLjAxNSAwIDAgMCAxNiAzbTAgMjRhMTEgMTEgMCAxIDEgMTEtMTEgMTEuMDEgMTEuMDEgMCAwIDEtMTEgMTEiLz48cGF0aCBmaWxsPSIjQjIwRjAzIiBkPSJNMTcuMDM4IDE4LjYxNUgxNC44N0wxNC41NjMgOS41aDIuNzgzem0tMS4wODQgMS40MjdxLjY2IDAgMS4wNTcuMzg4LjQwNy4zODkuNDA3Ljk5NCAwIC41OTYtLjQwNy45ODQtLjM5Ny4zOS0xLjA1Ny4zODktLjY1IDAtMS4wNTYtLjM4OS0uMzk4LS4zODktLjM5OC0uOTg0IDAtLjU5Ny4zOTgtLjk4NS40MDYtLjM5NyAxLjA1Ni0uMzk3Ii8+PC9zdmc+");background-repeat:no-repeat;background-size:contain;padding-left:34px}</style><meta http-equiv="refresh" content="360"></head><body><div class="main-wrapper" role="main"><div class="main-content"><noscript><div class="h2"><span id="challenge-error-text">Enable JavaScript and cookies to continue</span></div></noscript></div></div><script nonce="PQU0yiBoyz50uG3uDCVdeH">(function(){window._cf_chl_opt = {cFPWv: 'g',cH: '9Ch63PM31XvycSZls5BxdCQ09e.b21O7Q3bQ1fBZLx4-1789715830-1.2.1.1-GzqlHPCZEJH4AK8uX0leLbClt1FDzzH2OmHxWm8qr3INC7aZyfbATZZ3c6AgowSa',cITimeS: '1789715830',cN: 'PQU0yiBoyz50uG3uDCVdeH',cRay: 'a3ce91c57d87cf3b',cTplB: '0',cTplC:0,cTplO:0,cTplV:5,cType: 'managed',cUPMDTk:"/uuid?__cf_chl_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",cvId: '3',cZone: 'dl.freev2.net',fa:"/uuid?__cf_chl_f_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",md: 'uq7gKkfa46Qna81MkX_I66XWXGfeHpCgb7o8bV2t2Lw-1789715830-1.2.1.1-ZxvPh8iZxSYJKKjYekxP8dIBO1w_sMBDpkzY76xrQUrYIraYMNr7L_FIOcAQb7NUUk3zJJ24SROuzvMXDmPZCnCEgoRYZfPOIuSvP7Mx8BJSjMcUyhK7pHmiqw21euZR9u2XTEA2LtfMX_qVKskWxYbi115XNHgxUy5At75s9jsW_5jW.PygluGYI01_Vz4JzlbpSymE3uTC2NVy2b296UBHaQa6wPq4IZHJgy6rV4Y7HmA9BE0GQNj.9R5IhgpEHA2rdIm6eYZsuggBzZzhLsgxMy9Ij3vL33aB0OOrRRgs4.EfVt3ZR59Se6jSVHBmq0NJLK..oGhI9CZBwXM22p04u02VNRPgDbjrZlBx.wqsnOxd2WkbOobNK.DmUI.AeLef5vVgF7_3bfeOKQ2YWzVewfzO9wYg5A8ksMedDzggXqTl3C0D7fMljNSh7PUiH19sp7pqrdki4K7xA2ATCBbM1pvabfpKQeiMbiFYTV1hHZq7fktZC5kCVQs7_MONIVTOmf49xqKAHd4FwLCShJneGrX0dMCLrrUdvFsweu.TAYe_gSwYS8CAJw8R95u_XkaLwsUbYSn2nNeYAD1n60jDEBctBELQXteNDlP4pYQjdeshb8hhvFExSSE0IoBdvBQG_LdYALLW2.9T5ECUXUDR3x8XgK7Zcak1p8NS_cRBp0XwjVApY8OgmZ8n56d_F26VfjYazKnt2FzxLIiF.dih67HQ6ryRUlxmanp.Cr5Ex15RuNphV6McofCD3qSyOpZbldp4PR1xP1jQt75rWICIuI5l9E9aTEDvLhHdnJEALitMn1xfuI0VdiqGvArjYpmC1nB_85JxUaLtmLrrhsoIOFo6s._MHBcJyUfTQ6Ksv31W4LkryKp154SeEWdUWD.mlxtSSvIOoHjh7Qo2Fw',mdrd: 'ByxHFZzWXqVEI7Fc5Yar2WHR6JKg7jlrZiiBlezt2dc-1789715830-1.2.1.1-yHNqbJdBsiaOh_._GI7MN_PCClAUlcTbJwjZR3hqtpjqglMqUUW6cpRQx_oFydujPKZd1v3np92y4E0qrCNqJ.MXtjSJThJVODMQieGRLCsZYrUfVc7hS.lY7A_kZFVn2QHbgfZP6k9zgoA.GyFLAfpE8O51K_qa046s0wJMYTu0F1cbdBdjeyZr5YqoPcH0v3pVS7p1NIOk9bwe1fQvBkyltLVv8ZWbEh3uAGAEifFCoaEuArqrmH8L1ZTuhBZd',};var a = document.createElement('script');a.nonce = 'PQU0yiBoyz50uG3uDCVdeH';a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a3ce91c57d87cf3b';window._cf_chl_opt.cOgUHash = location.hash === '' && location.href.indexOf('#') !== -1 ? '#' : location.hash;window._cf_chl_opt.cOgUQuery = location.search === '' && location.href.slice(0, location.href.length - window._cf_chl_opt.cOgUHash.length).indexOf('?') !== -1 ? '?' : location.search;if (window.history && window.history.replaceState) {var ogU = location.pathname + window._cf_chl_opt.cOgUQuery + window._cf_chl_opt.cOgUHash;history.replaceState(null, null,"/uuid?__cf_chl_rt_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ"+ window._cf_chl_opt.cOgUHash);a.onload = function() {history.replaceState(null, null, ogU);}}document.getElementsByTagName('head')[0].appendChild(a);}());</script></body></html>@freev2.cloudflare.182682.xyz:443?encryption=none&security=tls&sni=se-sto.xhs152.shop&fp=random&type=ws&host=se-sto.xhs152.shop&path=%2Fannouncement%3Fed%3D2048#SE-LN
vless://<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=Edge"><meta name="robots" content="noindex,nofollow"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="content-security-policy" content="default-src &#39;none&#39;; script-src &#39;nonce-PQU0yiBoyz50uG3uDCVdeH&#39; &#39;unsafe-eval&#39; https://challenges.cloudflare.com; script-src-attr &#39;none&#39;; style-src &#39;unsafe-inline&#39;; img-src &#39;self&#39; https://challenges.cloudflare.com; connect-src &#39;self&#39; https://challenges.cloudflare.com; frame-src &#39;self&#39; https://challenges.cloudflare.com blob:; child-src &#39;self&#39; https://challenges.cloudflare.com blob:; worker-src blob:; form-action http: https:; base-uri &#39;self&#39;"><style>*{box-sizing:border-box;margin:0;padding:0}html{line-height:1.15;-webkit-text-size-adjust:100%;color:#313131;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"}body{display:flex;flex-direction:column;height:100vh;min-height:100vh}.main-content{margin:8rem auto;padding-left:1.5rem;max-width:60rem}@media (width <= 720px){.main-content{margin-top:4rem}}#challenge-error-text{background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI0IyMEYwMyIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMTMgMTNBMTMuMDE1IDEzLjAxNSAwIDAgMCAxNiAzbTAgMjRhMTEgMTEgMCAxIDEgMTEtMTEgMTEuMDEgMTEuMDEgMCAwIDEtMTEgMTEiLz48cGF0aCBmaWxsPSIjQjIwRjAzIiBkPSJNMTcuMDM4IDE4LjYxNUgxNC44N0wxNC41NjMgOS41aDIuNzgzem0tMS4wODQgMS40MjdxLjY2IDAgMS4wNTcuMzg4LjQwNy4zODkuNDA3Ljk5NCAwIC41OTYtLjQwNy45ODQtLjM5Ny4zOS0xLjA1Ny4zODktLjY1IDAtMS4wNTYtLjM4OS0uMzk4LS4zODktLjM5OC0uOTg0IDAtLjU5Ny4zOTgtLjk4NS40MDYtLjM5NyAxLjA1Ni0uMzk3Ii8+PC9zdmc+");background-repeat:no-repeat;background-size:contain;padding-left:34px}</style><meta http-equiv="refresh" content="360"></head><body><div class="main-wrapper" role="main"><div class="main-content"><noscript><div class="h2"><span id="challenge-error-text">Enable JavaScript and cookies to continue</span></div></noscript></div></div><script nonce="PQU0yiBoyz50uG3uDCVdeH">(function(){window._cf_chl_opt = {cFPWv: 'g',cH: '9Ch63PM31XvycSZls5BxdCQ09e.b21O7Q3bQ1fBZLx4-1789715830-1.2.1.1-GzqlHPCZEJH4AK8uX0leLbClt1FDzzH2OmHxWm8qr3INC7aZyfbATZZ3c6AgowSa',cITimeS: '1789715830',cN: 'PQU0yiBoyz50uG3uDCVdeH',cRay: 'a3ce91c57d87cf3b',cTplB: '0',cTplC:0,cTplO:0,cTplV:5,cType: 'managed',cUPMDTk:"/uuid?__cf_chl_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",cvId: '3',cZone: 'dl.freev2.net',fa:"/uuid?__cf_chl_f_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",md: 'uq7gKkfa46Qna81MkX_I66XWXGfeHpCgb7o8bV2t2Lw-1789715830-1.2.1.1-ZxvPh8iZxSYJKKjYekxP8dIBO1w_sMBDpkzY76xrQUrYIraYMNr7L_FIOcAQb7NUUk3zJJ24SROuzvMXDmPZCnCEgoRYZfPOIuSvP7Mx8BJSjMcUyhK7pHmiqw21euZR9u2XTEA2LtfMX_qVKskWxYbi115XNHgxUy5At75s9jsW_5jW.PygluGYI01_Vz4JzlbpSymE3uTC2NVy2b296UBHaQa6wPq4IZHJgy6rV4Y7HmA9BE0GQNj.9R5IhgpEHA2rdIm6eYZsuggBzZzhLsgxMy9Ij3vL33aB0OOrRRgs4.EfVt3ZR59Se6jSVHBmq0NJLK..oGhI9CZBwXM22p04u02VNRPgDbjrZlBx.wqsnOxd2WkbOobNK.DmUI.AeLef5vVgF7_3bfeOKQ2YWzVewfzO9wYg5A8ksMedDzggXqTl3C0D7fMljNSh7PUiH19sp7pqrdki4K7xA2ATCBbM1pvabfpKQeiMbiFYTV1hHZq7fktZC5kCVQs7_MONIVTOmf49xqKAHd4FwLCShJneGrX0dMCLrrUdvFsweu.TAYe_gSwYS8CAJw8R95u_XkaLwsUbYSn2nNeYAD1n60jDEBctBELQXteNDlP4pYQjdeshb8hhvFExSSE0IoBdvBQG_LdYALLW2.9T5ECUXUDR3x8XgK7Zcak1p8NS_cRBp0XwjVApY8OgmZ8n56d_F26VfjYazKnt2FzxLIiF.dih67HQ6ryRUlxmanp.Cr5Ex15RuNphV6McofCD3qSyOpZbldp4PR1xP1jQt75rWICIuI5l9E9aTEDvLhHdnJEALitMn1xfuI0VdiqGvArjYpmC1nB_85JxUaLtmLrrhsoIOFo6s._MHBcJyUfTQ6Ksv31W4LkryKp154SeEWdUWD.mlxtSSvIOoHjh7Qo2Fw',mdrd: 'ByxHFZzWXqVEI7Fc5Yar2WHR6JKg7jlrZiiBlezt2dc-1789715830-1.2.1.1-yHNqbJdBsiaOh_._GI7MN_PCClAUlcTbJwjZR3hqtpjqglMqUUW6cpRQx_oFydujPKZd1v3np92y4E0qrCNqJ.MXtjSJThJVODMQieGRLCsZYrUfVc7hS.lY7A_kZFVn2QHbgfZP6k9zgoA.GyFLAfpE8O51K_qa046s0wJMYTu0F1cbdBdjeyZr5YqoPcH0v3pVS7p1NIOk9bwe1fQvBkyltLVv8ZWbEh3uAGAEifFCoaEuArqrmH8L1ZTuhBZd',};var a = document.createElement('script');a.nonce = 'PQU0yiBoyz50uG3uDCVdeH';a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a3ce91c57d87cf3b';window._cf_chl_opt.cOgUHash = location.hash === '' && location.href.indexOf('#') !== -1 ? '#' : location.hash;window._cf_chl_opt.cOgUQuery = location.search === '' && location.href.slice(0, location.href.length - window._cf_chl_opt.cOgUHash.length).indexOf('?') !== -1 ? '?' : location.search;if (window.history && window.history.replaceState) {var ogU = location.pathname + window._cf_chl_opt.cOgUQuery + window._cf_chl_opt.cOgUHash;history.replaceState(null, null,"/uuid?__cf_chl_rt_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ"+ window._cf_chl_opt.cOgUHash);a.onload = function() {history.replaceState(null, null, ogU);}}document.getElementsByTagName('head')[0].appendChild(a);}());</script></body></html>@ct.877774.xyz:443?encryption=none&security=tls&sni=br-gru.xhs152.shop&fp=random&type=ws&host=br-gru.xhs152.shop&path=%2Fannouncement%3Fed%3D2048#BR-LN
vless://<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=Edge"><meta name="robots" content="noindex,nofollow"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="content-security-policy" content="default-src &#39;none&#39;; script-src &#39;nonce-PQU0yiBoyz50uG3uDCVdeH&#39; &#39;unsafe-eval&#39; https://challenges.cloudflare.com; script-src-attr &#39;none&#39;; style-src &#39;unsafe-inline&#39;; img-src &#39;self&#39; https://challenges.cloudflare.com; connect-src &#39;self&#39; https://challenges.cloudflare.com; frame-src &#39;self&#39; https://challenges.cloudflare.com blob:; child-src &#39;self&#39; https://challenges.cloudflare.com blob:; worker-src blob:; form-action http: https:; base-uri &#39;self&#39;"><style>*{box-sizing:border-box;margin:0;padding:0}html{line-height:1.15;-webkit-text-size-adjust:100%;color:#313131;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"}body{display:flex;flex-direction:column;height:100vh;min-height:100vh}.main-content{margin:8rem auto;padding-left:1.5rem;max-width:60rem}@media (width <= 720px){.main-content{margin-top:4rem}}#challenge-error-text{background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI0IyMEYwMyIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMTMgMTNBMTMuMDE1IDEzLjAxNSAwIDAgMCAxNiAzbTAgMjRhMTEgMTEgMCAxIDEgMTEtMTEgMTEuMDEgMTEuMDEgMCAwIDEtMTEgMTEiLz48cGF0aCBmaWxsPSIjQjIwRjAzIiBkPSJNMTcuMDM4IDE4LjYxNUgxNC44N0wxNC41NjMgOS41aDIuNzgzem0tMS4wODQgMS40MjdxLjY2IDAgMS4wNTcuMzg4LjQwNy4zODkuNDA3Ljk5NCAwIC41OTYtLjQwNy45ODQtLjM5Ny4zOS0xLjA1Ny4zODktLjY1IDAtMS4wNTYtLjM4OS0uMzk4LS4zODktLjM5OC0uOTg0IDAtLjU5Ny4zOTgtLjk4NS40MDYtLjM5NyAxLjA1Ni0uMzk3Ii8+PC9zdmc+");background-repeat:no-repeat;background-size:contain;padding-left:34px}</style><meta http-equiv="refresh" content="360"></head><body><div class="main-wrapper" role="main"><div class="main-content"><noscript><div class="h2"><span id="challenge-error-text">Enable JavaScript and cookies to continue</span></div></noscript></div></div><script nonce="PQU0yiBoyz50uG3uDCVdeH">(function(){window._cf_chl_opt = {cFPWv: 'g',cH: '9Ch63PM31XvycSZls5BxdCQ09e.b21O7Q3bQ1fBZLx4-1789715830-1.2.1.1-GzqlHPCZEJH4AK8uX0leLbClt1FDzzH2OmHxWm8qr3INC7aZyfbATZZ3c6AgowSa',cITimeS: '1789715830',cN: 'PQU0yiBoyz50uG3uDCVdeH',cRay: 'a3ce91c57d87cf3b',cTplB: '0',cTplC:0,cTplO:0,cTplV:5,cType: 'managed',cUPMDTk:"/uuid?__cf_chl_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",cvId: '3',cZone: 'dl.freev2.net',fa:"/uuid?__cf_chl_f_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",md: 'uq7gKkfa46Qna81MkX_I66XWXGfeHpCgb7o8bV2t2Lw-1789715830-1.2.1.1-ZxvPh8iZxSYJKKjYekxP8dIBO1w_sMBDpkzY76xrQUrYIraYMNr7L_FIOcAQb7NUUk3zJJ24SROuzvMXDmPZCnCEgoRYZfPOIuSvP7Mx8BJSjMcUyhK7pHmiqw21euZR9u2XTEA2LtfMX_qVKskWxYbi115XNHgxUy5At75s9jsW_5jW.PygluGYI01_Vz4JzlbpSymE3uTC2NVy2b296UBHaQa6wPq4IZHJgy6rV4Y7HmA9BE0GQNj.9R5IhgpEHA2rdIm6eYZsuggBzZzhLsgxMy9Ij3vL33aB0OOrRRgs4.EfVt3ZR59Se6jSVHBmq0NJLK..oGhI9CZBwXM22p04u02VNRPgDbjrZlBx.wqsnOxd2WkbOobNK.DmUI.AeLef5vVgF7_3bfeOKQ2YWzVewfzO9wYg5A8ksMedDzggXqTl3C0D7fMljNSh7PUiH19sp7pqrdki4K7xA2ATCBbM1pvabfpKQeiMbiFYTV1hHZq7fktZC5kCVQs7_MONIVTOmf49xqKAHd4FwLCShJneGrX0dMCLrrUdvFsweu.TAYe_gSwYS8CAJw8R95u_XkaLwsUbYSn2nNeYAD1n60jDEBctBELQXteNDlP4pYQjdeshb8hhvFExSSE0IoBdvBQG_LdYALLW2.9T5ECUXUDR3x8XgK7Zcak1p8NS_cRBp0XwjVApY8OgmZ8n56d_F26VfjYazKnt2FzxLIiF.dih67HQ6ryRUlxmanp.Cr5Ex15RuNphV6McofCD3qSyOpZbldp4PR1xP1jQt75rWICIuI5l9E9aTEDvLhHdnJEALitMn1xfuI0VdiqGvArjYpmC1nB_85JxUaLtmLrrhsoIOFo6s._MHBcJyUfTQ6Ksv31W4LkryKp154SeEWdUWD.mlxtSSvIOoHjh7Qo2Fw',mdrd: 'ByxHFZzWXqVEI7Fc5Yar2WHR6JKg7jlrZiiBlezt2dc-1789715830-1.2.1.1-yHNqbJdBsiaOh_._GI7MN_PCClAUlcTbJwjZR3hqtpjqglMqUUW6cpRQx_oFydujPKZd1v3np92y4E0qrCNqJ.MXtjSJThJVODMQieGRLCsZYrUfVc7hS.lY7A_kZFVn2QHbgfZP6k9zgoA.GyFLAfpE8O51K_qa046s0wJMYTu0F1cbdBdjeyZr5YqoPcH0v3pVS7p1NIOk9bwe1fQvBkyltLVv8ZWbEh3uAGAEifFCoaEuArqrmH8L1ZTuhBZd',};var a = document.createElement('script');a.nonce = 'PQU0yiBoyz50uG3uDCVdeH';a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a3ce91c57d87cf3b';window._cf_chl_opt.cOgUHash = location.hash === '' && location.href.indexOf('#') !== -1 ? '#' : location.hash;window._cf_chl_opt.cOgUQuery = location.search === '' && location.href.slice(0, location.href.length - window._cf_chl_opt.cOgUHash.length).indexOf('?') !== -1 ? '?' : location.search;if (window.history && window.history.replaceState) {var ogU = location.pathname + window._cf_chl_opt.cOgUQuery + window._cf_chl_opt.cOgUHash;history.replaceState(null, null,"/uuid?__cf_chl_rt_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ"+ window._cf_chl_opt.cOgUHash);a.onload = function() {history.replaceState(null, null, ogU);}}document.getElementsByTagName('head')[0].appendChild(a);}());</script></body></html>@freev2.cloudflare.182682.xyz:443?encryption=none&security=tls&sni=it-mil.xhs152.shop&fp=random&type=ws&host=it-mil.xhs152.shop&path=%2Fannouncement%3Fed%3D2048#IT-LN
vless://<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=Edge"><meta name="robots" content="noindex,nofollow"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="content-security-policy" content="default-src &#39;none&#39;; script-src &#39;nonce-PQU0yiBoyz50uG3uDCVdeH&#39; &#39;unsafe-eval&#39; https://challenges.cloudflare.com; script-src-attr &#39;none&#39;; style-src &#39;unsafe-inline&#39;; img-src &#39;self&#39; https://challenges.cloudflare.com; connect-src &#39;self&#39; https://challenges.cloudflare.com; frame-src &#39;self&#39; https://challenges.cloudflare.com blob:; child-src &#39;self&#39; https://challenges.cloudflare.com blob:; worker-src blob:; form-action http: https:; base-uri &#39;self&#39;"><style>*{box-sizing:border-box;margin:0;padding:0}html{line-height:1.15;-webkit-text-size-adjust:100%;color:#313131;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"}body{display:flex;flex-direction:column;height:100vh;min-height:100vh}.main-content{margin:8rem auto;padding-left:1.5rem;max-width:60rem}@media (width <= 720px){.main-content{margin-top:4rem}}#challenge-error-text{background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI0IyMEYwMyIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMTMgMTNBMTMuMDE1IDEzLjAxNSAwIDAgMCAxNiAzbTAgMjRhMTEgMTEgMCAxIDEgMTEtMTEgMTEuMDEgMTEuMDEgMCAwIDEtMTEgMTEiLz48cGF0aCBmaWxsPSIjQjIwRjAzIiBkPSJNMTcuMDM4IDE4LjYxNUgxNC44N0wxNC41NjMgOS41aDIuNzgzem0tMS4wODQgMS40MjdxLjY2IDAgMS4wNTcuMzg4LjQwNy4zODkuNDA3Ljk5NCAwIC41OTYtLjQwNy45ODQtLjM5Ny4zOS0xLjA1Ny4zODktLjY1IDAtMS4wNTYtLjM4OS0uMzk4LS4zODktLjM5OC0uOTg0IDAtLjU5Ny4zOTgtLjk4NS40MDYtLjM5NyAxLjA1Ni0uMzk3Ii8+PC9zdmc+");background-repeat:no-repeat;background-size:contain;padding-left:34px}</style><meta http-equiv="refresh" content="360"></head><body><div class="main-wrapper" role="main"><div class="main-content"><noscript><div class="h2"><span id="challenge-error-text">Enable JavaScript and cookies to continue</span></div></noscript></div></div><script nonce="PQU0yiBoyz50uG3uDCVdeH">(function(){window._cf_chl_opt = {cFPWv: 'g',cH: '9Ch63PM31XvycSZls5BxdCQ09e.b21O7Q3bQ1fBZLx4-1789715830-1.2.1.1-GzqlHPCZEJH4AK8uX0leLbClt1FDzzH2OmHxWm8qr3INC7aZyfbATZZ3c6AgowSa',cITimeS: '1789715830',cN: 'PQU0yiBoyz50uG3uDCVdeH',cRay: 'a3ce91c57d87cf3b',cTplB: '0',cTplC:0,cTplO:0,cTplV:5,cType: 'managed',cUPMDTk:"/uuid?__cf_chl_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",cvId: '3',cZone: 'dl.freev2.net',fa:"/uuid?__cf_chl_f_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ",md: 'uq7gKkfa46Qna81MkX_I66XWXGfeHpCgb7o8bV2t2Lw-1789715830-1.2.1.1-ZxvPh8iZxSYJKKjYekxP8dIBO1w_sMBDpkzY76xrQUrYIraYMNr7L_FIOcAQb7NUUk3zJJ24SROuzvMXDmPZCnCEgoRYZfPOIuSvP7Mx8BJSjMcUyhK7pHmiqw21euZR9u2XTEA2LtfMX_qVKskWxYbi115XNHgxUy5At75s9jsW_5jW.PygluGYI01_Vz4JzlbpSymE3uTC2NVy2b296UBHaQa6wPq4IZHJgy6rV4Y7HmA9BE0GQNj.9R5IhgpEHA2rdIm6eYZsuggBzZzhLsgxMy9Ij3vL33aB0OOrRRgs4.EfVt3ZR59Se6jSVHBmq0NJLK..oGhI9CZBwXM22p04u02VNRPgDbjrZlBx.wqsnOxd2WkbOobNK.DmUI.AeLef5vVgF7_3bfeOKQ2YWzVewfzO9wYg5A8ksMedDzggXqTl3C0D7fMljNSh7PUiH19sp7pqrdki4K7xA2ATCBbM1pvabfpKQeiMbiFYTV1hHZq7fktZC5kCVQs7_MONIVTOmf49xqKAHd4FwLCShJneGrX0dMCLrrUdvFsweu.TAYe_gSwYS8CAJw8R95u_XkaLwsUbYSn2nNeYAD1n60jDEBctBELQXteNDlP4pYQjdeshb8hhvFExSSE0IoBdvBQG_LdYALLW2.9T5ECUXUDR3x8XgK7Zcak1p8NS_cRBp0XwjVApY8OgmZ8n56d_F26VfjYazKnt2FzxLIiF.dih67HQ6ryRUlxmanp.Cr5Ex15RuNphV6McofCD3qSyOpZbldp4PR1xP1jQt75rWICIuI5l9E9aTEDvLhHdnJEALitMn1xfuI0VdiqGvArjYpmC1nB_85JxUaLtmLrrhsoIOFo6s._MHBcJyUfTQ6Ksv31W4LkryKp154SeEWdUWD.mlxtSSvIOoHjh7Qo2Fw',mdrd: 'ByxHFZzWXqVEI7Fc5Yar2WHR6JKg7jlrZiiBlezt2dc-1789715830-1.2.1.1-yHNqbJdBsiaOh_._GI7MN_PCClAUlcTbJwjZR3hqtpjqglMqUUW6cpRQx_oFydujPKZd1v3np92y4E0qrCNqJ.MXtjSJThJVODMQieGRLCsZYrUfVc7hS.lY7A_kZFVn2QHbgfZP6k9zgoA.GyFLAfpE8O51K_qa046s0wJMYTu0F1cbdBdjeyZr5YqoPcH0v3pVS7p1NIOk9bwe1fQvBkyltLVv8ZWbEh3uAGAEifFCoaEuArqrmH8L1ZTuhBZd',};var a = document.createElement('script');a.nonce = 'PQU0yiBoyz50uG3uDCVdeH';a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a3ce91c57d87cf3b';window._cf_chl_opt.cOgUHash = location.hash === '' && location.href.indexOf('#') !== -1 ? '#' : location.hash;window._cf_chl_opt.cOgUQuery = location.search === '' && location.href.slice(0, location.href.length - window._cf_chl_opt.cOgUHash.length).indexOf('?') !== -1 ? '?' : location.search;if (window.history && window.history.replaceState) {var ogU = location.pathname + window._cf_chl_opt.cOgUQuery + window._cf_chl_opt.cOgUHash;history.replaceState(null, null,"/uuid?__cf_chl_rt_tk=ENTGqlxENzFQdEyX61JhJGmW3SdzJGkGAGYbmW_4kEw-1789715830-1.0.1.1-kGE73o3_NJBEMzr3y21SP.2ih1tg1O2MQ806BQTV4IQ"+ window._cf_chl_opt.cOgUHash);a.onload = function() {history.replaceState(null, null, ogU);}}document.getElementsByTagName('head')[0].appendChild(a);}());</script></body></html>@freev2.cloudflare.182682.xyz:443?encryption=none&security=tls&sni=eu-central.xhs152.shop&fp=random&type=ws&host=eu-central.xhs152.shop&path=%2Fannouncement%3Fed%3D2048#DE-LN