trojan://wkmY1R4EcP@45.76.47.77:443?security=tls&headerType=none&fp=chrome&type=tcp&sni=google.com#US🇺🇸 | google.com-443 | 29.29ms
trojan://trojan@162.159.152.4:8443?path=%2F%3Fed&security=tls&insecure=0&host=azadnet-f03.pages.dev&fp=chrome&type=ws&allowInsecure=0&sni=azadnet-f03.pages.dev#RELAY🚩 | azadnet-f03.pages.dev-8443 | 73.74ms
trojan://tg-dns68@162.159.153.9:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 427.89ms
trojan://tg-dns68@162.159.153.86:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 10.59ms
trojan://tg-dns68@162.159.153.75:443?security=tls&type=ws&sni=vip.putata.eu.org&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 7.06ms
trojan://tg-dns68@162.159.153.67:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 10.81ms
trojan://tg-dns68@162.159.153.31:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 9.62ms
trojan://tg-dns68@162.159.153.216:443?security=tls&type=ws&sni=vip.putata.eu.org&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 13.68ms
trojan://tg-dns68@162.159.153.160:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 13.22ms
trojan://tg-dns68@162.159.153.110:443?security=tls&type=ws&sni=vip.putata.eu.org&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 10.76ms
trojan://tg-dns68@162.159.152.93:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 10.82ms
trojan://tg-dns68@162.159.152.91:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 9.78ms
trojan://tg-dns68@162.159.152.84:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 7.59ms
trojan://tg-dns68@162.159.152.39:443?security=tls&type=ws&sni=vip.putata.eu.org&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 7.61ms
trojan://tg-dns68@162.159.152.36:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 17.98ms
trojan://tg-dns68@162.159.152.35:443?security=tls&sni=vip.putata.eu.org&type=ws&host=vip.putata.eu.org&path=%2F%3Fed%3D2560&fp=randomized&alpn=h3#RELAY🚩 | vip.putata.eu.org-443 | 8.86ms
trojan://tg-dns68@162.159.152.236:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 10.62ms
trojan://tg-dns68@162.159.152.22:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 16.4ms
trojan://tg-dns68@162.159.152.217:443?security=tls&type=ws&sni=vip.putata.eu.org&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 9.6ms
trojan://tg-dns68@162.159.152.214:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 9.96ms
trojan://tg-dns68@162.159.152.209:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 13.35ms
trojan://tg-dns68@162.159.152.204:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 9.76ms
trojan://tg-dns68@162.159.152.177:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 7.07ms
trojan://tg-dns68@162.159.152.169:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 7.41ms
trojan://tg-dns68@162.159.152.132:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 14.12ms
trojan://tg-dns68@162.159.152.10:443?security=tls&type=ws&sni=vip.putata.eu.org&path=%2F%3Fed%3D2560&host=vip.putata.eu.org#RELAY🚩 | vip.putata.eu.org-443 | 10.6ms
trojan://mitivpn@188.114.97.6:443?path=%2F720f09dba195249b423f771661162528%2Fworkers%2Fservices%2Fview%2Fmitivpn%2Fproduction&security=tls&alpn=http%2F1.1&insecure=0&fp=edge&type=ws&allowInsecure=0&sni=www.mitivpn.in.net#RELAY🚩 | www.mitivpn.in.net-443 | 76.86ms
trojan://humanity@www.multiplydose.com:443?type=ws&security=tls&path=%2Fassignment&sni=www.multiplydose.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.multiplydose.com-443 | 63.51ms
trojan://humanity@www.gossipglove.com:443?path=%2Fassignment&security=tls&fp=chrome&type=ws&sni=www.gossipglove.com#RELAY🚩 | www.gossipglove.com-443 | 161.57ms
trojan://humanity@www.calmlunch.com:443?type=ws&security=tls&path=%2Fassignment&sni=www.calmlunch.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.calmlunch.com-443 | 185.85ms
trojan://humanity@www.calmlunch.com:443?path=%2Fassignment&type=ws#RELAY🚩 | www.calmlunch.com-443 | 8.08ms
trojan://humanity@www.calmloud.com:443?path=%2Fassignment&type=ws#RELAY🚩 | www.calmloud.com-443 | 254.19ms
trojan://humanity@join-telegram-channel.tirexnet.kdns.fr:443?path=%2Fassignment&security=tls&alpn=h3%2Ch2%2Chttp%2F1.1&insecure=0&host=www.ignitelimit.com&fp=ios&type=ws&allowInsecure=0&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 145.66ms
trojan://humanity@66.81.247.155:443?security=tls&sni=www.calmloud.com&fp=chrome&alpn=http%2F1.1&insecure=0&allowInsecure=0&type=ws&host=www.calmloud.com&path=%2Fassignment#RELAY🚩 | www.calmloud.com-443 | 9.25ms
trojan://humanity@45.80.111.7:443?type=ws&security=tls&path=%2Fassignment&sni=www.calmlunch.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.calmlunch.com-443 | 8.31ms
trojan://humanity@45.80.111.7:443?path=%2Fassignment&security=tls&insecure=0&fp=chrome&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 9.77ms
trojan://humanity@45.130.125.96:443?security=tls&sni=www.calmloud.com&alpn=http%2F1.1&fp=chrome&type=ws&host=www.calmloud.com&path=%2Fassignment#RELAY🚩 | www.calmloud.com-443 | 9.24ms
trojan://humanity@45.130.125.75:443?type=ws&security=tls&path=%2Fassignment&host=www.calmlunch.com&sni=www.calmlunch.com&insecure=1&allowInsecure=1#RELAY🚩 | www.calmlunch.com-443 | 8.78ms
trojan://humanity@45.130.125.75:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 10.7ms
trojan://humanity@45.130.125.75:443?host=www.calmlunch.com&path=%2Fassignment&sni=www.calmlunch.com&type=ws#RELAY🚩 | www.calmlunch.com-443 | 10.35ms
trojan://humanity@45.130.125.32:443?path%D9%87=%2Fassignment&security=tls&insecure=0&host=www.calmloud.com&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 8.88ms
trojan://humanity@45.130.125.32:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmloud.com&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 9.82ms
trojan://humanity@45.130.125.2:443?path=%2Fassignment&security=tls&insecure=0&host=Www.cReaTIOnLONG.OrG&type=ws&allowInsecure=0&sni=Www.cReaTIOnLONG.OrG#RELAY🚩 | Www.cReaTIOnLONG.OrG-443 | 184.2ms
trojan://humanity@45.130.125.162:443?path=%2Fassignment&security=tls&alpn=h3%2Ch2%2Chttp%2F1.1&insecure=0&host=www.multiplydose.com&fp=ios&type=ws&allowInsecure=0&sni=www.multiplydose.com#RELAY🚩 | www.multiplydose.com-443 | 12.06ms
trojan://humanity@45.130.125.160:443?path=%2Fassignment&security=tls&alpn=http%2F1.1&insecure=0&host=www.calmloud.com&fp=chrome&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 7.46ms
trojan://humanity@45.130.125.126:443?host=www.multiplydose.com&path=%2Fassignment&sni=www.multiplydose.com&type=ws#RELAY🚩 | www.multiplydose.com-443 | 20.75ms
trojan://humanity@45.130.125.112:443?type=ws&security=tls&path=%2Fassignment&sni=www.calmlunch.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.calmlunch.com-443 | 7.65ms
trojan://humanity@45.130.125.112:443?path=%2Fassignment&security=tls&insecure=0&fp=chrome&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 7.03ms
trojan://humanity@45.130.125.112:443?path=%2Fassignment&security=tls&fp=chrome&type=ws&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 7.92ms
trojan://humanity@45.130.125.0:443?host=www.calmloud.com&path=%2Fassignment&sni=www.calmloud.com&type=ws#RELAY🚩 | www.calmloud.com-443 | 8.12ms
trojan://humanity@216.24.57.1:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmloud.com&ech=54.mk%2Budp%3A%2F%2F8.8.8.8&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 9.61ms
trojan://humanity@216.24.57.1:443?host=www.creationlong.org&path=%2Fassignment&sni=www.creationlong.org&type=ws#RELAY🚩 | www.creationlong.org-443 | 9.84ms
trojan://humanity@212.183.88.136:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 8.92ms
trojan://humanity@208.103.161.170:443?type=ws&security=tls&path=%2Fassignment&host=www.calmloud.com&sni=www.calmloud.com&alpn=http%2F1.1&fp=chrome&insecure=1&allowInsecure=1#RELAY🚩 | www.calmloud.com-443 | 9.47ms
trojan://humanity@208.103.161.170:443?path=%2Fassignment&security=tls&alpn=http%2F1.1&insecure=0&host=www.calmloud.com&fp=chrome&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 10.47ms
trojan://humanity@202.37.33.80:443?type=ws&security=tls&path=%2Fassignment&host=www.creationlong.org&sni=www.creationlong.org&insecure=0&allowInsecure=0#RELAY🚩 | www.creationlong.org-443 | 9.33ms
trojan://humanity@202.37.33.80:443?path=%2Fassignment&security=tls&insecure=0&host=www.creationlong.org&type=ws&allowInsecure=0&sni=www.creationlong.org#RELAY🚩 | www.creationlong.org-443 | 14.56ms
trojan://humanity@202.37.33.80:443?path=%2Fassignment&security=tls&host=www.creationlong.org&type=ws&sni=www.creationlong.org#RELAY🚩 | www.creationlong.org-443 | 9.57ms
trojan://humanity@198.62.62.23:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 11.9ms
trojan://humanity@198.202.211.1:443?type=ws&security=tls&path=%2Fassignment&host=www.creationlong.org&sni=www.creationlong.org&insecure=0&allowInsecure=0#RELAY🚩 | www.creationlong.org-443 | 14.38ms
trojan://humanity@198.202.211.1:443?type=ws&security=tls&path=%2Fassignment&host=www.creationlong.org&sni=www.creationlong.org&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.creationlong.org-443 | 10.61ms
trojan://humanity@198.202.211.1:443?security=tls&sni=www.creationlong.org&fp=chrome&insecure=0&allowInsecure=0&type=ws&host=www.creationlong.org&path=%2Fassignment#RELAY🚩 | www.creationlong.org-443 | 14.17ms
trojan://humanity@188.114.99.0:443?path=%2Fassignment&security=tls&insecure=0&host=www.gossipglove.com&type=ws&allowInsecure=0&sni=www.gossipglove.com#RELAY🚩 | www.gossipglove.com-443 | 15.75ms
trojan://humanity@188.114.98.0:443?type=ws&security=tls&path=%2Fassignment&sni=www.multiplydose.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.multiplydose.com-443 | 9.42ms
trojan://humanity@188.114.98.0:443?type=ws&security=tls&path=%2Fassignment&sni=www.calmlunch.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.calmlunch.com-443 | 7.56ms
trojan://humanity@188.114.98.0:443?path=%2Fassignment&security=tls&insecure=0&host=www.creationlong.org&type=ws&allowInsecure=0&sni=www.creationlong.org#RELAY🚩 | www.creationlong.org-443 | 7.09ms
trojan://humanity@188.114.98.0:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 7.09ms
trojan://humanity@188.114.97.6:443?path=%2Fassignment&security=tls&host=www.calmloud.com&type=ws&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 8.33ms
trojan://humanity@188.114.97.6:443?alpn=http%2F1.1&fp=chrome&host=www.calmloud.com&path=%2Fassignment&sni=www.calmloud.com&type=ws#RELAY🚩 | www.calmloud.com-443 | 9.97ms
trojan://humanity@188.114.96.3:443?type=ws&security=tls&path=%2Fassignment&sni=www.multiplydose.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.multiplydose.com-443 | 11.88ms
trojan://humanity@188.114.96.3:443?type=ws&security=tls&path=%2Fassignment&sni=www.creationlong.org&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.creationlong.org-443 | 18ms
trojan://humanity@188.114.96.3:443?type=ws&security=tls&path=%2Fassignment&sni=www.calmlunch.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.calmlunch.com-443 | 9.99ms
trojan://humanity@188.114.96.3:443?type=ws&host=www.gossipglove.com&path=%2Fassignment&security=tls&sni=www.gossipglove.com&allowInsecure=1#RELAY🚩 | www.gossipglove.com-443 | 8.04ms
trojan://humanity@185.18.250.252:443?path=%2Fassignment&security=tls&insecure=1&host=www.multiplydose.com&fp=chrome&type=ws&allowInsecure=1&sni=www.multiplydose.com#RELAY🚩 | www.multiplydose.com-443 | 9.09ms
trojan://humanity@185.18.250.252:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 7.72ms
trojan://humanity@185.18.250.252:443?path=%2Fassignment&security=tls&host=www.multiplydose.com&fp=chrome&type=ws&sni=www.multiplydose.com#RELAY🚩 | www.multiplydose.com-443 | 8.17ms
trojan://humanity@185.18.250.245:443?path=%2Fassignment&security=tls&insecure=1&host=www.calmlunch.com&type=ws&allowInsecure=1&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 8.97ms
trojan://humanity@172.67.180.92:443?path=%2Fassignment&security=tls&insecure=0&host=www.multiplydose.com&fp=chrome&type=ws&allowInsecure=0&sni=www.multiplydose.com#RELAY🚩 | www.multiplydose.com-443 | 7.93ms
trojan://humanity@172.66.44.211:443?host=www.multiplydose.com&path=%2Fassignment&sni=www.multiplydose.com&type=ws#RELAY🚩 | www.multiplydose.com-443 | 8.73ms
trojan://humanity@172.64.152.23:443?path=%2Fassignment&security=tls&insecure=1&host=www.calmlunch.com&type=ws&allowInsecure=1&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 8.06ms
trojan://humanity@172.64.152.23:443?path=%2Fassignment&security=tls&insecure=0&host=www.gossipglove.com&fp=chrome&type=ws&allowInsecure=0&sni=www.gossipglove.com#RELAY🚩 | www.gossipglove.com-443 | 11.61ms
trojan://humanity@172.64.152.23:443?path=%2Fassignment&security=tls&fp=chrome&type=ws&sni=www.multiplydose.com#RELAY🚩 | www.multiplydose.com-443 | 9.74ms
trojan://humanity@172.64.147.227:443?path=%2Fassignment&security=tls&insecure=1&host=www.gossipglove.com&type=ws&allowInsecure=1&sni=www.gossipglove.com#RELAY🚩 | www.gossipglove.com-443 | 9.04ms
trojan://humanity@172.64.146.1:443?security=tls&sni=www.gossipglove.com&insecure=1&allowInsecure=1&type=ws&host=www.gossipglove.com&path=%2Fassignment#RELAY🚩 | www.gossipglove.com-443 | 8.3ms
trojan://humanity@172.64.146.198:443?security=tls&sni=www.gossipglove.com&insecure=1&allowInsecure=1&type=ws&host=www.gossipglove.com&path=%2Fassignment#RELAY🚩 | www.gossipglove.com-443 | 7.61ms
trojan://humanity@172.64.146.153:443?security=tls&sni=www.gossipglove.com&insecure=1&allowInsecure=1&type=ws&host=www.gossipglove.com&path=%2Fassignment#RELAY🚩 | www.gossipglove.com-443 | 8.99ms
trojan://humanity@165.215.250.14:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&fp=chrome&insecure=1&allowInsecure=1#RELAY🚩 | www.ignitelimit.com-443 | 7.27ms
trojan://humanity@165.215.250.14:443?type=ws&security=tls&path=%2Fassignment&host=www.calmlunch.com&sni=www.calmlunch.com&fp=chrome&insecure=1&allowInsecure=1#RELAY🚩 | www.calmlunch.com-443 | 8.49ms
trojan://humanity@165.215.250.14:443?path=%2Fassignment&security=tls&insecure=1&host=www.ignitelimit.com&fp=chrome&type=ws&allowInsecure=1&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 7.4ms
trojan://humanity@165.215.250.14:443?path=%2Fassignment&security=tls&insecure=1&host=www.calmlunch.com&fp=chrome&type=ws&allowInsecure=1&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 8.7ms
trojan://humanity@165.215.250.14:443?path=%2Fassignment&security=tls&host=www.calmlunch.com&fp=chrome&type=ws&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 8.05ms
trojan://humanity@165.215.250.14:443?allowInsecure=1&fp=chrome&host=www.ignitelimit.com&path=%2Fassignment&sni=www.ignitelimit.com&type=ws#RELAY🚩 | www.ignitelimit.com-443 | 10.66ms
trojan://humanity@162.159.38.119:443?type=ws&security=tls&path=%2Fassignment&host=www.gossipglove.com&sni=www.gossipglove.com&insecure=0&allowInsecure=0#RELAY🚩 | www.gossipglove.com-443 | 10.89ms
trojan://humanity@162.159.38.119:443?type=ws&security=tls&path=%2Fassignment&host=www.creationlong.org&sni=www.creationlong.org&insecure=0&allowInsecure=0#RELAY🚩 | www.creationlong.org-443 | 7.87ms
trojan://humanity@162.159.38.119:443?type=ws&security=tls&path=%2Fassignment&host=www.calmloud.com&sni=www.calmloud.com&insecure=0&allowInsecure=0#RELAY🚩 | www.calmloud.com-443 | 8.84ms
trojan://humanity@162.159.38.119:443?security=tls&sni=www.gossipglove.com&insecure=0&allowInsecure=0&type=ws&host=www.gossipglove.com&path=%2Fassignment#RELAY🚩 | www.gossipglove.com-443 | 11.49ms
trojan://humanity@162.159.38.119:443?path=%2Fassignment&security=tls&insecure=0&host=www.creationlong.org&type=ws&allowInsecure=0&sni=www.creationlong.org#RELAY🚩 | www.creationlong.org-443 | 12.73ms
trojan://humanity@162.159.38.119:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmloud.com&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 13.25ms
trojan://humanity@162.159.17.189:443?path=%2Fassignment&security=tls&insecure=1&host=www.multiplydose.com&type=ws&allowInsecure=1&sni=www.multiplydose.com#RELAY🚩 | www.multiplydose.com-443 | 12.64ms
trojan://humanity@162.159.17.189:443?path=%2Fassignment&security=tls&host=www.multiplydose.com&type=ws&sni=www.multiplydose.com#RELAY🚩 | www.multiplydose.com-443 | 7.38ms
trojan://humanity@141.193.213.21:443?type=ws&security=tls&path=%2Fassignment&host=www.calmloud.com&sni=www.calmloud.com&alpn=http%2F1.1&insecure=0&allowInsecure=0#RELAY🚩 | www.calmloud.com-443 | 9.36ms
trojan://humanity@141.193.213.21:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmloud.com&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 8.84ms
trojan://humanity@141.193.213.21:443?path=%2Fassignment&security=tls&host=www.calmloud.com&type=ws&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 13.42ms
trojan://humanity@141.193.213.21:443?path=%2Fassignment&security=tls&alpn=http%2F1.1&insecure=0&host=www.calmloud.com&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 11.06ms
trojan://humanity@141.193.213.21:443?path=%2Fassignment&security=tls&alpn=http%2F1.1&host=www.calmloud.com&type=ws&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 9.62ms
trojan://humanity@141.193.213.11:443?security=tls&sni=www.calmloud.com&alpn=http%2F1.1&fp=chrome&type=ws&host=www.calmloud.com&path=%2Fassignment#RELAY🚩 | www.calmloud.com-443 | 8.19ms
trojan://humanity@141.101.90.101:443?encryption=none&security=tls&sni=www.ignitelimit.com&type=ws&path=%2Fassignment#RELAY🚩 | www.ignitelimit.com-443 | 8.68ms
trojan://humanity@104.21.40.34:443?path=%2Fassignment&security=tls&insecure=1&host=www.gossipglove.com&type=ws&allowInsecure=1&sni=www.gossipglove.com#RELAY🚩 | www.gossipglove.com-443 | 17.21ms
trojan://humanity@104.21.40.34:443?path=%2Fassignment&security=tls&host=www.gossipglove.com&type=ws&sni=www.gossipglove.com#RELAY🚩 | www.gossipglove.com-443 | 8.37ms
trojan://humanity@104.20.6.134:443?host=www.ignitelimit.com&path=%2Fassignment&sni=www.ignitelimit.com&type=ws#RELAY🚩 | www.ignitelimit.com-443 | 10.02ms
trojan://humanity@104.20.42.250:443?host=www.calmloud.com&path=%2Fassignment&sni=www.calmloud.com&type=ws#RELAY🚩 | www.calmloud.com-443 | 8.3ms
trojan://humanity@104.19.64.105:443?host=www.calmlunch.com&path=%2Fassignment&sni=www.calmlunch.com&type=ws#RELAY🚩 | www.calmlunch.com-443 | 8.71ms
trojan://humanity@104.19.230.21:443?security=tls&sni=www.multiplydose.com&insecure=0&allowInsecure=0&type=ws&path=%2Fassignment#RELAY🚩 | www.multiplydose.com-443 | 17.12ms
trojan://humanity@104.19.229.21:443?type=ws&host=www.calmloud.com&path=%2Fassignment&security=tls&fp=chrome&sni=www.calmloud.com&alpn=http%2F1.1#RELAY🚩 | www.calmloud.com-443 | 13.47ms
trojan://humanity@104.19.229.21:443?security=tls&sni=www.calmloud.com&alpn=http%2F1.1&fp=chrome&type=ws&host=www.calmloud.com&path=%2Fassignment#RELAY🚩 | www.calmloud.com-443 | 7.22ms
trojan://humanity@104.19.229.21:443?path=%2Fassignment&security=tls&insecure=0&host=www.gossipglove.com&type=ws&allowInsecure=0&sni=www.gossipglove.com#RELAY🚩 | www.gossipglove.com-443 | 9.47ms
trojan://humanity@104.19.229.21:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 10.6ms
trojan://humanity@104.19.229.21:443?path=%2Fassignment&security=tls&alpn=http%2F1.1&insecure=0&host=www.calmloud.com&fp=chrome&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 9.02ms
trojan://humanity@104.19.229.21:443?path=%2Fassignment&security=tls&alpn=http%2F1.1&host=www.calmloud.com&fp=chrome&type=ws&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 11.9ms
trojan://humanity@104.19.2.175:443?encryption=none&security=tls&sni=www.calmloud.com&alpn=http%2F1.1&type=ws&host=www.calmloud.com&path=%2Fassignment#RELAY🚩 | www.calmloud.com-443 | 11.06ms
trojan://humanity@104.18.32.47:443?type=ws&security=tls&path=%2Fassignment&host=www.multiplydose.com&sni=www.multiplydose.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.multiplydose.com-443 | 9.64ms
trojan://humanity@104.18.32.47:443?path=%2Fassignment&security=tls&insecure=0&fp=chrome&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 7.83ms
trojan://humanity@104.18.152.97:443?path=%2Fassignment&security=tls&insecure=0&host=www.ignitelimit.com&type=ws&allowInsecure=0&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 9.49ms
trojan://humanity@104.18.152.77:443?path=%2Fassignment&security=tls&insecure=0&host=www.ignitelimit.com&type=ws&allowInsecure=0&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 14.21ms
trojan://humanity@104.18.152.73:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&insecure=0&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 8.15ms
trojan://humanity@104.18.152.246:443?type=ws&security=tls&path=%2Fassignment&host=www.calmloud.com&sni=www.calmloud.com&alpn=http%2F1.1&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.calmloud.com-443 | 7.35ms
trojan://humanity@104.18.152.246:443?path=%2Fassignment&security=tls&alpn=http%2F1.1&insecure=0&host=www.calmloud.com&fp=chrome&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 9.28ms
trojan://humanity@104.18.152.229:443?type=ws&security=tls&path=%2Fassignment&sni=www.calmloud.com&alpn=http%2F1.1&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.calmloud.com-443 | 8.6ms
trojan://humanity@104.18.152.229:443?type=ws&security=tls&path=%2Fassignment&host=www.calmloud.com&sni=www.calmloud.com&alpn=http%2F1.1&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.calmloud.com-443 | 12.56ms
trojan://humanity@104.18.152.229:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmloud.com&type=ws&allowInsecure=0&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 7.84ms
trojan://humanity@104.18.152.229:443?path=%2Fassignment&security=tls&alpn=http%2F1.1&host=www.calmloud.com&fp=chrome&type=ws&sni=www.calmloud.com#RELAY🚩 | www.calmloud.com-443 | 10.29ms
trojan://humanity@104.18.152.229:443?encryption=none&security=tls&sni=www.ignitelimit.com&fp=chrome&type=ws&path=%2Fassignment#RELAY🚩 | www.ignitelimit.com-443 | 8.1ms
trojan://humanity@104.18.152.229:443?alpn=http%2F1.1&fp=chrome&host=www.calmloud.com&path=%2Fassignment&sni=www.calmloud.com&type=ws#RELAY🚩 | www.calmloud.com-443 | 7.78ms
trojan://humanity@104.18.152.225:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&insecure=0&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 7.07ms
trojan://humanity@104.18.152.225:443?path=%2Fassignment&security=tls&insecure=0&host=www.ignitelimit.com&type=ws&allowInsecure=0&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 8.26ms
trojan://humanity@104.18.152.225:443?path=%2Fassignment&security=tls&host=www.ignitelimit.com&type=ws&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 8.8ms
trojan://humanity@104.18.152.219:443?path=%2Fassignment&security=tls&insecure=0&host=www.ignitelimit.com&type=ws&allowInsecure=0&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 9.69ms
trojan://humanity@104.18.152.208:443?host=www.ignitelimit.com&path=%2Fassignment&sni=www.ignitelimit.com&type=ws#RELAY🚩 | www.ignitelimit.com-443 | 11.8ms
trojan://humanity@104.18.152.187:443?type=ws&security=tls&path=%2Fassignment&sni=www.ignitelimit.com&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 8.33ms
trojan://humanity@104.18.152.155:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&insecure=0&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 9.86ms
trojan://humanity@104.18.152.108:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&insecure=0&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 11.21ms
trojan://humanity@104.18.12.149:443?path=%2Fassignment&security=tls&host=www.ignitelimit.com&type=ws&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 6.76ms
trojan://humanity@104.18.12.149:443?host=www.calmlunch.com&path=%2Fassignment&sni=www.calmlunch.com&type=ws#RELAY🚩 | www.calmlunch.com-443 | 7.79ms
trojan://humanity@104.17.121.71:443?host=www.calmlunch.com&path=%2Fassignment&sni=www.calmlunch.com&type=ws#RELAY🚩 | www.calmlunch.com-443 | 8.13ms
trojan://humanity@104.17.121.43:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 12.34ms
trojan://humanity@104.16.72.41:443?type=ws&security=tls&path=%2Fassignment&host=www.calmlunch.com&sni=www.calmlunch.com&insecure=0&allowInsecure=0#RELAY🚩 | www.calmlunch.com-443 | 7.11ms
trojan://humanity@104.16.72.41:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 10.26ms
trojan://humanity@104.16.72.41:443?host=www.calmlunch.com&path=%2Fassignment&sni=www.calmlunch.com&type=ws#RELAY🚩 | www.calmlunch.com-443 | 7.02ms
trojan://humanity@104.16.72.2:443?type=ws&security=tls&path=%2Fassignment&host=www.calmlunch.com&sni=www.calmlunch.com&insecure=0&allowInsecure=0#RELAY🚩 | www.calmlunch.com-443 | 11.43ms
trojan://humanity@104.16.72.2:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 8.79ms
trojan://humanity@104.16.71.213:443?path=%2Fassignment&security=tls&insecure=0&host=www.calmlunch.com&type=ws&allowInsecure=0&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 11.76ms
trojan://humanity@104.16.71.213:443?path=%2Fassignment&security=tls&host=www.calmlunch.com&type=ws&sni=www.calmlunch.com#RELAY🚩 | www.calmlunch.com-443 | 9.02ms
trojan://humanity@104.16.174.71:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&insecure=1&allowInsecure=1#RELAY🚩 | www.ignitelimit.com-443 | 21.05ms
trojan://humanity@104.16.174.44:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&insecure=0&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 7.87ms
trojan://humanity@104.16.174.44:443?path=%2Fassignment&security=tls&insecure=0&host=www.ignitelimit.com&type=ws&allowInsecure=0&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 9.9ms
trojan://humanity@104.16.174.36:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&insecure=0&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 13.21ms
trojan://humanity@104.16.174.12:443?type=ws&security=tls&path=%2Fassignment&host=www.ignitelimit.com&sni=www.ignitelimit.com&insecure=0&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 9.81ms
trojan://humanity@104.16.174.12:443?sni=www.ignitelimit.com&insecure=0&path=%2Fassignment&host=www.ignitelimit.com&security=tls&type=ws&allowInsecure=0#RELAY🚩 | www.ignitelimit.com-443 | 10.62ms
trojan://humanity@104.16.174.117:443?path=%2Fassignment&security=tls&insecure=0&host=www.ignitelimit.com&type=ws&allowInsecure=0&sni=www.ignitelimit.com#RELAY🚩 | www.ignitelimit.com-443 | 7.16ms
trojan://fQ84Q7A4dw@152.42.252.70:443?security=tls&type=grpc&sni=ultra.vpnxhub.xyz#US🇺🇸 | ultra.vpnxhub.xyz-443 | 175.38ms
trojan://f922fa0f-3311-4368-85ff-cf65e727c854@141.193.213.30:443?path=%2Fbr-orcl&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 652.12ms
trojan://f922fa0f-3311-4368-85ff-cf65e727c854@104.17.121.43:443?path=%2Fbr-orcl&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 15.04ms
trojan://f922fa0f-3311-4368-85ff-cf65e727c854@104.16.72.70:443?path=%2Fbr-orcl&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 8.07ms
trojan://f922fa0f-3311-4368-85ff-cf65e727c854@104.16.72.41:443?path=%2Fbr-orcl&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 13.72ms
trojan://f922fa0f-3311-4368-85ff-cf65e727c854@104.16.72.2:443?path=%2Fbr-orcl&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 11.42ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.151:443#DE🇩🇪 | 185.137.157.151-443 | 122.57ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.149:443?type=tcp&security=tls&headerType=none&sni=185.137.157.149&insecure=0&allowInsecure=0#DE🇩🇪 | 185.137.157.149-443 | 125.96ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.149:443?security=tls&insecure=0&host=v2rayNplus--v2rayNplus--v2rayNplus&headerType=none&type=tcp&allowInsecure=0&sni=185.137.157.149#DE🇩🇪 | 185.137.157.149-443 | 135.6ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.149:443?security=tls&insecure=0&headerType=none&type=tcp&allowInsecure=0#DE🇩🇪 | 185.137.157.149-443 | 113.09ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.149:443?security=tls&insecure=0&allowInsecure=0&type=tcp&headerType=none#DE🇩🇪 | 185.137.157.149-443 | 124.49ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.145:443?security=tls&insecure=0&headerType=none&type=tcp&allowInsecure=0#DE🇩🇪 | 185.137.157.145-443 | 118.33ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.142:443?type=tcp&security=tls&insecure=1&allowInsecure=1#DE🇩🇪 | 185.137.157.142-443 | 131.31ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.142:443?security=tls&insecure=0&headerType=none&type=tcp&allowInsecure=0#DE🇩🇪 | 185.137.157.142-443 | 119.51ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.142:443#DE🇩🇪 | 185.137.157.142-443 | 128.53ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.140:443?security=tls&insecure=0&headerType=none&type=tcp&allowInsecure=0#DE🇩🇪 | 185.137.157.140-443 | 127.41ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.138:443#DE🇩🇪 | 185.137.157.138-443 | 114.57ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.128:443?security=tls&insecure=0&headerType=none&type=tcp&allowInsecure=0#DE🇩🇪 | 185.137.157.128-443 | 118.77ms
trojan://dh-Ws-YoJIgTYLZ-A5VljeduVse-vhDl7Q@185.137.157.128:443#DE🇩🇪 | 185.137.157.128-443 | 128.04ms
trojan://dfdse334053vuohm@104.16.72.2:443?path=%2F&security=tls&insecure=0&host=alternative.mhjstudio.ir&type=ws&allowInsecure=0&sni=alternative.mhjstudio.ir#TR🇹🇷 | alternative.mhjstudio.ir-443 | 501.55ms
trojan://d39e048c-c9f3-c79d-6f0b-cfbba5722f1b@104.17.72.206:443?security=tls&sni=quiet-hill-5b71.roi2bnd12r912msdn12m23rofo2fkk.workers.dev&fp=chrome&insecure=0&allowInsecure=0&type=ws&host=quiet-hill-5b71.roi2bnd12r912msdn12m23rofo2fkk.workers.dev&path=%2F#RELAY🚩 | quiet-hill-5b71.roi2bnd12r912msdn12m23rofo2fkk.workers.dev-443 | 100.33ms
trojan://cassiusvpn@104.17.147.22:2087?security=tls&type=ws&sni=telegram----cassiusvpn----4447265148777747781232254445611722275.mint14.workers.dev&path=%2F%3Fed%3D2560&host=telegram----cassiusvpn----4447265148777747781232254445611722275.mint14.workers.dev#RELAY🚩 | telegram----cassiusvpn----4447265148777747781232254445611722275.mint14.workers.dev-2087 | 82.66ms
trojan://bb45f73f-795b-4a05-a8e0-ba717bce87e3@104.19.229.21:443?path=%2Fid-tksi&security=tls&insecure=0&host=api24-normal.tiktokv.com.cyylr.eu.cc&type=ws&allowInsecure=0&sni=api24-normal.tiktokv.com.cyylr.eu.cc#RELAY🚩 | api24-normal.tiktokv.com.cyylr.eu.cc-443 | 759.48ms
trojan://b10f2914-0401-4eff-ac4f-e430aeda0c45@104.19.142.99:443?security=tls&type=ws&sni=cfus2.trojanwss.xyz&path=%2FCFJICHANG&host=cfus2.trojanwss.xyz#US🇺🇸 | cfus2.trojanwss.xyz-443 | 216ms
trojan://auto@172.67.68.157:443?security=tls&type=ws&sni=e9464f45.trauma-2r4.pages.dev&path=%2F&host=e9464f45.trauma-2r4.pages.dev#RELAY🚩 | e9464f45.trauma-2r4.pages.dev-443 | 57.4ms
trojan://auto@172.67.174.252:443?security=tls&type=ws&sni=esetsecuritylicense1.vowexa5791.workers.dev&path=%2F&host=esetsecuritylicense1.vowexa5791.workers.dev#RELAY🚩 | esetsecuritylicense1.vowexa5791.workers.dev-443 | 93.5ms
trojan://auto@162.159.153.99:443?security=tls&type=ws&sni=fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org&host=fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org#RELAY🚩 | fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org-443 | 178.9ms
trojan://auto@162.159.153.92:443?security=tls&type=ws&sni=fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org&host=fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org#RELAY🚩 | fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org-443 | 7.94ms
trojan://auto@162.159.152.212:443?security=tls&type=ws&sni=fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org&host=fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org#RELAY🚩 | fe9b5676-a2aa-4b6a-8257-cd2dd0910205.8c98ef2b-bee2-470b-b759-9f5efbc10812.freeddns.org-443 | 6.83ms
trojan://auto@162.159.136.232:8443?security=tls&type=ws&sni=e9464f45.trauma-2r4.pages.dev&path=%2F&host=e9464f45.trauma-2r4.pages.dev#RELAY🚩 | e9464f45.trauma-2r4.pages.dev-8443 | 8.43ms
trojan://afbcd89a-5a90-4a44-a42a-be08f444aa3f@blog.webex.com:443?path=%2Fbr-orcl&security=tls&insecure=0&host=unnes.ac.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=unnes.ac.id.yxls.eu.cc#RELAY🚩 | unnes.ac.id.yxls.eu.cc-443 | 277.69ms
trojan://aa710f78-eddb-45b4-bd32-1f8692a754e5@104.19.229.21:443?path=%2Fae-bo&security=tls&insecure=0&host=s.blibli.com.cyylr.eu.cc&type=ws&allowInsecure=0&sni=s.blibli.com.cyylr.eu.cc#RELAY🚩 | s.blibli.com.cyylr.eu.cc-443 | 627.36ms
trojan://XG59623478@soskeynets-asp.rooster465.autos:443?allowInsecure=0&sni=enabling-asp.rooster465.autos#DE🇩🇪 | enabling-asp.rooster465.autos-443 | 295.37ms
trojan://XG59623478@singular-lark.rooster465.autos:443#IE🇮🇪 | singular-lark.rooster465.autos-443 | 227.5ms
trojan://XG59623478@enabling-asp.rooster465.autos:443?allowInsecure=0&sni=enabling-asp.rooster465.autos#DE🇩🇪 | enabling-asp.rooster465.autos-443 | 183.31ms
trojan://XG59623478@enabling-asp.rooster465.autos:443#DE🇩🇪 | enabling-asp.rooster465.autos-443 | 171.57ms
trojan://XG59623478@3.249.67.252:443?sni=singular-lark.rooster465.autos#IE🇮🇪 | singular-lark.rooster465.autos-443 | 179.43ms
trojan://XG59623478@3.249.67.252:443?security=tls&insecure=0&headerType=none&type=tcp&allowInsecure=0&sni=singular-lark.rooster465.autos#IE🇮🇪 | singular-lark.rooster465.autos-443 | 325.93ms
trojan://VPNCUSTOMIZE@104.19.34.116:443?type=xhttp&security=tls&path=%2Fconfig&host=bvck-oizksj-swin-usje-c-o.offers.de5.net&mode=stream-one&sni=offers.de5.net&insecure=0&allowInsecure=0#RELAY🚩 | offers.de5.net-443 | 99.64ms
trojan://Trojan-Hqv2rayNG@151.101.66.219:443?security=tls&type=ws&sni=speedtest.net&path=%2Fhqv2rayng.host%3Fed%3D2048&host=dontskii.hqv2rayng.xyz#US🇺🇸 | speedtest.net-443 | 11.13ms
trojan://SoftNetConnect@178.104.213.121:443?security=reality&pbk=bVGtj0cRMfC-VapbrAa97IjYqjMoxODMOqsN0eGBDmI&headerType=none&type=tcp&sni=www.yahoo.com&sid=e0c7dbaa7dc2#REALITY|US🇺🇸 | www.yahoo.com-443 | 24.59ms
trojan://OD90375861@wired-tick.rooster465.autos:443?allowInsecure=0&sni=wired-tick.rooster465.autos#IE🇮🇪 | wired-tick.rooster465.autos-443 | 218.35ms
trojan://OD90375861@together-insect.rooster465.autos:443?allowInsecure=0&sni=together-insect.rooster465.autos#DE🇩🇪 | together-insect.rooster465.autos-443 | 467.83ms
trojan://OD90375861@together-insect.rooster465.autos:443#DE🇩🇪 | together-insect.rooster465.autos-443 | 246.35ms
trojan://OD90375861@fit-calf.rooster465.autos:443?allowInsecure=0&sni=fit-calf.rooster465.autos#IE🇮🇪 | fit-calf.rooster465.autos-443 | 146.35ms
trojan://OD90375861@busy-hermit.rooster465.autos:443?allowInsecure=0&sni=busy-hermit.rooster465.autos#DE🇩🇪 | busy-hermit.rooster465.autos-443 | 278.52ms
trojan://OD90375861@busy-hermit.rooster465.autos:443#DE🇩🇪 | busy-hermit.rooster465.autos-443 | 144.57ms
trojan://Nova-Proxy@8.39.125.191:2083?path=%2F&security=tls&insecure=1&host=spring-queen-a95f.cewon19053.workers.dev&type=ws&allowInsecure=1&sni=spring-queen-a95f.cewon19053.workers.dev#RELAY🚩 | spring-queen-a95f.cewon19053.workers.dev-2083 | 73.32ms
trojan://MiTiVPN@assets.fiverr.com:443?type=ws&security=tls&path=%2FMiTiVPN%3DNL&host=PioHosting.ir&sni=PioHosting.ir&alpn=http%2F1.1&fp=firefox&insecure=0&allowInsecure=0#IR🇮🇷 | PioHosting.ir-443 | 379.53ms
trojan://MiTiVPN@91.193.58.201:443?type=ws&security=tls&path=%2FMiTiVPN%3DfL&host=PioHosting.ir&sni=PioHosting.ir&alpn=http%2F1.1&fp=firefox&insecure=0&allowInsecure=0#IR🇮🇷 | PioHosting.ir-443 | 131.66ms
trojan://MiTiVPN@91.193.58.201:443?type=ws&security=tls&path=%2FMiTiVPN%3DNL&host=PioHosting.ir&sni=PioHosting.ir&alpn=http%2F1.1&fp=firefox&insecure=0&allowInsecure=0#IR🇮🇷 | PioHosting.ir-443 | 125.19ms
trojan://MiTiVPN@91.193.58.201:443?path=%2FMiTiVPN%3DfL&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 132.87ms
trojan://MiTiVPN@91.193.58.201:443?path=%2FMiTiVPN%3DNL&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 330.67ms
trojan://MiTiVPN@151.101.1.242:443?path=%2Fde%3Dmitivpn&security=tls&alpn=http%2F1.1&insecure=0&host=www.f6r.ir&fp=chrome&type=ws&allowInsecure=0&sni=www.f6r.ir#IR🇮🇷 | www.f6r.ir-443 | 589.08ms
trojan://MiTiVPN@104.16.72.41:443?type=ws&security=tls&path=%2FMiTiVPN%3DSe&host=PioHosting.ir&sni=PioHosting.ir&alpn=http%2F1.1&fp=firefox&insecure=0&allowInsecure=0#IR🇮🇷 | PioHosting.ir-443 | 133.95ms
trojan://MiTiVPN@104.16.72.41:443?path=%2FMiTiVPN%3DSe&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 251.06ms
trojan://Mehdi1234@172.64.144.251:2083?security=tls&sni=purple-recipe-5e30.cimavo4626.workers.dev&insecure=0&allowInsecure=0&type=ws&host=purple-recipe-5e30.cimavo4626.workers.dev&path=%2F#RELAY🚩 | purple-recipe-5e30.cimavo4626.workers.dev-2083 | 65.58ms
trojan://Mehdi1234@172.64.144.251:2083?path=%2F&security=tls&insecure=0&host=purple-recipe-5e30.cimavo4626.workers.dev&type=ws&allowInsecure=0&sni=purple-recipe-5e30.cimavo4626.workers.dev#RELAY🚩 | purple-recipe-5e30.cimavo4626.workers.dev-2083 | 8.03ms
trojan://Mehdi1234@172.64.144.251:2083?ed=2560&eh=Sec-WebSocket-Protocol&host=purple-recipe-5e30.cimavo4626.workers.dev&path=%2F&sni=purple-recipe-5e30.cimavo4626.workers.dev&type=ws#RELAY🚩 | purple-recipe-5e30.cimavo4626.workers.dev-2083 | 11.27ms
trojan://MITIVPN@45.8.211.217:443?type=ws&security=tls&path=%2FMiTiVPN%3DDE&host=D--e.App-Cloud.ir&sni=D--e.App-Cloud.ir&alpn=http%2F1.1&fp=chrome&insecure=0&allowInsecure=0#RELAY🚩 | D--e.App-Cloud.ir-443 | 150.51ms
trojan://MITIVPN@45.131.4.115:443?type=ws&security=tls&path=%2FMiTiVPN%3DUsa&host=PioHosting.ir&sni=PioHosting.ir&alpn=http%2F1.1&fp=firefox&insecure=0&allowInsecure=0#IR🇮🇷 | PioHosting.ir-443 | 247.77ms
trojan://MITIVPN@45.131.4.115:443?path=%2FMiTiVPN%3DUsa&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 332.28ms
trojan://MITIVPN@151.101.69.219:443?path=%2Fed%3Dmitivpn&security=tls&alpn=h2&insecure=1&host=mitivpn-77.global.ssl.fastly.net&fp=chrome&type=ws&allowInsecure=1&sni=speedtest.net#US🇺🇸 | speedtest.net-443 | 13.07ms
trojan://MITIVPN@146.75.121.194:443?path=%2Fed%3Dmitivpn&security=tls&alpn=h2&insecure=1&host=mitivpn--3.global.ssl.fastly.net&fp=chrome&type=ws&allowInsecure=1&sni=fastly.com#US🇺🇸 | fastly.com-443 | 40.19ms
trojan://MITIVPN@104.16.72.41:443?type=ws&security=tls&path=%2FMiTiVPN%3DDe&host=PioHosting.ir&sni=PioHosting.ir&alpn=http%2F1.1&fp=firefox&insecure=0&allowInsecure=0#IR🇮🇷 | PioHosting.ir-443 | 249.02ms
trojan://KV63147582@more-trout.rooster465.autos:443?allowInsecure=0&sni=more-trout.rooster465.autos#PL🇵🇱 | more-trout.rooster465.autos-443 | 210.95ms
trojan://KV63147582@game-firefly.rooster465.autos:443?allowInsecure=0&sni=game-firefly.rooster465.autos#NL🇳🇱 | game-firefly.rooster465.autos-443 | 222.4ms
trojan://KV63147582@game-firefly.rooster465.autos:443#NL🇳🇱 | game-firefly.rooster465.autos-443 | 130.11ms
trojan://KV63147582@evolving-baboon.rooster465.autos:443?allowInsecure=0&sni=evolving-baboon.rooster465.autos#DE🇩🇪 | evolving-baboon.rooster465.autos-443 | 181.41ms
trojan://KV63147582@evolving-baboon.rooster465.autos:443#DE🇩🇪 | evolving-baboon.rooster465.autos-443 | 130.56ms
trojan://KV63147582@electric-sturgeon.rooster465.autos:443?allowInsecure=0&sni=electric-sturgeon.rooster465.autos#HK🇭🇰 | electric-sturgeon.rooster465.autos-443 | 276.3ms
trojan://Config0plus@45.130.125.0:443?path=%2Fid-tksi&security=tls&insecure=0&host=api24-normal.tiktokv.com.cyylr.eu.cc&type=ws&allowInsecure=0&sni=api24-normal.tiktokv.com.cyylr.eu.cc#RELAY🚩 | api24-normal.tiktokv.com.cyylr.eu.cc-443 | 16.03ms
trojan://CF68213490@well-marmot.rooster465.autos:443?allowInsecure=0&sni=well-marmot.rooster465.autos#HK🇭🇰 | well-marmot.rooster465.autos-443 | 388.37ms
trojan://CF68213490@welcome-monitor.rooster465.autos:443?allowInsecure=0&sni=welcome-monitor.rooster465.autos#JP🇯🇵 | welcome-monitor.rooster465.autos-443 | 173.06ms
trojan://CF68213490@wealthy-gobbler.rooster465.autos:443?allowInsecure=0&sni=wealthy-gobbler.rooster465.autos#JP🇯🇵 | wealthy-gobbler.rooster465.autos-443 | 190.42ms
trojan://CF68213490@vast-werewolf.rooster465.autos:443?allowInsecure=0&sni=vast-werewolf.rooster465.autos#SG🇸🇬 | vast-werewolf.rooster465.autos-443 | 248.87ms
trojan://CF68213490@upright-rhino.rooster465.autos:443?allowInsecure=0&sni=upright-rhino.rooster465.autos#JP🇯🇵 | upright-rhino.rooster465.autos-443 | 221.17ms
trojan://CF68213490@united-molly.rooster465.autos:443?allowInsecure=0&sni=united-molly.rooster465.autos#JP🇯🇵 | united-molly.rooster465.autos-443 | 336.57ms
trojan://CF68213490@ultimate-jaguar.rooster465.autos:443?allowInsecure=0&sni=ultimate-jaguar.rooster465.autos#JP🇯🇵 | ultimate-jaguar.rooster465.autos-443 | 177.6ms
trojan://CF68213490@tight-gator.rooster465.autos:443?allowInsecure=0&sni=tight-gator.rooster465.autos#SG🇸🇬 | tight-gator.rooster465.autos-443 | 239.5ms
trojan://CF68213490@thankful-mustang.rooster465.autos:443?allowInsecure=0&sni=thankful-mustang.rooster465.autos#JP🇯🇵 | thankful-mustang.rooster465.autos-443 | 172.07ms
trojan://CF68213490@summary-lemming.rooster465.autos:443?allowInsecure=0&sni=summary-lemming.rooster465.autos#SG🇸🇬 | summary-lemming.rooster465.autos-443 | 260.76ms
trojan://CF68213490@summary-firefly.rooster465.autos:443?allowInsecure=0&sni=summary-firefly.rooster465.autos#JP🇯🇵 | summary-firefly.rooster465.autos-443 | 166.8ms
trojan://CF68213490@star-moray.rooster465.autos:443?allowInsecure=0&sni=star-moray.rooster465.autos#JP🇯🇵 | star-moray.rooster465.autos-443 | 168.55ms
trojan://CF68213490@star-hagfish.rooster465.autos:443?allowInsecure=0&sni=star-hagfish.rooster465.autos#SG🇸🇬 | star-hagfish.rooster465.autos-443 | 244.95ms
trojan://CF68213490@soskeynets-mullet.rooster465.autos:443?allowInsecure=0&sni=immune-mullet.rooster465.autos#JP🇯🇵 | immune-mullet.rooster465.autos-443 | 177.36ms
trojan://CF68213490@soskeynets-mastiff.rooster465.autos:443?allowInsecure=0&sni=gentle-mastiff.rooster465.autos#KR🇰🇷 | gentle-mastiff.rooster465.autos-443 | 216.82ms
trojan://CF68213490@soskeynets-bat.rooster465.autos:443?allowInsecure=0&sni=modest-bat.rooster465.autos#SG🇸🇬 | modest-bat.rooster465.autos-443 | 238.9ms
trojan://CF68213490@smooth-hornet.rooster465.autos:443?allowInsecure=0&sni=smooth-hornet.rooster465.autos#JP🇯🇵 | smooth-hornet.rooster465.autos-443 | 164ms
trojan://CF68213490@smiling-fowl.rooster465.autos:443?allowInsecure=0&sni=smiling-fowl.rooster465.autos#JP🇯🇵 | smiling-fowl.rooster465.autos-443 | 171.26ms
trojan://CF68213490@smashing-fawn.rooster465.autos:443?allowInsecure=0&sni=smashing-fawn.rooster465.autos#JP🇯🇵 | smashing-fawn.rooster465.autos-443 | 161.9ms
trojan://CF68213490@skilled-lioness.rooster465.autos:443?allowInsecure=0&sni=skilled-lioness.rooster465.autos#JP🇯🇵 | skilled-lioness.rooster465.autos-443 | 191.58ms
trojan://CF68213490@sincere-crappie.rooster465.autos:443?allowInsecure=0&sni=sincere-crappie.rooster465.autos#JP🇯🇵 | sincere-crappie.rooster465.autos-443 | 181.39ms
trojan://CF68213490@shining-piranha.rooster465.autos:443?allowInsecure=0&sni=shining-piranha.rooster465.autos#JP🇯🇵 | shining-piranha.rooster465.autos-443 | 194.39ms
trojan://CF68213490@settling-humpback.rooster465.autos:443?allowInsecure=0&sni=settling-humpback.rooster465.autos#JP🇯🇵 | settling-humpback.rooster465.autos-443 | 161.66ms
trojan://CF68213490@sacred-treefrog.rooster465.autos:443?allowInsecure=0&sni=sacred-treefrog.rooster465.autos#SG🇸🇬 | sacred-treefrog.rooster465.autos-443 | 227.2ms
trojan://CF68213490@sacred-shepherd.rooster465.autos:443?allowInsecure=0&sni=sacred-shepherd.rooster465.autos#JP🇯🇵 | sacred-shepherd.rooster465.autos-443 | 171.53ms
trojan://CF68213490@sacred-anemone.rooster465.autos:443?allowInsecure=0&sni=sacred-anemone.rooster465.autos#JP🇯🇵 | sacred-anemone.rooster465.autos-443 | 175.84ms
trojan://CF68213490@relevant-oryx.rooster465.autos:443?allowInsecure=0&sni=relevant-oryx.rooster465.autos#SG🇸🇬 | relevant-oryx.rooster465.autos-443 | 237.82ms
trojan://CF68213490@pure-ram.rooster465.autos:443?allowInsecure=0&sni=pure-ram.rooster465.autos#KR🇰🇷 | pure-ram.rooster465.autos-443 | 201.99ms
trojan://CF68213490@prime-buzzard.rooster465.autos:443?allowInsecure=0&sni=prime-buzzard.rooster465.autos#SG🇸🇬 | prime-buzzard.rooster465.autos-443 | 236.32ms
trojan://CF68213490@present-ram.rooster465.autos:443?allowInsecure=0&sni=present-ram.rooster465.autos#JP🇯🇵 | present-ram.rooster465.autos-443 | 160.97ms
trojan://CF68213490@powerful-troll.rooster465.autos:443?allowInsecure=0&sni=powerful-troll.rooster465.autos#SG🇸🇬 | powerful-troll.rooster465.autos-443 | 238.16ms
trojan://CF68213490@normal-macaque.rooster465.autos:443?allowInsecure=0&sni=normal-macaque.rooster465.autos#SG🇸🇬 | normal-macaque.rooster465.autos-443 | 228.62ms
trojan://CF68213490@nearby-egret.rooster465.autos:443?allowInsecure=0&sni=nearby-egret.rooster465.autos#JP🇯🇵 | nearby-egret.rooster465.autos-443 | 178.86ms
trojan://CF68213490@musical-terrier.rooster465.autos:443?allowInsecure=0&sni=musical-terrier.rooster465.autos#SG🇸🇬 | musical-terrier.rooster465.autos-443 | 241.11ms
trojan://CF68213490@musical-manatee.rooster465.autos:443?allowInsecure=0&sni=musical-manatee.rooster465.autos#JP🇯🇵 | musical-manatee.rooster465.autos-443 | 167.58ms
trojan://CF68213490@moved-bluegill.rooster465.autos:443?allowInsecure=0&sni=moved-bluegill.rooster465.autos#JP🇯🇵 | moved-bluegill.rooster465.autos-443 | 164.44ms
trojan://CF68213490@moral-basilisk.rooster465.autos:443?allowInsecure=0&sni=moral-basilisk.rooster465.autos#SG🇸🇬 | moral-basilisk.rooster465.autos-443 | 240.4ms
trojan://CF68213490@modest-bat.rooster465.autos:443?allowInsecure=0&sni=modest-bat.rooster465.autos#SG🇸🇬 | modest-bat.rooster465.autos-443 | 212.34ms
trojan://CF68213490@lucky-chimp.rooster465.autos:443?allowInsecure=1&sni=lucky-chimp.rooster465.autos#SG🇸🇬 | lucky-chimp.rooster465.autos-443 | 253.19ms
trojan://CF68213490@loyal-molly.rooster465.autos:443?allowInsecure=0&sni=loyal-molly.rooster465.autos#JP🇯🇵 | loyal-molly.rooster465.autos-443 | 182.14ms
trojan://CF68213490@live-drake.rooster465.autos:443?allowInsecure=0&sni=live-drake.rooster465.autos#JP🇯🇵 | live-drake.rooster465.autos-443 | 175.73ms
trojan://CF68213490@learning-wren.rooster465.autos:443?allowInsecure=0&sni=learning-wren.rooster465.autos#SG🇸🇬 | learning-wren.rooster465.autos-443 | 238.5ms
trojan://CF68213490@intimate-moray.rooster465.autos:443?allowInsecure=0&sni=intimate-moray.rooster465.autos#SG🇸🇬 | intimate-moray.rooster465.autos-443 | 246.03ms
trojan://CF68213490@internal-krill.rooster465.autos:443?allowInsecure=0&sni=internal-krill.rooster465.autos#SG🇸🇬 | internal-krill.rooster465.autos-443 | 238.23ms
trojan://CF68213490@innocent-rattler.rooster465.autos:443?allowInsecure=0&sni=innocent-rattler.rooster465.autos#JP🇯🇵 | innocent-rattler.rooster465.autos-443 | 176.54ms
trojan://CF68213490@informed-stud.rooster465.autos:443?allowInsecure=0&sni=informed-stud.rooster465.autos#JP🇯🇵 | informed-stud.rooster465.autos-443 | 184.53ms
trojan://CF68213490@in-oriole.rooster465.autos:443?allowInsecure=0&sni=in-oriole.rooster465.autos#JP🇯🇵 | in-oriole.rooster465.autos-443 | 186.48ms
trojan://CF68213490@immune-mullet.rooster465.autos:443?allowInsecure=0&sni=immune-mullet.rooster465.autos#JP🇯🇵 | immune-mullet.rooster465.autos-443 | 146.19ms
trojan://CF68213490@immense-eagle.rooster465.autos:443?allowInsecure=0&sni=immense-eagle.rooster465.autos#SG🇸🇬 | immense-eagle.rooster465.autos-443 | 233.75ms
trojan://CF68213490@helping-shark.rooster465.autos:443?allowInsecure=0&sni=helping-shark.rooster465.autos#KR🇰🇷 | helping-shark.rooster465.autos-443 | 197.2ms
trojan://CF68213490@harmless-lab.rooster465.autos:443?allowInsecure=1&sni=harmless-lab.rooster465.autos#DE🇩🇪 | harmless-lab.rooster465.autos-443 | 163.49ms
trojan://CF68213490@harmless-lab.rooster465.autos:443?allowInsecure=1#DE🇩🇪 | harmless-lab.rooster465.autos-443 | 137.71ms
trojan://CF68213490@grateful-owl.rooster465.autos:443?allowInsecure=0&sni=grateful-owl.rooster465.autos#SG🇸🇬 | grateful-owl.rooster465.autos-443 | 230.81ms
trojan://CF68213490@gentle-raptor.rooster465.autos:443?allowInsecure=0&sni=gentle-raptor.rooster465.autos#SG🇸🇬 | gentle-raptor.rooster465.autos-443 | 235.34ms
trojan://CF68213490@gentle-mastiff.rooster465.autos:443?allowInsecure=0&sni=gentle-mastiff.rooster465.autos#KR🇰🇷 | gentle-mastiff.rooster465.autos-443 | 185.43ms
trojan://CF68213490@gentle-honeybee.rooster465.autos:443?allowInsecure=0&sni=gentle-honeybee.rooster465.autos#JP🇯🇵 | gentle-honeybee.rooster465.autos-443 | 164.22ms
trojan://CF68213490@funny-hen.rooster465.autos:443?allowInsecure=0&sni=funny-hen.rooster465.autos#JP🇯🇵 | funny-hen.rooster465.autos-443 | 168.16ms
trojan://CF68213490@funny-hawk.rooster465.autos:443?allowInsecure=0&sni=funny-hawk.rooster465.autos#JP🇯🇵 | funny-hawk.rooster465.autos-443 | 161.93ms
trojan://CF68213490@free-hare.rooster465.autos:443?allowInsecure=0&sni=free-hare.rooster465.autos#JP🇯🇵 | free-hare.rooster465.autos-443 | 169.59ms
trojan://CF68213490@fair-werewolf.rooster465.autos:443?allowInsecure=0&sni=fair-werewolf.rooster465.autos#JP🇯🇵 | fair-werewolf.rooster465.autos-443 | 174.1ms
trojan://CF68213490@evolving-platypus.rooster465.autos:443?allowInsecure=0&sni=evolving-platypus.rooster465.autos#SG🇸🇬 | evolving-platypus.rooster465.autos-443 | 231.06ms
trojan://CF68213490@evolving-mollusk.rooster465.autos:443?allowInsecure=0&sni=evolving-mollusk.rooster465.autos#JP🇯🇵 | evolving-mollusk.rooster465.autos-443 | 166.87ms
trojan://CF68213490@eternal-woodcock.rooster465.autos:443?allowInsecure=0&sni=eternal-woodcock.rooster465.autos#JP🇯🇵 | eternal-woodcock.rooster465.autos-443 | 179.53ms
trojan://CF68213490@eternal-perch.rooster465.autos:443?allowInsecure=0&sni=eternal-perch.rooster465.autos#JP🇯🇵 | eternal-perch.rooster465.autos-443 | 168.1ms
trojan://CF68213490@easy-barnacle.rooster465.autos:443?allowInsecure=0&sni=easy-barnacle.rooster465.autos#JP🇯🇵 | easy-barnacle.rooster465.autos-443 | 165.54ms
trojan://CF68213490@eager-platypus.rooster465.autos:443?allowInsecure=0&sni=eager-platypus.rooster465.autos#JP🇯🇵 | eager-platypus.rooster465.autos-443 | 168.23ms
trojan://CF68213490@concrete-aardvark.rooster465.autos:443?allowInsecure=0&sni=concrete-aardvark.rooster465.autos#JP🇯🇵 | concrete-aardvark.rooster465.autos-443 | 175.82ms
trojan://CF68213490@central-jawfish.rooster465.autos:443?allowInsecure=0&sni=central-jawfish.rooster465.autos#KR🇰🇷 | central-jawfish.rooster465.autos-443 | 195.69ms
trojan://CF68213490@caring-wallaby.rooster465.autos:443?allowInsecure=0&sni=caring-wallaby.rooster465.autos#JP🇯🇵 | caring-wallaby.rooster465.autos-443 | 183.64ms
trojan://CF68213490@bright-cicada.rooster465.autos:443?allowInsecure=0&sni=bright-cicada.rooster465.autos#SG🇸🇬 | bright-cicada.rooster465.autos-443 | 221.46ms
trojan://CF68213490@brief-warthog.rooster465.autos:443?allowInsecure=0&sni=brief-warthog.rooster465.autos#SG🇸🇬 | brief-warthog.rooster465.autos-443 | 234ms
trojan://CF68213490@alert-redfish.rooster465.autos:443?allowInsecure=0&sni=alert-redfish.rooster465.autos#JP🇯🇵 | alert-redfish.rooster465.autos-443 | 177.35ms
trojan://CF68213490@adapting-giraffe.rooster465.autos:443?allowInsecure=0&sni=adapting-giraffe.rooster465.autos#JP🇯🇵 | adapting-giraffe.rooster465.autos-443 | 180.35ms
trojan://CF68213490@active-hippo.rooster465.autos:443?allowInsecure=0&sni=active-hippo.rooster465.autos#SG🇸🇬 | active-hippo.rooster465.autos-443 | 243.04ms
trojan://Aimer@167.68.4.199:2053?host=epge.muarua.filegear-sg.me&path=%2F&sni=epge.muarua.filegear-sg.me&type=ws#RELAY🚩 | epge.muarua.filegear-sg.me-2053 | 537.43ms
trojan://Aimer@167.68.4.199:2053?ed=2560&eh=Sec-WebSocket-Protocol&host=epge.muarua.filegear-sg.me&path=%2F%3Fproxyip%3Dts.hpc.tw&sni=epge.muarua.filegear-sg.me&type=ws#RELAY🚩 | epge.muarua.filegear-sg.me-2053 | 10.62ms
trojan://9yu6m5okr@production.tj.ojan.workers.dev:443?path=%2F&security=tls&host=production.tj.ojan.workers.dev&type=ws&sni=production.tj.ojan.workers.dev#RELAY🚩 | production.tj.ojan.workers.dev-443 | 76.47ms
trojan://8r%3C%5B9%27l6hAO%238ZQi@94.242.53.94:8443?path=%2FtrTelegram%F0%9F%87%A8%F0%9F%87%B3%2B%40WangCai2&security=tls&insecure=0&host=Koma-YT.PAGeS.Dev&type=ws&allowInsecure=0&sni=Koma-YT.PAGeS.Dev#RELAY🚩 | Koma-YT.PAGeS.Dev-8443 | 81.49ms
trojan://8r%3C%5B9%27l6hAO%238ZQi@213.176.113.98:2053?path=%2FtrTelegram%F0%9F%87%A8%F0%9F%87%B3%2B%40WangCai2&security=tls&insecure=0&host=Koma-YT.PAGeS.Dev&type=ws&allowInsecure=0&sni=Koma-YT.PAGeS.Dev#RELAY🚩 | Koma-YT.PAGeS.Dev-2053 | 13.09ms
trojan://8r%3C%5B9%27l6hAO%238ZQi@212.34.146.229:8443?path=%2FtrTelegram%F0%9F%87%A8%F0%9F%87%B3%2B%40WangCai2&security=tls&insecure=0&host=Koma-YT.PAGeS.Dev&type=ws&allowInsecure=0&sni=Koma-YT.PAGeS.Dev#RELAY🚩 | Koma-YT.PAGeS.Dev-8443 | 7.38ms
trojan://8r%3C%5B9%27l6hAO%238ZQi@185.102.136.51:2053?path=%2FtrTelegram%F0%9F%87%A8%F0%9F%87%B3%2B%40WangCai2&security=tls&insecure=0&host=Koma-YT.PAGeS.Dev&type=ws&allowInsecure=0&sni=Koma-YT.PAGeS.Dev#RELAY🚩 | Koma-YT.PAGeS.Dev-2053 | 9.31ms
trojan://8r%3C%5B9%27l6hAO%238ZQi@18.194.183.74:2053?path=%2FtrTelegram%F0%9F%87%A8%F0%9F%87%B3%2B%40WangCai2&security=tls&insecure=0&host=Koma-YT.PAGeS.Dev&type=ws&allowInsecure=0&sni=Koma-YT.PAGeS.Dev#RELAY🚩 | Koma-YT.PAGeS.Dev-2053 | 15.23ms
trojan://8OXD5VVt8s@176.32.39.29:443?security=reality&pbk=f_av3K6BFEs9abRaFgPJMKHz4ElZP7BP34ZlRtxysQ0&headerType=none&fp=random&spx=%2FyethePcHjaf&type=tcp&sni=journalofbigdata.springeropen.com&sid=109cb5faeb6b#REALITY|US🇺🇸 | journalofbigdata.springeropen.com-443 | 120.58ms
trojan://86957ec0-b213-433b-a43b-51f2175e0ec3@45.130.125.126:443?path=%2Fau-do&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 10.73ms
trojan://86957ec0-b213-433b-a43b-51f2175e0ec3@104.16.72.70:443?path=%2Fau-do&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 16.24ms
trojan://86957ec0-b213-433b-a43b-51f2175e0ec3@104.16.72.41:443?path=%2Fau-do&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 6.96ms
trojan://86957ec0-b213-433b-a43b-51f2175e0ec3@104.16.72.2:443?type=ws&security=tls&path=%2Fau-do&host=space.byu.id.yxls.eu.cc&sni=space.byu.id.yxls.eu.cc&insecure=0&allowInsecure=0#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 14.12ms
trojan://86957ec0-b213-433b-a43b-51f2175e0ec3@104.16.72.2:443?path=%2Fau-do&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 7.18ms
trojan://86957ec0-b213-433b-a43b-51f2175e0ec3@104.16.72.101:443?path=%2Fau-do&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 9.35ms
trojan://6c862415-30d2-4813-8e49-42e99a0bd415@104.16.72.70:443?type=ws&security=tls&path=%2Fus-gllc&host=space.byu.id.yxls.eu.cc&sni=space.byu.id.yxls.eu.cc&insecure=1&allowInsecure=1#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 11.1ms
trojan://6c862415-30d2-4813-8e49-42e99a0bd415@104.16.72.70:443?type=ws&host=space.byu.id.yxls.eu.cc&path=%2Fus-gllc&security=tls&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 10.53ms
trojan://6c862415-30d2-4813-8e49-42e99a0bd415@104.16.72.70:443?path=%2Fus-gllc&security=tls&insecure=0&host=space.byu.id.yxls.eu.cc&type=ws&allowInsecure=0&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 7.22ms
trojan://6c862415-30d2-4813-8e49-42e99a0bd415@104.16.72.70:443?path=%2Fus-gllc&security=tls&host=space.byu.id.yxls.eu.cc&allowinsecure=0&type=ws&sni=space.byu.id.yxls.eu.cc#RELAY🚩 | space.byu.id.yxls.eu.cc-443 | 9.96ms
trojan://6202b230-417c-4d8e-b624-0f71afa9c75d@104.17.101.139:443?path=%2F%3Fproxyip%3Dip.111000.de5.net%253A443&security=tls&alpn=http%2F1.1&insecure=1&host=sni.111000.dynv6.net&type=ws&allowInsecure=1&sni=sni.111000.dynv6.net#RELAY🚩 | sni.111000.dynv6.net-443 | 101.49ms
trojan://5301502@198.62.62.239:443?security=tls&type=ws&sni=fc071d49-af91-42d6-a20e-5a64e24a53bc.71a45835-dd0c-4d51-8bd4-9ccf9f223662.casacam.net&path=%2Ftrojan-9tc.pages.dev%2F&host=fc071d49-af91-42d6-a20e-5a64e24a53bc.71a45835-dd0c-4d51-8bd4-9ccf9f223662.casacam.neth3#RELAY🚩 | fc071d49-af91-42d6-a20e-5a64e24a53bc.71a45835-dd0c-4d51-8bd4-9ccf9f223662.casacam.net-443 | 146.63ms
trojan://52701795-3c3b-46b4-b7cf-c5978b3a4cf2@172.67.149.124:443?security=tls&type=grpc&sni=hdfyc1.achaemenidempireofpersia.uk#RELAY🚩 | hdfyc1.achaemenidempireofpersia.uk-443 | 281.99ms
trojan://521314@wangcai.yunzhongzhuan.com:443?host=tjplay.lxdxo.kdns.fr&path=Telegram%F0%9F%87%A8%F0%9F%87%B3&sni=tjplay.lxdxo.kdns.fr&type=ws#RELAY🚩 | tjplay.lxdxo.kdns.fr-443 | 382.16ms
trojan://521314@45.131.5.9:443?host=tjplay.lxdxo.kdns.fr&path=%2FTelegram%F0%9F%87%A8%F0%9F%87%B3%2B%40WangCai2&sni=tjplay.lxdxo.kdns.fr&type=ws#RELAY🚩 | tjplay.lxdxo.kdns.fr-443 | 7.57ms
trojan://521314@104.248.161.136:443?path=%2F&security=tls&insecure=1&host=tjplay.lxdxo.kdns.fr&type=ws&allowInsecure=1&sni=tjplay.lxdxo.kdns.fr#RELAY🚩 | tjplay.lxdxo.kdns.fr-443 | 7.43ms
trojan://521314@104.248.161.136:443?path=%2F&security=tls&insecure=0&host=tjplay.lxdxo.kdns.fr&type=ws&allowInsecure=0&sni=tjplay.lxdxo.kdns.fr#RELAY🚩 | tjplay.lxdxo.kdns.fr-443 | 14.04ms
trojan://521314@104.248.161.136:443?host=tjplay.lxdxo.kdns.fr&path=%2F&sni=tjplay.lxdxo.kdns.fr&type=ws#RELAY🚩 | tjplay.lxdxo.kdns.fr-443 | 9.96ms
trojan://521314@104.248.161.136:443?allowInsecure=1&host=tjplay.lxdxo.kdns.fr&path=%2F&sni=tjplay.lxdxo.kdns.fr&type=ws#RELAY🚩 | tjplay.lxdxo.kdns.fr-443 | 8.34ms
trojan://2cba4104747d49d18319e5ade1b93ab5@198.41.220.10:443?security=tls&type=ws&sni=jobscareerforstudent.com&path=6b777a91&host=jobscareerforstudent.com#US🇺🇸 | jobscareerforstudent.com-443 | 200.06ms
trojan://19b7a240-6eb1-11ef-b7d5-1239d0255272@www.speedtest.net:443?type=ws&sni=usa.test3.net&path=%2Fhowdy&host=usa.test3.net#US🇺🇸 | usa.test3.net-443 | 109.81ms
trojan://%4D%69%54%69%56%50%4E@www.hcaptcha.com:443?path=%2FMiTiVPN%3DNL&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 139.55ms
trojan://%4D%69%54%69%56%50%4E@assets.fiverr.com:443?path=%2FMiTiVPN%3DNL&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 125.53ms
trojan://%4D%69%54%69%56%50%4E@91.193.58.201:443?path=%2FMiTiVPN%3DNL&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 127.47ms
trojan://%4D%69%54%69%56%50%4E@45.131.4.115:443?path=%2FMiTiVPN%3DUsa&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 236.74ms
trojan://%4D%69%54%69%56%50%4E@104.16.72.41:443?path=%2FMiTiVPN%3DSe&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 244.59ms
trojan://%4D%69%54%69%56%50%4E@104.16.72.41:443?path=%2FMiTiVPN%3DDe&security=tls&alpn=http%2F1.1&insecure=0&host=PioHosting.ir&fp=firefox&type=ws&allowInsecure=0&sni=PioHosting.ir#IR🇮🇷 | PioHosting.ir-443 | 124.15ms