From b7e037de5619aba9993de60708aaf8b119ccaff7 Mon Sep 17 00:00:00 2001 From: etfans <124616173+etfans@users.noreply.github.com> Date: Sun, 28 May 2023 00:54:56 +0800 Subject: [PATCH] init cf worker code --- .gitignore | 5 + config/config-client-with-dns-lcoal.json | 72 + config/config-client-without-dns-lcoal.json | 72 + dist/README.md | 1 + dist/cidr.js | 2971 ++++++++ dist/cidr.js.map | 8 + jsonconfig.json | 16 + package.json | 21 + src/worker-vless.js | 7188 +++++++++++++++++++ test/cidr.js | 6548 +++++++++++++++++ test/webstream.mjs | 73 + test/worker/cf-cdn-cgi-trace.js | 11 + test/worker/cf-worker-http-header.js | 22 + test/worker/cidr.js | 33 + test/worker/ipaddr-test.js | 1029 +++ test/worker/stream-ws-test.js | 55 + test/worker/worker-connect-test.js | 46 + test/worker/wrangler.toml | 6 + test/worker/ws-send-issue.js | 60 + wrangler.toml | 7 + 20 files changed, 18244 insertions(+) create mode 100644 .gitignore create mode 100644 config/config-client-with-dns-lcoal.json create mode 100644 config/config-client-without-dns-lcoal.json create mode 100644 dist/README.md create mode 100644 dist/cidr.js create mode 100644 dist/cidr.js.map create mode 100644 jsonconfig.json create mode 100644 package.json create mode 100644 src/worker-vless.js create mode 100644 test/cidr.js create mode 100644 test/webstream.mjs create mode 100644 test/worker/cf-cdn-cgi-trace.js create mode 100644 test/worker/cf-worker-http-header.js create mode 100644 test/worker/cidr.js create mode 100644 test/worker/ipaddr-test.js create mode 100644 test/worker/stream-ws-test.js create mode 100644 test/worker/worker-connect-test.js create mode 100644 test/worker/wrangler.toml create mode 100644 test/worker/ws-send-issue.js create mode 100644 wrangler.toml diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f8adeed --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.DS_Store +/node_modules +*-lock.* +*.lock +*.log \ No newline at end of file diff --git a/config/config-client-with-dns-lcoal.json b/config/config-client-with-dns-lcoal.json new file mode 100644 index 0000000..cd37300 --- /dev/null +++ b/config/config-client-with-dns-lcoal.json @@ -0,0 +1,72 @@ +{ + "log": { + "loglevel": "debug" + }, + "inbounds": [ + { + "listen": "0.0.0.0", + "port": "4080", + "protocol": "socks", + "settings": { + "auth": "noauth", + "udp": true, + "ip": "0.0.0.0" + } + }, + { + "listen": "0.0.0.0", + "port": "4081", + "protocol": "http" + } + ], + "dns": { + "servers": ["8.8.8.8"] + }, + "outbounds": [ + { + "protocol": "vless", + "settings": { + "vnext": [ + { + "address": "127.0.0.1", + "port": 8788, + "users": [ + { + "id": "1a403b79-039b-4dc2-9b45-1ad13197b99a", + "encryption": "none", + "level": 0 + } + ] + } + ] + }, + "streamSettings": { + "network": "ws", + "wsSettings": { + "path": "/vless" + } + // "security": "tls" + }, + "tag": "zizi-ws" + }, + { + "protocol": "freedom", + "tag": "direct" + } + ], + "routing": { + "domainStrategy": "IPIfNonMatch", + "rules": [ + { + "type": "field", + "ip": ["8.8.8.8"], + "outboundTag": "zizi-ws" + }, + { + "type": "field", + "ip": ["geoip:private"], + "outboundTag": "zizi-ws" + } + ] + } +} diff --git a/config/config-client-without-dns-lcoal.json b/config/config-client-without-dns-lcoal.json new file mode 100644 index 0000000..77af096 --- /dev/null +++ b/config/config-client-without-dns-lcoal.json @@ -0,0 +1,72 @@ +{ + "log": { + "loglevel": "debug" + }, + "inbounds": [ + { + "listen": "0.0.0.0", + "port": "4080", + "protocol": "socks", + "settings": { + "auth": "noauth", + "udp": true, + "ip": "0.0.0.0" + } + }, + { + "listen": "0.0.0.0", + "port": "4081", + "protocol": "http" + } + ], + "dns": { + "servers": ["8.8.8.8"] + }, + "outbounds": [ + { + "protocol": "vless", + "settings": { + "vnext": [ + { + "address": "127.0.0.1", + "port": 8787, + "users": [ + { + "id": "1a403b79-039b-4dc2-9b45-1ad13197b99a", + "encryption": "none", + "level": 0 + } + ] + } + ] + }, + "streamSettings": { + "network": "ws" + // "wsSettings": { + // "path": "/node-vless" + // } + // "security": "tls" + }, + "tag": "zizi-ws" + }, + { + "protocol": "freedom", + "tag": "direct" + } + ], + "routing": { + "domainStrategy": "IPIfNonMatch", + "rules": [ + { + "type": "field", + "ip": ["8.8.8.8"], + "outboundTag": "zizi-ws" + }, + { + "type": "field", + "ip": ["geoip:private"], + "outboundTag": "zizi-ws" + } + ] + } +} diff --git a/dist/README.md b/dist/README.md new file mode 100644 index 0000000..fc6ba03 --- /dev/null +++ b/dist/README.md @@ -0,0 +1 @@ +This folder contains the built output assets for the worker "cf-worker-ws-dev" generated at 2023-05-26T18:01:56.750Z. \ No newline at end of file diff --git a/dist/cidr.js b/dist/cidr.js new file mode 100644 index 0000000..104de23 --- /dev/null +++ b/dist/cidr.js @@ -0,0 +1,2971 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// node_modules/ip-address/dist/lib/common.js +var require_common = __commonJS({ + "node_modules/ip-address/dist/lib/common.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isCorrect = exports.isInSubnet = void 0; + function isInSubnet(address) { + if (this.subnetMask < address.subnetMask) { + return false; + } + if (this.mask(address.subnetMask) === address.mask()) { + return true; + } + return false; + } + exports.isInSubnet = isInSubnet; + function isCorrect(defaultBits) { + return function() { + if (this.addressMinusSuffix !== this.correctForm()) { + return false; + } + if (this.subnetMask === defaultBits && !this.parsedSubnet) { + return true; + } + return this.parsedSubnet === String(this.subnetMask); + }; + } + exports.isCorrect = isCorrect; + } +}); + +// node_modules/ip-address/dist/lib/v4/constants.js +var require_constants = __commonJS({ + "node_modules/ip-address/dist/lib/v4/constants.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = void 0; + exports.BITS = 32; + exports.GROUPS = 4; + exports.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/g; + exports.RE_SUBNET_STRING = /\/\d{1,2}$/; + } +}); + +// node_modules/ip-address/dist/lib/address-error.js +var require_address_error = __commonJS({ + "node_modules/ip-address/dist/lib/address-error.js"(exports) { + "use strict"; + var __extends = exports && exports.__extends || function() { + var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { + d2.__proto__ = b2; + } || function(d2, b2) { + for (var p in b2) + if (Object.prototype.hasOwnProperty.call(b2, p)) + d2[p] = b2[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + }(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AddressError = void 0; + var AddressError = function(_super) { + __extends(AddressError2, _super); + function AddressError2(message, parseMessage) { + var _this = _super.call(this, message) || this; + _this.name = "AddressError"; + if (parseMessage !== null) { + _this.parseMessage = parseMessage; + } + return _this; + } + return AddressError2; + }(Error); + exports.AddressError = AddressError; + } +}); + +// node_modules/jsbn/index.js +var require_jsbn = __commonJS({ + "node_modules/jsbn/index.js"(exports, module) { + (function() { + var dbits; + var canary = 244837814094590; + var j_lm = (canary & 16777215) == 15715070; + function BigInteger(a, b, c) { + if (a != null) + if ("number" == typeof a) + this.fromNumber(a, b, c); + else if (b == null && "string" != typeof a) + this.fromString(a, 256); + else + this.fromString(a, b); + } + function nbi() { + return new BigInteger(null); + } + function am1(i, x, w, j, c, n) { + while (--n >= 0) { + var v = x * this[i++] + w[j] + c; + c = Math.floor(v / 67108864); + w[j++] = v & 67108863; + } + return c; + } + function am2(i, x, w, j, c, n) { + var xl = x & 32767, xh = x >> 15; + while (--n >= 0) { + var l = this[i] & 32767; + var h = this[i++] >> 15; + var m = xh * l + h * xl; + l = xl * l + ((m & 32767) << 15) + w[j] + (c & 1073741823); + c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30); + w[j++] = l & 1073741823; + } + return c; + } + function am3(i, x, w, j, c, n) { + var xl = x & 16383, xh = x >> 14; + while (--n >= 0) { + var l = this[i] & 16383; + var h = this[i++] >> 14; + var m = xh * l + h * xl; + l = xl * l + ((m & 16383) << 14) + w[j] + c; + c = (l >> 28) + (m >> 14) + xh * h; + w[j++] = l & 268435455; + } + return c; + } + var inBrowser = typeof navigator !== "undefined"; + if (inBrowser && j_lm && navigator.appName == "Microsoft Internet Explorer") { + BigInteger.prototype.am = am2; + dbits = 30; + } else if (inBrowser && j_lm && navigator.appName != "Netscape") { + BigInteger.prototype.am = am1; + dbits = 26; + } else { + BigInteger.prototype.am = am3; + dbits = 28; + } + BigInteger.prototype.DB = dbits; + BigInteger.prototype.DM = (1 << dbits) - 1; + BigInteger.prototype.DV = 1 << dbits; + var BI_FP = 52; + BigInteger.prototype.FV = Math.pow(2, BI_FP); + BigInteger.prototype.F1 = BI_FP - dbits; + BigInteger.prototype.F2 = 2 * dbits - BI_FP; + var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz"; + var BI_RC = new Array(); + var rr, vv; + rr = "0".charCodeAt(0); + for (vv = 0; vv <= 9; ++vv) + BI_RC[rr++] = vv; + rr = "a".charCodeAt(0); + for (vv = 10; vv < 36; ++vv) + BI_RC[rr++] = vv; + rr = "A".charCodeAt(0); + for (vv = 10; vv < 36; ++vv) + BI_RC[rr++] = vv; + function int2char(n) { + return BI_RM.charAt(n); + } + function intAt(s, i) { + var c = BI_RC[s.charCodeAt(i)]; + return c == null ? -1 : c; + } + function bnpCopyTo(r) { + for (var i = this.t - 1; i >= 0; --i) + r[i] = this[i]; + r.t = this.t; + r.s = this.s; + } + function bnpFromInt(x) { + this.t = 1; + this.s = x < 0 ? -1 : 0; + if (x > 0) + this[0] = x; + else if (x < -1) + this[0] = x + this.DV; + else + this.t = 0; + } + function nbv(i) { + var r = nbi(); + r.fromInt(i); + return r; + } + function bnpFromString(s, b) { + var k; + if (b == 16) + k = 4; + else if (b == 8) + k = 3; + else if (b == 256) + k = 8; + else if (b == 2) + k = 1; + else if (b == 32) + k = 5; + else if (b == 4) + k = 2; + else { + this.fromRadix(s, b); + return; + } + this.t = 0; + this.s = 0; + var i = s.length, mi = false, sh = 0; + while (--i >= 0) { + var x = k == 8 ? s[i] & 255 : intAt(s, i); + if (x < 0) { + if (s.charAt(i) == "-") + mi = true; + continue; + } + mi = false; + if (sh == 0) + this[this.t++] = x; + else if (sh + k > this.DB) { + this[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh; + this[this.t++] = x >> this.DB - sh; + } else + this[this.t - 1] |= x << sh; + sh += k; + if (sh >= this.DB) + sh -= this.DB; + } + if (k == 8 && (s[0] & 128) != 0) { + this.s = -1; + if (sh > 0) + this[this.t - 1] |= (1 << this.DB - sh) - 1 << sh; + } + this.clamp(); + if (mi) + BigInteger.ZERO.subTo(this, this); + } + function bnpClamp() { + var c = this.s & this.DM; + while (this.t > 0 && this[this.t - 1] == c) + --this.t; + } + function bnToString(b) { + if (this.s < 0) + return "-" + this.negate().toString(b); + var k; + if (b == 16) + k = 4; + else if (b == 8) + k = 3; + else if (b == 2) + k = 1; + else if (b == 32) + k = 5; + else if (b == 4) + k = 2; + else + return this.toRadix(b); + var km = (1 << k) - 1, d, m = false, r = "", i = this.t; + var p = this.DB - i * this.DB % k; + if (i-- > 0) { + if (p < this.DB && (d = this[i] >> p) > 0) { + m = true; + r = int2char(d); + } + while (i >= 0) { + if (p < k) { + d = (this[i] & (1 << p) - 1) << k - p; + d |= this[--i] >> (p += this.DB - k); + } else { + d = this[i] >> (p -= k) & km; + if (p <= 0) { + p += this.DB; + --i; + } + } + if (d > 0) + m = true; + if (m) + r += int2char(d); + } + } + return m ? r : "0"; + } + function bnNegate() { + var r = nbi(); + BigInteger.ZERO.subTo(this, r); + return r; + } + function bnAbs() { + return this.s < 0 ? this.negate() : this; + } + function bnCompareTo(a) { + var r = this.s - a.s; + if (r != 0) + return r; + var i = this.t; + r = i - a.t; + if (r != 0) + return this.s < 0 ? -r : r; + while (--i >= 0) + if ((r = this[i] - a[i]) != 0) + return r; + return 0; + } + function nbits(x) { + var r = 1, t2; + if ((t2 = x >>> 16) != 0) { + x = t2; + r += 16; + } + if ((t2 = x >> 8) != 0) { + x = t2; + r += 8; + } + if ((t2 = x >> 4) != 0) { + x = t2; + r += 4; + } + if ((t2 = x >> 2) != 0) { + x = t2; + r += 2; + } + if ((t2 = x >> 1) != 0) { + x = t2; + r += 1; + } + return r; + } + function bnBitLength() { + if (this.t <= 0) + return 0; + return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM); + } + function bnpDLShiftTo(n, r) { + var i; + for (i = this.t - 1; i >= 0; --i) + r[i + n] = this[i]; + for (i = n - 1; i >= 0; --i) + r[i] = 0; + r.t = this.t + n; + r.s = this.s; + } + function bnpDRShiftTo(n, r) { + for (var i = n; i < this.t; ++i) + r[i - n] = this[i]; + r.t = Math.max(this.t - n, 0); + r.s = this.s; + } + function bnpLShiftTo(n, r) { + var bs = n % this.DB; + var cbs = this.DB - bs; + var bm = (1 << cbs) - 1; + var ds = Math.floor(n / this.DB), c = this.s << bs & this.DM, i; + for (i = this.t - 1; i >= 0; --i) { + r[i + ds + 1] = this[i] >> cbs | c; + c = (this[i] & bm) << bs; + } + for (i = ds - 1; i >= 0; --i) + r[i] = 0; + r[ds] = c; + r.t = this.t + ds + 1; + r.s = this.s; + r.clamp(); + } + function bnpRShiftTo(n, r) { + r.s = this.s; + var ds = Math.floor(n / this.DB); + if (ds >= this.t) { + r.t = 0; + return; + } + var bs = n % this.DB; + var cbs = this.DB - bs; + var bm = (1 << bs) - 1; + r[0] = this[ds] >> bs; + for (var i = ds + 1; i < this.t; ++i) { + r[i - ds - 1] |= (this[i] & bm) << cbs; + r[i - ds] = this[i] >> bs; + } + if (bs > 0) + r[this.t - ds - 1] |= (this.s & bm) << cbs; + r.t = this.t - ds; + r.clamp(); + } + function bnpSubTo(a, r) { + var i = 0, c = 0, m = Math.min(a.t, this.t); + while (i < m) { + c += this[i] - a[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + if (a.t < this.t) { + c -= a.s; + while (i < this.t) { + c += this[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + c += this.s; + } else { + c += this.s; + while (i < a.t) { + c -= a[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + c -= a.s; + } + r.s = c < 0 ? -1 : 0; + if (c < -1) + r[i++] = this.DV + c; + else if (c > 0) + r[i++] = c; + r.t = i; + r.clamp(); + } + function bnpMultiplyTo(a, r) { + var x = this.abs(), y = a.abs(); + var i = x.t; + r.t = i + y.t; + while (--i >= 0) + r[i] = 0; + for (i = 0; i < y.t; ++i) + r[i + x.t] = x.am(0, y[i], r, i, 0, x.t); + r.s = 0; + r.clamp(); + if (this.s != a.s) + BigInteger.ZERO.subTo(r, r); + } + function bnpSquareTo(r) { + var x = this.abs(); + var i = r.t = 2 * x.t; + while (--i >= 0) + r[i] = 0; + for (i = 0; i < x.t - 1; ++i) { + var c = x.am(i, x[i], r, 2 * i, 0, 1); + if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) { + r[i + x.t] -= x.DV; + r[i + x.t + 1] = 1; + } + } + if (r.t > 0) + r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1); + r.s = 0; + r.clamp(); + } + function bnpDivRemTo(m, q, r) { + var pm = m.abs(); + if (pm.t <= 0) + return; + var pt = this.abs(); + if (pt.t < pm.t) { + if (q != null) + q.fromInt(0); + if (r != null) + this.copyTo(r); + return; + } + if (r == null) + r = nbi(); + var y = nbi(), ts = this.s, ms = m.s; + var nsh = this.DB - nbits(pm[pm.t - 1]); + if (nsh > 0) { + pm.lShiftTo(nsh, y); + pt.lShiftTo(nsh, r); + } else { + pm.copyTo(y); + pt.copyTo(r); + } + var ys = y.t; + var y0 = y[ys - 1]; + if (y0 == 0) + return; + var yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0); + var d1 = this.FV / yt, d2 = (1 << this.F1) / yt, e = 1 << this.F2; + var i = r.t, j = i - ys, t2 = q == null ? nbi() : q; + y.dlShiftTo(j, t2); + if (r.compareTo(t2) >= 0) { + r[r.t++] = 1; + r.subTo(t2, r); + } + BigInteger.ONE.dlShiftTo(ys, t2); + t2.subTo(y, y); + while (y.t < ys) + y[y.t++] = 0; + while (--j >= 0) { + var qd = r[--i] == y0 ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2); + if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { + y.dlShiftTo(j, t2); + r.subTo(t2, r); + while (r[i] < --qd) + r.subTo(t2, r); + } + } + if (q != null) { + r.drShiftTo(ys, q); + if (ts != ms) + BigInteger.ZERO.subTo(q, q); + } + r.t = ys; + r.clamp(); + if (nsh > 0) + r.rShiftTo(nsh, r); + if (ts < 0) + BigInteger.ZERO.subTo(r, r); + } + function bnMod(a) { + var r = nbi(); + this.abs().divRemTo(a, null, r); + if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) + a.subTo(r, r); + return r; + } + function Classic(m) { + this.m = m; + } + function cConvert(x) { + if (x.s < 0 || x.compareTo(this.m) >= 0) + return x.mod(this.m); + else + return x; + } + function cRevert(x) { + return x; + } + function cReduce(x) { + x.divRemTo(this.m, null, x); + } + function cMulTo(x, y, r) { + x.multiplyTo(y, r); + this.reduce(r); + } + function cSqrTo(x, r) { + x.squareTo(r); + this.reduce(r); + } + Classic.prototype.convert = cConvert; + Classic.prototype.revert = cRevert; + Classic.prototype.reduce = cReduce; + Classic.prototype.mulTo = cMulTo; + Classic.prototype.sqrTo = cSqrTo; + function bnpInvDigit() { + if (this.t < 1) + return 0; + var x = this[0]; + if ((x & 1) == 0) + return 0; + var y = x & 3; + y = y * (2 - (x & 15) * y) & 15; + y = y * (2 - (x & 255) * y) & 255; + y = y * (2 - ((x & 65535) * y & 65535)) & 65535; + y = y * (2 - x * y % this.DV) % this.DV; + return y > 0 ? this.DV - y : -y; + } + function Montgomery(m) { + this.m = m; + this.mp = m.invDigit(); + this.mpl = this.mp & 32767; + this.mph = this.mp >> 15; + this.um = (1 << m.DB - 15) - 1; + this.mt2 = 2 * m.t; + } + function montConvert(x) { + var r = nbi(); + x.abs().dlShiftTo(this.m.t, r); + r.divRemTo(this.m, null, r); + if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) + this.m.subTo(r, r); + return r; + } + function montRevert(x) { + var r = nbi(); + x.copyTo(r); + this.reduce(r); + return r; + } + function montReduce(x) { + while (x.t <= this.mt2) + x[x.t++] = 0; + for (var i = 0; i < this.m.t; ++i) { + var j = x[i] & 32767; + var u0 = j * this.mpl + ((j * this.mph + (x[i] >> 15) * this.mpl & this.um) << 15) & x.DM; + j = i + this.m.t; + x[j] += this.m.am(0, u0, x, i, 0, this.m.t); + while (x[j] >= x.DV) { + x[j] -= x.DV; + x[++j]++; + } + } + x.clamp(); + x.drShiftTo(this.m.t, x); + if (x.compareTo(this.m) >= 0) + x.subTo(this.m, x); + } + function montSqrTo(x, r) { + x.squareTo(r); + this.reduce(r); + } + function montMulTo(x, y, r) { + x.multiplyTo(y, r); + this.reduce(r); + } + Montgomery.prototype.convert = montConvert; + Montgomery.prototype.revert = montRevert; + Montgomery.prototype.reduce = montReduce; + Montgomery.prototype.mulTo = montMulTo; + Montgomery.prototype.sqrTo = montSqrTo; + function bnpIsEven() { + return (this.t > 0 ? this[0] & 1 : this.s) == 0; + } + function bnpExp(e, z2) { + if (e > 4294967295 || e < 1) + return BigInteger.ONE; + var r = nbi(), r2 = nbi(), g = z2.convert(this), i = nbits(e) - 1; + g.copyTo(r); + while (--i >= 0) { + z2.sqrTo(r, r2); + if ((e & 1 << i) > 0) + z2.mulTo(r2, g, r); + else { + var t2 = r; + r = r2; + r2 = t2; + } + } + return z2.revert(r); + } + function bnModPowInt(e, m) { + var z2; + if (e < 256 || m.isEven()) + z2 = new Classic(m); + else + z2 = new Montgomery(m); + return this.exp(e, z2); + } + BigInteger.prototype.copyTo = bnpCopyTo; + BigInteger.prototype.fromInt = bnpFromInt; + BigInteger.prototype.fromString = bnpFromString; + BigInteger.prototype.clamp = bnpClamp; + BigInteger.prototype.dlShiftTo = bnpDLShiftTo; + BigInteger.prototype.drShiftTo = bnpDRShiftTo; + BigInteger.prototype.lShiftTo = bnpLShiftTo; + BigInteger.prototype.rShiftTo = bnpRShiftTo; + BigInteger.prototype.subTo = bnpSubTo; + BigInteger.prototype.multiplyTo = bnpMultiplyTo; + BigInteger.prototype.squareTo = bnpSquareTo; + BigInteger.prototype.divRemTo = bnpDivRemTo; + BigInteger.prototype.invDigit = bnpInvDigit; + BigInteger.prototype.isEven = bnpIsEven; + BigInteger.prototype.exp = bnpExp; + BigInteger.prototype.toString = bnToString; + BigInteger.prototype.negate = bnNegate; + BigInteger.prototype.abs = bnAbs; + BigInteger.prototype.compareTo = bnCompareTo; + BigInteger.prototype.bitLength = bnBitLength; + BigInteger.prototype.mod = bnMod; + BigInteger.prototype.modPowInt = bnModPowInt; + BigInteger.ZERO = nbv(0); + BigInteger.ONE = nbv(1); + function bnClone() { + var r = nbi(); + this.copyTo(r); + return r; + } + function bnIntValue() { + if (this.s < 0) { + if (this.t == 1) + return this[0] - this.DV; + else if (this.t == 0) + return -1; + } else if (this.t == 1) + return this[0]; + else if (this.t == 0) + return 0; + return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0]; + } + function bnByteValue() { + return this.t == 0 ? this.s : this[0] << 24 >> 24; + } + function bnShortValue() { + return this.t == 0 ? this.s : this[0] << 16 >> 16; + } + function bnpChunkSize(r) { + return Math.floor(Math.LN2 * this.DB / Math.log(r)); + } + function bnSigNum() { + if (this.s < 0) + return -1; + else if (this.t <= 0 || this.t == 1 && this[0] <= 0) + return 0; + else + return 1; + } + function bnpToRadix(b) { + if (b == null) + b = 10; + if (this.signum() == 0 || b < 2 || b > 36) + return "0"; + var cs = this.chunkSize(b); + var a = Math.pow(b, cs); + var d = nbv(a), y = nbi(), z2 = nbi(), r = ""; + this.divRemTo(d, y, z2); + while (y.signum() > 0) { + r = (a + z2.intValue()).toString(b).substr(1) + r; + y.divRemTo(d, y, z2); + } + return z2.intValue().toString(b) + r; + } + function bnpFromRadix(s, b) { + this.fromInt(0); + if (b == null) + b = 10; + var cs = this.chunkSize(b); + var d = Math.pow(b, cs), mi = false, j = 0, w = 0; + for (var i = 0; i < s.length; ++i) { + var x = intAt(s, i); + if (x < 0) { + if (s.charAt(i) == "-" && this.signum() == 0) + mi = true; + continue; + } + w = b * w + x; + if (++j >= cs) { + this.dMultiply(d); + this.dAddOffset(w, 0); + j = 0; + w = 0; + } + } + if (j > 0) { + this.dMultiply(Math.pow(b, j)); + this.dAddOffset(w, 0); + } + if (mi) + BigInteger.ZERO.subTo(this, this); + } + function bnpFromNumber(a, b, c) { + if ("number" == typeof b) { + if (a < 2) + this.fromInt(1); + else { + this.fromNumber(a, c); + if (!this.testBit(a - 1)) + this.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, this); + if (this.isEven()) + this.dAddOffset(1, 0); + while (!this.isProbablePrime(b)) { + this.dAddOffset(2, 0); + if (this.bitLength() > a) + this.subTo(BigInteger.ONE.shiftLeft(a - 1), this); + } + } + } else { + var x = new Array(), t2 = a & 7; + x.length = (a >> 3) + 1; + b.nextBytes(x); + if (t2 > 0) + x[0] &= (1 << t2) - 1; + else + x[0] = 0; + this.fromString(x, 256); + } + } + function bnToByteArray() { + var i = this.t, r = new Array(); + r[0] = this.s; + var p = this.DB - i * this.DB % 8, d, k = 0; + if (i-- > 0) { + if (p < this.DB && (d = this[i] >> p) != (this.s & this.DM) >> p) + r[k++] = d | this.s << this.DB - p; + while (i >= 0) { + if (p < 8) { + d = (this[i] & (1 << p) - 1) << 8 - p; + d |= this[--i] >> (p += this.DB - 8); + } else { + d = this[i] >> (p -= 8) & 255; + if (p <= 0) { + p += this.DB; + --i; + } + } + if ((d & 128) != 0) + d |= -256; + if (k == 0 && (this.s & 128) != (d & 128)) + ++k; + if (k > 0 || d != this.s) + r[k++] = d; + } + } + return r; + } + function bnEquals(a) { + return this.compareTo(a) == 0; + } + function bnMin(a) { + return this.compareTo(a) < 0 ? this : a; + } + function bnMax(a) { + return this.compareTo(a) > 0 ? this : a; + } + function bnpBitwiseTo(a, op, r) { + var i, f, m = Math.min(a.t, this.t); + for (i = 0; i < m; ++i) + r[i] = op(this[i], a[i]); + if (a.t < this.t) { + f = a.s & this.DM; + for (i = m; i < this.t; ++i) + r[i] = op(this[i], f); + r.t = this.t; + } else { + f = this.s & this.DM; + for (i = m; i < a.t; ++i) + r[i] = op(f, a[i]); + r.t = a.t; + } + r.s = op(this.s, a.s); + r.clamp(); + } + function op_and(x, y) { + return x & y; + } + function bnAnd(a) { + var r = nbi(); + this.bitwiseTo(a, op_and, r); + return r; + } + function op_or(x, y) { + return x | y; + } + function bnOr(a) { + var r = nbi(); + this.bitwiseTo(a, op_or, r); + return r; + } + function op_xor(x, y) { + return x ^ y; + } + function bnXor(a) { + var r = nbi(); + this.bitwiseTo(a, op_xor, r); + return r; + } + function op_andnot(x, y) { + return x & ~y; + } + function bnAndNot(a) { + var r = nbi(); + this.bitwiseTo(a, op_andnot, r); + return r; + } + function bnNot() { + var r = nbi(); + for (var i = 0; i < this.t; ++i) + r[i] = this.DM & ~this[i]; + r.t = this.t; + r.s = ~this.s; + return r; + } + function bnShiftLeft(n) { + var r = nbi(); + if (n < 0) + this.rShiftTo(-n, r); + else + this.lShiftTo(n, r); + return r; + } + function bnShiftRight(n) { + var r = nbi(); + if (n < 0) + this.lShiftTo(-n, r); + else + this.rShiftTo(n, r); + return r; + } + function lbit(x) { + if (x == 0) + return -1; + var r = 0; + if ((x & 65535) == 0) { + x >>= 16; + r += 16; + } + if ((x & 255) == 0) { + x >>= 8; + r += 8; + } + if ((x & 15) == 0) { + x >>= 4; + r += 4; + } + if ((x & 3) == 0) { + x >>= 2; + r += 2; + } + if ((x & 1) == 0) + ++r; + return r; + } + function bnGetLowestSetBit() { + for (var i = 0; i < this.t; ++i) + if (this[i] != 0) + return i * this.DB + lbit(this[i]); + if (this.s < 0) + return this.t * this.DB; + return -1; + } + function cbit(x) { + var r = 0; + while (x != 0) { + x &= x - 1; + ++r; + } + return r; + } + function bnBitCount() { + var r = 0, x = this.s & this.DM; + for (var i = 0; i < this.t; ++i) + r += cbit(this[i] ^ x); + return r; + } + function bnTestBit(n) { + var j = Math.floor(n / this.DB); + if (j >= this.t) + return this.s != 0; + return (this[j] & 1 << n % this.DB) != 0; + } + function bnpChangeBit(n, op) { + var r = BigInteger.ONE.shiftLeft(n); + this.bitwiseTo(r, op, r); + return r; + } + function bnSetBit(n) { + return this.changeBit(n, op_or); + } + function bnClearBit(n) { + return this.changeBit(n, op_andnot); + } + function bnFlipBit(n) { + return this.changeBit(n, op_xor); + } + function bnpAddTo(a, r) { + var i = 0, c = 0, m = Math.min(a.t, this.t); + while (i < m) { + c += this[i] + a[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + if (a.t < this.t) { + c += a.s; + while (i < this.t) { + c += this[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + c += this.s; + } else { + c += this.s; + while (i < a.t) { + c += a[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + c += a.s; + } + r.s = c < 0 ? -1 : 0; + if (c > 0) + r[i++] = c; + else if (c < -1) + r[i++] = this.DV + c; + r.t = i; + r.clamp(); + } + function bnAdd(a) { + var r = nbi(); + this.addTo(a, r); + return r; + } + function bnSubtract(a) { + var r = nbi(); + this.subTo(a, r); + return r; + } + function bnMultiply(a) { + var r = nbi(); + this.multiplyTo(a, r); + return r; + } + function bnSquare() { + var r = nbi(); + this.squareTo(r); + return r; + } + function bnDivide(a) { + var r = nbi(); + this.divRemTo(a, r, null); + return r; + } + function bnRemainder(a) { + var r = nbi(); + this.divRemTo(a, null, r); + return r; + } + function bnDivideAndRemainder(a) { + var q = nbi(), r = nbi(); + this.divRemTo(a, q, r); + return new Array(q, r); + } + function bnpDMultiply(n) { + this[this.t] = this.am(0, n - 1, this, 0, 0, this.t); + ++this.t; + this.clamp(); + } + function bnpDAddOffset(n, w) { + if (n == 0) + return; + while (this.t <= w) + this[this.t++] = 0; + this[w] += n; + while (this[w] >= this.DV) { + this[w] -= this.DV; + if (++w >= this.t) + this[this.t++] = 0; + ++this[w]; + } + } + function NullExp() { + } + function nNop(x) { + return x; + } + function nMulTo(x, y, r) { + x.multiplyTo(y, r); + } + function nSqrTo(x, r) { + x.squareTo(r); + } + NullExp.prototype.convert = nNop; + NullExp.prototype.revert = nNop; + NullExp.prototype.mulTo = nMulTo; + NullExp.prototype.sqrTo = nSqrTo; + function bnPow(e) { + return this.exp(e, new NullExp()); + } + function bnpMultiplyLowerTo(a, n, r) { + var i = Math.min(this.t + a.t, n); + r.s = 0; + r.t = i; + while (i > 0) + r[--i] = 0; + var j; + for (j = r.t - this.t; i < j; ++i) + r[i + this.t] = this.am(0, a[i], r, i, 0, this.t); + for (j = Math.min(a.t, n); i < j; ++i) + this.am(0, a[i], r, i, 0, n - i); + r.clamp(); + } + function bnpMultiplyUpperTo(a, n, r) { + --n; + var i = r.t = this.t + a.t - n; + r.s = 0; + while (--i >= 0) + r[i] = 0; + for (i = Math.max(n - this.t, 0); i < a.t; ++i) + r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n); + r.clamp(); + r.drShiftTo(1, r); + } + function Barrett(m) { + this.r2 = nbi(); + this.q3 = nbi(); + BigInteger.ONE.dlShiftTo(2 * m.t, this.r2); + this.mu = this.r2.divide(m); + this.m = m; + } + function barrettConvert(x) { + if (x.s < 0 || x.t > 2 * this.m.t) + return x.mod(this.m); + else if (x.compareTo(this.m) < 0) + return x; + else { + var r = nbi(); + x.copyTo(r); + this.reduce(r); + return r; + } + } + function barrettRevert(x) { + return x; + } + function barrettReduce(x) { + x.drShiftTo(this.m.t - 1, this.r2); + if (x.t > this.m.t + 1) { + x.t = this.m.t + 1; + x.clamp(); + } + this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3); + this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2); + while (x.compareTo(this.r2) < 0) + x.dAddOffset(1, this.m.t + 1); + x.subTo(this.r2, x); + while (x.compareTo(this.m) >= 0) + x.subTo(this.m, x); + } + function barrettSqrTo(x, r) { + x.squareTo(r); + this.reduce(r); + } + function barrettMulTo(x, y, r) { + x.multiplyTo(y, r); + this.reduce(r); + } + Barrett.prototype.convert = barrettConvert; + Barrett.prototype.revert = barrettRevert; + Barrett.prototype.reduce = barrettReduce; + Barrett.prototype.mulTo = barrettMulTo; + Barrett.prototype.sqrTo = barrettSqrTo; + function bnModPow(e, m) { + var i = e.bitLength(), k, r = nbv(1), z2; + if (i <= 0) + return r; + else if (i < 18) + k = 1; + else if (i < 48) + k = 3; + else if (i < 144) + k = 4; + else if (i < 768) + k = 5; + else + k = 6; + if (i < 8) + z2 = new Classic(m); + else if (m.isEven()) + z2 = new Barrett(m); + else + z2 = new Montgomery(m); + var g = new Array(), n = 3, k1 = k - 1, km = (1 << k) - 1; + g[1] = z2.convert(this); + if (k > 1) { + var g2 = nbi(); + z2.sqrTo(g[1], g2); + while (n <= km) { + g[n] = nbi(); + z2.mulTo(g2, g[n - 2], g[n]); + n += 2; + } + } + var j = e.t - 1, w, is1 = true, r2 = nbi(), t2; + i = nbits(e[j]) - 1; + while (j >= 0) { + if (i >= k1) + w = e[j] >> i - k1 & km; + else { + w = (e[j] & (1 << i + 1) - 1) << k1 - i; + if (j > 0) + w |= e[j - 1] >> this.DB + i - k1; + } + n = k; + while ((w & 1) == 0) { + w >>= 1; + --n; + } + if ((i -= n) < 0) { + i += this.DB; + --j; + } + if (is1) { + g[w].copyTo(r); + is1 = false; + } else { + while (n > 1) { + z2.sqrTo(r, r2); + z2.sqrTo(r2, r); + n -= 2; + } + if (n > 0) + z2.sqrTo(r, r2); + else { + t2 = r; + r = r2; + r2 = t2; + } + z2.mulTo(r2, g[w], r); + } + while (j >= 0 && (e[j] & 1 << i) == 0) { + z2.sqrTo(r, r2); + t2 = r; + r = r2; + r2 = t2; + if (--i < 0) { + i = this.DB - 1; + --j; + } + } + } + return z2.revert(r); + } + function bnGCD(a) { + var x = this.s < 0 ? this.negate() : this.clone(); + var y = a.s < 0 ? a.negate() : a.clone(); + if (x.compareTo(y) < 0) { + var t2 = x; + x = y; + y = t2; + } + var i = x.getLowestSetBit(), g = y.getLowestSetBit(); + if (g < 0) + return x; + if (i < g) + g = i; + if (g > 0) { + x.rShiftTo(g, x); + y.rShiftTo(g, y); + } + while (x.signum() > 0) { + if ((i = x.getLowestSetBit()) > 0) + x.rShiftTo(i, x); + if ((i = y.getLowestSetBit()) > 0) + y.rShiftTo(i, y); + if (x.compareTo(y) >= 0) { + x.subTo(y, x); + x.rShiftTo(1, x); + } else { + y.subTo(x, y); + y.rShiftTo(1, y); + } + } + if (g > 0) + y.lShiftTo(g, y); + return y; + } + function bnpModInt(n) { + if (n <= 0) + return 0; + var d = this.DV % n, r = this.s < 0 ? n - 1 : 0; + if (this.t > 0) + if (d == 0) + r = this[0] % n; + else + for (var i = this.t - 1; i >= 0; --i) + r = (d * r + this[i]) % n; + return r; + } + function bnModInverse(m) { + var ac = m.isEven(); + if (this.isEven() && ac || m.signum() == 0) + return BigInteger.ZERO; + var u = m.clone(), v = this.clone(); + var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1); + while (u.signum() != 0) { + while (u.isEven()) { + u.rShiftTo(1, u); + if (ac) { + if (!a.isEven() || !b.isEven()) { + a.addTo(this, a); + b.subTo(m, b); + } + a.rShiftTo(1, a); + } else if (!b.isEven()) + b.subTo(m, b); + b.rShiftTo(1, b); + } + while (v.isEven()) { + v.rShiftTo(1, v); + if (ac) { + if (!c.isEven() || !d.isEven()) { + c.addTo(this, c); + d.subTo(m, d); + } + c.rShiftTo(1, c); + } else if (!d.isEven()) + d.subTo(m, d); + d.rShiftTo(1, d); + } + if (u.compareTo(v) >= 0) { + u.subTo(v, u); + if (ac) + a.subTo(c, a); + b.subTo(d, b); + } else { + v.subTo(u, v); + if (ac) + c.subTo(a, c); + d.subTo(b, d); + } + } + if (v.compareTo(BigInteger.ONE) != 0) + return BigInteger.ZERO; + if (d.compareTo(m) >= 0) + return d.subtract(m); + if (d.signum() < 0) + d.addTo(m, d); + else + return d; + if (d.signum() < 0) + return d.add(m); + else + return d; + } + var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]; + var lplim = (1 << 26) / lowprimes[lowprimes.length - 1]; + function bnIsProbablePrime(t2) { + var i, x = this.abs(); + if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) { + for (i = 0; i < lowprimes.length; ++i) + if (x[0] == lowprimes[i]) + return true; + return false; + } + if (x.isEven()) + return false; + i = 1; + while (i < lowprimes.length) { + var m = lowprimes[i], j = i + 1; + while (j < lowprimes.length && m < lplim) + m *= lowprimes[j++]; + m = x.modInt(m); + while (i < j) + if (m % lowprimes[i++] == 0) + return false; + } + return x.millerRabin(t2); + } + function bnpMillerRabin(t2) { + var n1 = this.subtract(BigInteger.ONE); + var k = n1.getLowestSetBit(); + if (k <= 0) + return false; + var r = n1.shiftRight(k); + t2 = t2 + 1 >> 1; + if (t2 > lowprimes.length) + t2 = lowprimes.length; + var a = nbi(); + for (var i = 0; i < t2; ++i) { + a.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]); + var y = a.modPow(r, this); + if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) { + var j = 1; + while (j++ < k && y.compareTo(n1) != 0) { + y = y.modPowInt(2, this); + if (y.compareTo(BigInteger.ONE) == 0) + return false; + } + if (y.compareTo(n1) != 0) + return false; + } + } + return true; + } + BigInteger.prototype.chunkSize = bnpChunkSize; + BigInteger.prototype.toRadix = bnpToRadix; + BigInteger.prototype.fromRadix = bnpFromRadix; + BigInteger.prototype.fromNumber = bnpFromNumber; + BigInteger.prototype.bitwiseTo = bnpBitwiseTo; + BigInteger.prototype.changeBit = bnpChangeBit; + BigInteger.prototype.addTo = bnpAddTo; + BigInteger.prototype.dMultiply = bnpDMultiply; + BigInteger.prototype.dAddOffset = bnpDAddOffset; + BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo; + BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo; + BigInteger.prototype.modInt = bnpModInt; + BigInteger.prototype.millerRabin = bnpMillerRabin; + BigInteger.prototype.clone = bnClone; + BigInteger.prototype.intValue = bnIntValue; + BigInteger.prototype.byteValue = bnByteValue; + BigInteger.prototype.shortValue = bnShortValue; + BigInteger.prototype.signum = bnSigNum; + BigInteger.prototype.toByteArray = bnToByteArray; + BigInteger.prototype.equals = bnEquals; + BigInteger.prototype.min = bnMin; + BigInteger.prototype.max = bnMax; + BigInteger.prototype.and = bnAnd; + BigInteger.prototype.or = bnOr; + BigInteger.prototype.xor = bnXor; + BigInteger.prototype.andNot = bnAndNot; + BigInteger.prototype.not = bnNot; + BigInteger.prototype.shiftLeft = bnShiftLeft; + BigInteger.prototype.shiftRight = bnShiftRight; + BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit; + BigInteger.prototype.bitCount = bnBitCount; + BigInteger.prototype.testBit = bnTestBit; + BigInteger.prototype.setBit = bnSetBit; + BigInteger.prototype.clearBit = bnClearBit; + BigInteger.prototype.flipBit = bnFlipBit; + BigInteger.prototype.add = bnAdd; + BigInteger.prototype.subtract = bnSubtract; + BigInteger.prototype.multiply = bnMultiply; + BigInteger.prototype.divide = bnDivide; + BigInteger.prototype.remainder = bnRemainder; + BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder; + BigInteger.prototype.modPow = bnModPow; + BigInteger.prototype.modInverse = bnModInverse; + BigInteger.prototype.pow = bnPow; + BigInteger.prototype.gcd = bnGCD; + BigInteger.prototype.isProbablePrime = bnIsProbablePrime; + BigInteger.prototype.square = bnSquare; + BigInteger.prototype.Barrett = Barrett; + var rng_state; + var rng_pool; + var rng_pptr; + function rng_seed_int(x) { + rng_pool[rng_pptr++] ^= x & 255; + rng_pool[rng_pptr++] ^= x >> 8 & 255; + rng_pool[rng_pptr++] ^= x >> 16 & 255; + rng_pool[rng_pptr++] ^= x >> 24 & 255; + if (rng_pptr >= rng_psize) + rng_pptr -= rng_psize; + } + function rng_seed_time() { + rng_seed_int(new Date().getTime()); + } + if (rng_pool == null) { + rng_pool = new Array(); + rng_pptr = 0; + var t; + if (typeof window !== "undefined" && window.crypto) { + if (window.crypto.getRandomValues) { + var ua = new Uint8Array(32); + window.crypto.getRandomValues(ua); + for (t = 0; t < 32; ++t) + rng_pool[rng_pptr++] = ua[t]; + } else if (navigator.appName == "Netscape" && navigator.appVersion < "5") { + var z = window.crypto.random(32); + for (t = 0; t < z.length; ++t) + rng_pool[rng_pptr++] = z.charCodeAt(t) & 255; + } + } + while (rng_pptr < rng_psize) { + t = Math.floor(65536 * Math.random()); + rng_pool[rng_pptr++] = t >>> 8; + rng_pool[rng_pptr++] = t & 255; + } + rng_pptr = 0; + rng_seed_time(); + } + function rng_get_byte() { + if (rng_state == null) { + rng_seed_time(); + rng_state = prng_newstate(); + rng_state.init(rng_pool); + for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) + rng_pool[rng_pptr] = 0; + rng_pptr = 0; + } + return rng_state.next(); + } + function rng_get_bytes(ba) { + var i; + for (i = 0; i < ba.length; ++i) + ba[i] = rng_get_byte(); + } + function SecureRandom() { + } + SecureRandom.prototype.nextBytes = rng_get_bytes; + function Arcfour() { + this.i = 0; + this.j = 0; + this.S = new Array(); + } + function ARC4init(key) { + var i, j, t2; + for (i = 0; i < 256; ++i) + this.S[i] = i; + j = 0; + for (i = 0; i < 256; ++i) { + j = j + this.S[i] + key[i % key.length] & 255; + t2 = this.S[i]; + this.S[i] = this.S[j]; + this.S[j] = t2; + } + this.i = 0; + this.j = 0; + } + function ARC4next() { + var t2; + this.i = this.i + 1 & 255; + this.j = this.j + this.S[this.i] & 255; + t2 = this.S[this.i]; + this.S[this.i] = this.S[this.j]; + this.S[this.j] = t2; + return this.S[t2 + this.S[this.i] & 255]; + } + Arcfour.prototype.init = ARC4init; + Arcfour.prototype.next = ARC4next; + function prng_newstate() { + return new Arcfour(); + } + var rng_psize = 256; + if (typeof exports !== "undefined") { + exports = module.exports = { + default: BigInteger, + BigInteger, + SecureRandom + }; + } else { + this.jsbn = { + BigInteger, + SecureRandom + }; + } + }).call(exports); + } +}); + +// node_modules/sprintf-js/src/sprintf.js +var require_sprintf = __commonJS({ + "node_modules/sprintf-js/src/sprintf.js"(exports) { + !function() { + "use strict"; + var re = { + not_string: /[^s]/, + not_bool: /[^t]/, + not_type: /[^T]/, + not_primitive: /[^v]/, + number: /[diefg]/, + numeric_arg: /[bcdiefguxX]/, + json: /[j]/, + not_json: /[^j]/, + text: /^[^\x25]+/, + modulo: /^\x25{2}/, + placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/, + key: /^([a-z_][a-z_\d]*)/i, + key_access: /^\.([a-z_][a-z_\d]*)/i, + index_access: /^\[(\d+)\]/, + sign: /^[+-]/ + }; + function sprintf(key) { + return sprintf_format(sprintf_parse(key), arguments); + } + function vsprintf(fmt, argv) { + return sprintf.apply(null, [fmt].concat(argv || [])); + } + function sprintf_format(parse_tree, argv) { + var cursor = 1, tree_length = parse_tree.length, arg, output = "", i, k, ph, pad, pad_character, pad_length, is_positive, sign; + for (i = 0; i < tree_length; i++) { + if (typeof parse_tree[i] === "string") { + output += parse_tree[i]; + } else if (typeof parse_tree[i] === "object") { + ph = parse_tree[i]; + if (ph.keys) { + arg = argv[cursor]; + for (k = 0; k < ph.keys.length; k++) { + if (arg == void 0) { + throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k - 1])); + } + arg = arg[ph.keys[k]]; + } + } else if (ph.param_no) { + arg = argv[ph.param_no]; + } else { + arg = argv[cursor++]; + } + if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) { + arg = arg(); + } + if (re.numeric_arg.test(ph.type) && (typeof arg !== "number" && isNaN(arg))) { + throw new TypeError(sprintf("[sprintf] expecting number but found %T", arg)); + } + if (re.number.test(ph.type)) { + is_positive = arg >= 0; + } + switch (ph.type) { + case "b": + arg = parseInt(arg, 10).toString(2); + break; + case "c": + arg = String.fromCharCode(parseInt(arg, 10)); + break; + case "d": + case "i": + arg = parseInt(arg, 10); + break; + case "j": + arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0); + break; + case "e": + arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential(); + break; + case "f": + arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg); + break; + case "g": + arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg); + break; + case "o": + arg = (parseInt(arg, 10) >>> 0).toString(8); + break; + case "s": + arg = String(arg); + arg = ph.precision ? arg.substring(0, ph.precision) : arg; + break; + case "t": + arg = String(!!arg); + arg = ph.precision ? arg.substring(0, ph.precision) : arg; + break; + case "T": + arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase(); + arg = ph.precision ? arg.substring(0, ph.precision) : arg; + break; + case "u": + arg = parseInt(arg, 10) >>> 0; + break; + case "v": + arg = arg.valueOf(); + arg = ph.precision ? arg.substring(0, ph.precision) : arg; + break; + case "x": + arg = (parseInt(arg, 10) >>> 0).toString(16); + break; + case "X": + arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase(); + break; + } + if (re.json.test(ph.type)) { + output += arg; + } else { + if (re.number.test(ph.type) && (!is_positive || ph.sign)) { + sign = is_positive ? "+" : "-"; + arg = arg.toString().replace(re.sign, ""); + } else { + sign = ""; + } + pad_character = ph.pad_char ? ph.pad_char === "0" ? "0" : ph.pad_char.charAt(1) : " "; + pad_length = ph.width - (sign + arg).length; + pad = ph.width ? pad_length > 0 ? pad_character.repeat(pad_length) : "" : ""; + output += ph.align ? sign + arg + pad : pad_character === "0" ? sign + pad + arg : pad + sign + arg; + } + } + } + return output; + } + var sprintf_cache = /* @__PURE__ */ Object.create(null); + function sprintf_parse(fmt) { + if (sprintf_cache[fmt]) { + return sprintf_cache[fmt]; + } + var _fmt = fmt, match, parse_tree = [], arg_names = 0; + while (_fmt) { + if ((match = re.text.exec(_fmt)) !== null) { + parse_tree.push(match[0]); + } else if ((match = re.modulo.exec(_fmt)) !== null) { + parse_tree.push("%"); + } else if ((match = re.placeholder.exec(_fmt)) !== null) { + if (match[2]) { + arg_names |= 1; + var field_list = [], replacement_field = match[2], field_match = []; + if ((field_match = re.key.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + while ((replacement_field = replacement_field.substring(field_match[0].length)) !== "") { + if ((field_match = re.key_access.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + } else if ((field_match = re.index_access.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + } else { + throw new SyntaxError("[sprintf] failed to parse named argument key"); + } + } + } else { + throw new SyntaxError("[sprintf] failed to parse named argument key"); + } + match[2] = field_list; + } else { + arg_names |= 2; + } + if (arg_names === 3) { + throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported"); + } + parse_tree.push( + { + placeholder: match[0], + param_no: match[1], + keys: match[2], + sign: match[3], + pad_char: match[4], + align: match[5], + width: match[6], + precision: match[7], + type: match[8] + } + ); + } else { + throw new SyntaxError("[sprintf] unexpected placeholder"); + } + _fmt = _fmt.substring(match[0].length); + } + return sprintf_cache[fmt] = parse_tree; + } + if (typeof exports !== "undefined") { + exports["sprintf"] = sprintf; + exports["vsprintf"] = vsprintf; + } + if (typeof window !== "undefined") { + window["sprintf"] = sprintf; + window["vsprintf"] = vsprintf; + if (typeof define === "function" && define["amd"]) { + define(function() { + return { + "sprintf": sprintf, + "vsprintf": vsprintf + }; + }); + } + } + }(); + } +}); + +// node_modules/ip-address/dist/lib/ipv4.js +var require_ipv4 = __commonJS({ + "node_modules/ip-address/dist/lib/ipv4.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding(result, mod, k); + } + __setModuleDefault(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Address4 = void 0; + var common = __importStar(require_common()); + var constants = __importStar(require_constants()); + var address_error_1 = require_address_error(); + var jsbn_1 = require_jsbn(); + var sprintf_js_1 = require_sprintf(); + var Address4 = function() { + function Address42(address) { + this.groups = constants.GROUPS; + this.parsedAddress = []; + this.parsedSubnet = ""; + this.subnet = "/32"; + this.subnetMask = 32; + this.v4 = true; + this.isCorrect = common.isCorrect(constants.BITS); + this.isInSubnet = common.isInSubnet; + this.address = address; + var subnet = constants.RE_SUBNET_STRING.exec(address); + if (subnet) { + this.parsedSubnet = subnet[0].replace("/", ""); + this.subnetMask = parseInt(this.parsedSubnet, 10); + this.subnet = "/" + this.subnetMask; + if (this.subnetMask < 0 || this.subnetMask > constants.BITS) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + address = address.replace(constants.RE_SUBNET_STRING, ""); + } + this.addressMinusSuffix = address; + this.parsedAddress = this.parse(address); + } + Address42.isValid = function(address) { + try { + new Address42(address); + return true; + } catch (e) { + return false; + } + }; + Address42.prototype.parse = function(address) { + var groups = address.split("."); + if (!address.match(constants.RE_ADDRESS)) { + throw new address_error_1.AddressError("Invalid IPv4 address."); + } + return groups; + }; + Address42.prototype.correctForm = function() { + return this.parsedAddress.map(function(part) { + return parseInt(part, 10); + }).join("."); + }; + Address42.fromHex = function(hex) { + var padded = hex.replace(/:/g, "").padStart(8, "0"); + var groups = []; + var i; + for (i = 0; i < 8; i += 2) { + var h = padded.slice(i, i + 2); + groups.push(parseInt(h, 16)); + } + return new Address42(groups.join(".")); + }; + Address42.fromInteger = function(integer) { + return Address42.fromHex(integer.toString(16)); + }; + Address42.prototype.toHex = function() { + return this.parsedAddress.map(function(part) { + return sprintf_js_1.sprintf("%02x", parseInt(part, 10)); + }).join(":"); + }; + Address42.prototype.toArray = function() { + return this.parsedAddress.map(function(part) { + return parseInt(part, 10); + }); + }; + Address42.prototype.toGroup6 = function() { + var output = []; + var i; + for (i = 0; i < constants.GROUPS; i += 2) { + var hex = sprintf_js_1.sprintf("%02x%02x", parseInt(this.parsedAddress[i], 10), parseInt(this.parsedAddress[i + 1], 10)); + output.push(sprintf_js_1.sprintf("%x", parseInt(hex, 16))); + } + return output.join(":"); + }; + Address42.prototype.bigInteger = function() { + return new jsbn_1.BigInteger(this.parsedAddress.map(function(n) { + return sprintf_js_1.sprintf("%02x", parseInt(n, 10)); + }).join(""), 16); + }; + Address42.prototype._startAddress = function() { + return new jsbn_1.BigInteger(this.mask() + "0".repeat(constants.BITS - this.subnetMask), 2); + }; + Address42.prototype.startAddress = function() { + return Address42.fromBigInteger(this._startAddress()); + }; + Address42.prototype.startAddressExclusive = function() { + var adjust = new jsbn_1.BigInteger("1"); + return Address42.fromBigInteger(this._startAddress().add(adjust)); + }; + Address42.prototype._endAddress = function() { + return new jsbn_1.BigInteger(this.mask() + "1".repeat(constants.BITS - this.subnetMask), 2); + }; + Address42.prototype.endAddress = function() { + return Address42.fromBigInteger(this._endAddress()); + }; + Address42.prototype.endAddressExclusive = function() { + var adjust = new jsbn_1.BigInteger("1"); + return Address42.fromBigInteger(this._endAddress().subtract(adjust)); + }; + Address42.fromBigInteger = function(bigInteger) { + return Address42.fromInteger(parseInt(bigInteger.toString(), 10)); + }; + Address42.prototype.mask = function(mask) { + if (mask === void 0) { + mask = this.subnetMask; + } + return this.getBitsBase2(0, mask); + }; + Address42.prototype.getBitsBase2 = function(start, end) { + return this.binaryZeroPad().slice(start, end); + }; + Address42.prototype.isMulticast = function() { + return this.isInSubnet(new Address42("224.0.0.0/4")); + }; + Address42.prototype.binaryZeroPad = function() { + return this.bigInteger().toString(2).padStart(constants.BITS, "0"); + }; + Address42.prototype.groupForV6 = function() { + var segments = this.parsedAddress; + return this.address.replace(constants.RE_ADDRESS, sprintf_js_1.sprintf('%s.%s', segments.slice(0, 2).join("."), segments.slice(2, 4).join("."))); + }; + return Address42; + }(); + exports.Address4 = Address4; + } +}); + +// node_modules/ip-address/dist/lib/v6/constants.js +var require_constants2 = __commonJS({ + "node_modules/ip-address/dist/lib/v6/constants.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = void 0; + exports.BITS = 128; + exports.GROUPS = 8; + exports.SCOPES = { + 0: "Reserved", + 1: "Interface local", + 2: "Link local", + 4: "Admin local", + 5: "Site local", + 8: "Organization local", + 14: "Global", + 15: "Reserved" + }; + exports.TYPES = { + "ff01::1/128": "Multicast (All nodes on this interface)", + "ff01::2/128": "Multicast (All routers on this interface)", + "ff02::1/128": "Multicast (All nodes on this link)", + "ff02::2/128": "Multicast (All routers on this link)", + "ff05::2/128": "Multicast (All routers in this site)", + "ff02::5/128": "Multicast (OSPFv3 AllSPF routers)", + "ff02::6/128": "Multicast (OSPFv3 AllDR routers)", + "ff02::9/128": "Multicast (RIP routers)", + "ff02::a/128": "Multicast (EIGRP routers)", + "ff02::d/128": "Multicast (PIM routers)", + "ff02::16/128": "Multicast (MLDv2 reports)", + "ff01::fb/128": "Multicast (mDNSv6)", + "ff02::fb/128": "Multicast (mDNSv6)", + "ff05::fb/128": "Multicast (mDNSv6)", + "ff02::1:2/128": "Multicast (All DHCP servers and relay agents on this link)", + "ff05::1:2/128": "Multicast (All DHCP servers and relay agents in this site)", + "ff02::1:3/128": "Multicast (All DHCP servers on this link)", + "ff05::1:3/128": "Multicast (All DHCP servers in this site)", + "::/128": "Unspecified", + "::1/128": "Loopback", + "ff00::/8": "Multicast", + "fe80::/10": "Link-local unicast" + }; + exports.RE_BAD_CHARACTERS = /([^0-9a-f:/%])/gi; + exports.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\/$)/gi; + exports.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/; + exports.RE_ZONE_STRING = /%.*$/; + exports.RE_URL = new RegExp(/^\[{0,1}([0-9a-f:]+)\]{0,1}/); + exports.RE_URL_WITH_PORT = new RegExp(/\[([0-9a-f:]+)\]:([0-9]{1,5})/); + } +}); + +// node_modules/ip-address/dist/lib/v6/helpers.js +var require_helpers = __commonJS({ + "node_modules/ip-address/dist/lib/v6/helpers.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.simpleGroup = exports.spanLeadingZeroes = exports.spanAll = exports.spanAllZeroes = void 0; + var sprintf_js_1 = require_sprintf(); + function spanAllZeroes(s) { + return s.replace(/(0+)/g, '$1'); + } + exports.spanAllZeroes = spanAllZeroes; + function spanAll(s, offset) { + if (offset === void 0) { + offset = 0; + } + var letters = s.split(""); + return letters.map( + function(n, i) { + return sprintf_js_1.sprintf('%s', n, i + offset, spanAllZeroes(n)); + } + ).join(""); + } + exports.spanAll = spanAll; + function spanLeadingZeroesSimple(group) { + return group.replace(/^(0+)/, '$1'); + } + function spanLeadingZeroes(address) { + var groups = address.split(":"); + return groups.map(function(g) { + return spanLeadingZeroesSimple(g); + }).join(":"); + } + exports.spanLeadingZeroes = spanLeadingZeroes; + function simpleGroup(addressString, offset) { + if (offset === void 0) { + offset = 0; + } + var groups = addressString.split(":"); + return groups.map(function(g, i) { + if (/group-v4/.test(g)) { + return g; + } + return sprintf_js_1.sprintf('%s', i + offset, spanLeadingZeroesSimple(g)); + }); + } + exports.simpleGroup = simpleGroup; + } +}); + +// node_modules/ip-address/dist/lib/v6/regular-expressions.js +var require_regular_expressions = __commonJS({ + "node_modules/ip-address/dist/lib/v6/regular-expressions.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding(result, mod, k); + } + __setModuleDefault(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.possibleElisions = exports.simpleRegularExpression = exports.ADDRESS_BOUNDARY = exports.padGroup = exports.groupPossibilities = void 0; + var v6 = __importStar(require_constants2()); + var sprintf_js_1 = require_sprintf(); + function groupPossibilities(possibilities) { + return sprintf_js_1.sprintf("(%s)", possibilities.join("|")); + } + exports.groupPossibilities = groupPossibilities; + function padGroup(group) { + if (group.length < 4) { + return sprintf_js_1.sprintf("0{0,%d}%s", 4 - group.length, group); + } + return group; + } + exports.padGroup = padGroup; + exports.ADDRESS_BOUNDARY = "[^A-Fa-f0-9:]"; + function simpleRegularExpression(groups) { + var zeroIndexes = []; + groups.forEach(function(group, i) { + var groupInteger = parseInt(group, 16); + if (groupInteger === 0) { + zeroIndexes.push(i); + } + }); + var possibilities = zeroIndexes.map(function(zeroIndex) { + return groups.map(function(group, i) { + if (i === zeroIndex) { + var elision = i === 0 || i === v6.GROUPS - 1 ? ":" : ""; + return groupPossibilities([padGroup(group), elision]); + } + return padGroup(group); + }).join(":"); + }); + possibilities.push(groups.map(padGroup).join(":")); + return groupPossibilities(possibilities); + } + exports.simpleRegularExpression = simpleRegularExpression; + function possibleElisions(elidedGroups, moreLeft, moreRight) { + var left = moreLeft ? "" : ":"; + var right = moreRight ? "" : ":"; + var possibilities = []; + if (!moreLeft && !moreRight) { + possibilities.push("::"); + } + if (moreLeft && moreRight) { + possibilities.push(""); + } + if (moreRight && !moreLeft || !moreRight && moreLeft) { + possibilities.push(":"); + } + possibilities.push(sprintf_js_1.sprintf("%s(:0{1,4}){1,%d}", left, elidedGroups - 1)); + possibilities.push(sprintf_js_1.sprintf("(0{1,4}:){1,%d}%s", elidedGroups - 1, right)); + possibilities.push(sprintf_js_1.sprintf("(0{1,4}:){%d}0{1,4}", elidedGroups - 1)); + for (var groups = 1; groups < elidedGroups - 1; groups++) { + for (var position = 1; position < elidedGroups - groups; position++) { + possibilities.push(sprintf_js_1.sprintf("(0{1,4}:){%d}:(0{1,4}:){%d}0{1,4}", position, elidedGroups - position - groups - 1)); + } + } + return groupPossibilities(possibilities); + } + exports.possibleElisions = possibleElisions; + } +}); + +// node_modules/ip-address/dist/lib/ipv6.js +var require_ipv6 = __commonJS({ + "node_modules/ip-address/dist/lib/ipv6.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding(result, mod, k); + } + __setModuleDefault(result, mod); + return result; + }; + var __spreadArrays = exports && exports.__spreadArrays || function() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) + s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Address6 = void 0; + var common = __importStar(require_common()); + var constants4 = __importStar(require_constants()); + var constants6 = __importStar(require_constants2()); + var helpers = __importStar(require_helpers()); + var ipv4_1 = require_ipv4(); + var regular_expressions_1 = require_regular_expressions(); + var address_error_1 = require_address_error(); + var jsbn_1 = require_jsbn(); + var sprintf_js_1 = require_sprintf(); + function assert(condition) { + if (!condition) { + throw new Error("Assertion failed."); + } + } + function addCommas(number) { + var r = /(\d+)(\d{3})/; + while (r.test(number)) { + number = number.replace(r, "$1,$2"); + } + return number; + } + function spanLeadingZeroes4(n) { + n = n.replace(/^(0{1,})([1-9]+)$/, '$1$2'); + n = n.replace(/^(0{1,})(0)$/, '$1$2'); + return n; + } + function compact(address, slice) { + var s1 = []; + var s2 = []; + var i; + for (i = 0; i < address.length; i++) { + if (i < slice[0]) { + s1.push(address[i]); + } else if (i > slice[1]) { + s2.push(address[i]); + } + } + return s1.concat(["compact"]).concat(s2); + } + function paddedHex(octet) { + return sprintf_js_1.sprintf("%04x", parseInt(octet, 16)); + } + function unsignByte(b) { + return b & 255; + } + var Address6 = function() { + function Address62(address, optionalGroups) { + this.addressMinusSuffix = ""; + this.parsedSubnet = ""; + this.subnet = "/128"; + this.subnetMask = 128; + this.v4 = false; + this.zone = ""; + this.isInSubnet = common.isInSubnet; + this.isCorrect = common.isCorrect(constants6.BITS); + if (optionalGroups === void 0) { + this.groups = constants6.GROUPS; + } else { + this.groups = optionalGroups; + } + this.address = address; + var subnet = constants6.RE_SUBNET_STRING.exec(address); + if (subnet) { + this.parsedSubnet = subnet[0].replace("/", ""); + this.subnetMask = parseInt(this.parsedSubnet, 10); + this.subnet = "/" + this.subnetMask; + if (Number.isNaN(this.subnetMask) || this.subnetMask < 0 || this.subnetMask > constants6.BITS) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + address = address.replace(constants6.RE_SUBNET_STRING, ""); + } else if (/\//.test(address)) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + var zone = constants6.RE_ZONE_STRING.exec(address); + if (zone) { + this.zone = zone[0]; + address = address.replace(constants6.RE_ZONE_STRING, ""); + } + this.addressMinusSuffix = address; + this.parsedAddress = this.parse(this.addressMinusSuffix); + } + Address62.isValid = function(address) { + try { + new Address62(address); + return true; + } catch (e) { + return false; + } + }; + Address62.fromBigInteger = function(bigInteger) { + var hex = bigInteger.toString(16).padStart(32, "0"); + var groups = []; + var i; + for (i = 0; i < constants6.GROUPS; i++) { + groups.push(hex.slice(i * 4, (i + 1) * 4)); + } + return new Address62(groups.join(":")); + }; + Address62.fromURL = function(url) { + var host; + var port = null; + var result; + if (url.indexOf("[") !== -1 && url.indexOf("]:") !== -1) { + result = constants6.RE_URL_WITH_PORT.exec(url); + if (result === null) { + return { + error: "failed to parse address with port", + address: null, + port: null + }; + } + host = result[1]; + port = result[2]; + } else if (url.indexOf("/") !== -1) { + url = url.replace(/^[a-z0-9]+:\/\//, ""); + result = constants6.RE_URL.exec(url); + if (result === null) { + return { + error: "failed to parse address from URL", + address: null, + port: null + }; + } + host = result[1]; + } else { + host = url; + } + if (port) { + port = parseInt(port, 10); + if (port < 0 || port > 65536) { + port = null; + } + } else { + port = null; + } + return { + address: new Address62(host), + port + }; + }; + Address62.fromAddress4 = function(address) { + var address4 = new ipv4_1.Address4(address); + var mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask); + return new Address62("::ffff:" + address4.correctForm() + "/" + mask6); + }; + Address62.fromArpa = function(arpaFormAddress) { + var address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, ""); + var semicolonAmount = 7; + if (address.length !== 63) { + throw new address_error_1.AddressError("Invalid 'ip6.arpa' form."); + } + var parts = address.split(".").reverse(); + for (var i = semicolonAmount; i > 0; i--) { + var insertIndex = i * 4; + parts.splice(insertIndex, 0, ":"); + } + address = parts.join(""); + return new Address62(address); + }; + Address62.prototype.microsoftTranscription = function() { + return sprintf_js_1.sprintf("%s.ipv6-literal.net", this.correctForm().replace(/:/g, "-")); + }; + Address62.prototype.mask = function(mask) { + if (mask === void 0) { + mask = this.subnetMask; + } + return this.getBitsBase2(0, mask); + }; + Address62.prototype.possibleSubnets = function(subnetSize) { + if (subnetSize === void 0) { + subnetSize = 128; + } + var availableBits = constants6.BITS - this.subnetMask; + var subnetBits = Math.abs(subnetSize - constants6.BITS); + var subnetPowers = availableBits - subnetBits; + if (subnetPowers < 0) { + return "0"; + } + return addCommas(new jsbn_1.BigInteger("2", 10).pow(subnetPowers).toString(10)); + }; + Address62.prototype._startAddress = function() { + return new jsbn_1.BigInteger(this.mask() + "0".repeat(constants6.BITS - this.subnetMask), 2); + }; + Address62.prototype.startAddress = function() { + return Address62.fromBigInteger(this._startAddress()); + }; + Address62.prototype.startAddressExclusive = function() { + var adjust = new jsbn_1.BigInteger("1"); + return Address62.fromBigInteger(this._startAddress().add(adjust)); + }; + Address62.prototype._endAddress = function() { + return new jsbn_1.BigInteger(this.mask() + "1".repeat(constants6.BITS - this.subnetMask), 2); + }; + Address62.prototype.endAddress = function() { + return Address62.fromBigInteger(this._endAddress()); + }; + Address62.prototype.endAddressExclusive = function() { + var adjust = new jsbn_1.BigInteger("1"); + return Address62.fromBigInteger(this._endAddress().subtract(adjust)); + }; + Address62.prototype.getScope = function() { + var scope = constants6.SCOPES[this.getBits(12, 16).intValue()]; + if (this.getType() === "Global unicast" && scope !== "Link local") { + scope = "Global"; + } + return scope || "Unknown"; + }; + Address62.prototype.getType = function() { + for (var _i = 0, _a = Object.keys(constants6.TYPES); _i < _a.length; _i++) { + var subnet = _a[_i]; + if (this.isInSubnet(new Address62(subnet))) { + return constants6.TYPES[subnet]; + } + } + return "Global unicast"; + }; + Address62.prototype.getBits = function(start, end) { + return new jsbn_1.BigInteger(this.getBitsBase2(start, end), 2); + }; + Address62.prototype.getBitsBase2 = function(start, end) { + return this.binaryZeroPad().slice(start, end); + }; + Address62.prototype.getBitsBase16 = function(start, end) { + var length = end - start; + if (length % 4 !== 0) { + throw new Error("Length of bits to retrieve must be divisible by four"); + } + return this.getBits(start, end).toString(16).padStart(length / 4, "0"); + }; + Address62.prototype.getBitsPastSubnet = function() { + return this.getBitsBase2(this.subnetMask, constants6.BITS); + }; + Address62.prototype.reverseForm = function(options) { + if (!options) { + options = {}; + } + var characters = Math.floor(this.subnetMask / 4); + var reversed = this.canonicalForm().replace(/:/g, "").split("").slice(0, characters).reverse().join("."); + if (characters > 0) { + if (options.omitSuffix) { + return reversed; + } + return sprintf_js_1.sprintf("%s.ip6.arpa.", reversed); + } + if (options.omitSuffix) { + return ""; + } + return "ip6.arpa."; + }; + Address62.prototype.correctForm = function() { + var i; + var groups = []; + var zeroCounter = 0; + var zeroes = []; + for (i = 0; i < this.parsedAddress.length; i++) { + var value = parseInt(this.parsedAddress[i], 16); + if (value === 0) { + zeroCounter++; + } + if (value !== 0 && zeroCounter > 0) { + if (zeroCounter > 1) { + zeroes.push([i - zeroCounter, i - 1]); + } + zeroCounter = 0; + } + } + if (zeroCounter > 1) { + zeroes.push([this.parsedAddress.length - zeroCounter, this.parsedAddress.length - 1]); + } + var zeroLengths = zeroes.map(function(n) { + return n[1] - n[0] + 1; + }); + if (zeroes.length > 0) { + var index = zeroLengths.indexOf(Math.max.apply(Math, zeroLengths)); + groups = compact(this.parsedAddress, zeroes[index]); + } else { + groups = this.parsedAddress; + } + for (i = 0; i < groups.length; i++) { + if (groups[i] !== "compact") { + groups[i] = parseInt(groups[i], 16).toString(16); + } + } + var correct = groups.join(":"); + correct = correct.replace(/^compact$/, "::"); + correct = correct.replace(/^compact|compact$/, ":"); + correct = correct.replace(/compact/, ""); + return correct; + }; + Address62.prototype.binaryZeroPad = function() { + return this.bigInteger().toString(2).padStart(constants6.BITS, "0"); + }; + Address62.prototype.parse4in6 = function(address) { + var groups = address.split(":"); + var lastGroup = groups.slice(-1)[0]; + var address4 = lastGroup.match(constants4.RE_ADDRESS); + if (address4) { + this.parsedAddress4 = address4[0]; + this.address4 = new ipv4_1.Address4(this.parsedAddress4); + for (var i = 0; i < this.address4.groups; i++) { + if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) { + throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join("."))); + } + } + this.v4 = true; + groups[groups.length - 1] = this.address4.toGroup6(); + address = groups.join(":"); + } + return address; + }; + Address62.prototype.parse = function(address) { + address = this.parse4in6(address); + var badCharacters = address.match(constants6.RE_BAD_CHARACTERS); + if (badCharacters) { + throw new address_error_1.AddressError(sprintf_js_1.sprintf("Bad character%s detected in address: %s", badCharacters.length > 1 ? "s" : "", badCharacters.join("")), address.replace(constants6.RE_BAD_CHARACTERS, '$1')); + } + var badAddress = address.match(constants6.RE_BAD_ADDRESS); + if (badAddress) { + throw new address_error_1.AddressError(sprintf_js_1.sprintf("Address failed regex: %s", badAddress.join("")), address.replace(constants6.RE_BAD_ADDRESS, '$1')); + } + var groups = []; + var halves = address.split("::"); + if (halves.length === 2) { + var first = halves[0].split(":"); + var last = halves[1].split(":"); + if (first.length === 1 && first[0] === "") { + first = []; + } + if (last.length === 1 && last[0] === "") { + last = []; + } + var remaining = this.groups - (first.length + last.length); + if (!remaining) { + throw new address_error_1.AddressError("Error parsing groups"); + } + this.elidedGroups = remaining; + this.elisionBegin = first.length; + this.elisionEnd = first.length + this.elidedGroups; + groups = groups.concat(first); + for (var i = 0; i < remaining; i++) { + groups.push("0"); + } + groups = groups.concat(last); + } else if (halves.length === 1) { + groups = address.split(":"); + this.elidedGroups = 0; + } else { + throw new address_error_1.AddressError("Too many :: groups found"); + } + groups = groups.map(function(group) { + return sprintf_js_1.sprintf("%x", parseInt(group, 16)); + }); + if (groups.length !== this.groups) { + throw new address_error_1.AddressError("Incorrect number of groups found"); + } + return groups; + }; + Address62.prototype.canonicalForm = function() { + return this.parsedAddress.map(paddedHex).join(":"); + }; + Address62.prototype.decimal = function() { + return this.parsedAddress.map(function(n) { + return sprintf_js_1.sprintf("%05d", parseInt(n, 16)); + }).join(":"); + }; + Address62.prototype.bigInteger = function() { + return new jsbn_1.BigInteger(this.parsedAddress.map(paddedHex).join(""), 16); + }; + Address62.prototype.to4 = function() { + var binary = this.binaryZeroPad().split(""); + return ipv4_1.Address4.fromHex(new jsbn_1.BigInteger(binary.slice(96, 128).join(""), 2).toString(16)); + }; + Address62.prototype.to4in6 = function() { + var address4 = this.to4(); + var address6 = new Address62(this.parsedAddress.slice(0, 6).join(":"), 6); + var correct = address6.correctForm(); + var infix = ""; + if (!/:$/.test(correct)) { + infix = ":"; + } + return correct + infix + address4.address; + }; + Address62.prototype.inspectTeredo = function() { + var prefix = this.getBitsBase16(0, 32); + var udpPort = this.getBits(80, 96).xor(new jsbn_1.BigInteger("ffff", 16)).toString(); + var server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64)); + var client4 = ipv4_1.Address4.fromHex(this.getBits(96, 128).xor(new jsbn_1.BigInteger("ffffffff", 16)).toString(16)); + var flags = this.getBits(64, 80); + var flagsBase2 = this.getBitsBase2(64, 80); + var coneNat = flags.testBit(15); + var reserved = flags.testBit(14); + var groupIndividual = flags.testBit(8); + var universalLocal = flags.testBit(9); + var nonce = new jsbn_1.BigInteger(flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16), 2).toString(10); + return { + prefix: sprintf_js_1.sprintf("%s:%s", prefix.slice(0, 4), prefix.slice(4, 8)), + server4: server4.address, + client4: client4.address, + flags: flagsBase2, + coneNat, + microsoft: { + reserved, + universalLocal, + groupIndividual, + nonce + }, + udpPort + }; + }; + Address62.prototype.inspect6to4 = function() { + var prefix = this.getBitsBase16(0, 16); + var gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48)); + return { + prefix: sprintf_js_1.sprintf("%s", prefix.slice(0, 4)), + gateway: gateway.address + }; + }; + Address62.prototype.to6to4 = function() { + if (!this.is4()) { + return null; + } + var addr6to4 = [ + "2002", + this.getBitsBase16(96, 112), + this.getBitsBase16(112, 128), + "", + "/16" + ].join(":"); + return new Address62(addr6to4); + }; + Address62.prototype.toByteArray = function() { + var byteArray = this.bigInteger().toByteArray(); + if (byteArray.length === 17 && byteArray[0] === 0) { + return byteArray.slice(1); + } + return byteArray; + }; + Address62.prototype.toUnsignedByteArray = function() { + return this.toByteArray().map(unsignByte); + }; + Address62.fromByteArray = function(bytes) { + return this.fromUnsignedByteArray(bytes.map(unsignByte)); + }; + Address62.fromUnsignedByteArray = function(bytes) { + var BYTE_MAX = new jsbn_1.BigInteger("256", 10); + var result = new jsbn_1.BigInteger("0", 10); + var multiplier = new jsbn_1.BigInteger("1", 10); + for (var i = bytes.length - 1; i >= 0; i--) { + result = result.add(multiplier.multiply(new jsbn_1.BigInteger(bytes[i].toString(10), 10))); + multiplier = multiplier.multiply(BYTE_MAX); + } + return Address62.fromBigInteger(result); + }; + Address62.prototype.isCanonical = function() { + return this.addressMinusSuffix === this.canonicalForm(); + }; + Address62.prototype.isLinkLocal = function() { + if (this.getBitsBase2(0, 64) === "1111111010000000000000000000000000000000000000000000000000000000") { + return true; + } + return false; + }; + Address62.prototype.isMulticast = function() { + return this.getType() === "Multicast"; + }; + Address62.prototype.is4 = function() { + return this.v4; + }; + Address62.prototype.isTeredo = function() { + return this.isInSubnet(new Address62("2001::/32")); + }; + Address62.prototype.is6to4 = function() { + return this.isInSubnet(new Address62("2002::/16")); + }; + Address62.prototype.isLoopback = function() { + return this.getType() === "Loopback"; + }; + Address62.prototype.href = function(optionalPort) { + if (optionalPort === void 0) { + optionalPort = ""; + } else { + optionalPort = sprintf_js_1.sprintf(":%s", optionalPort); + } + return sprintf_js_1.sprintf("http://[%s]%s/", this.correctForm(), optionalPort); + }; + Address62.prototype.link = function(options) { + if (!options) { + options = {}; + } + if (options.className === void 0) { + options.className = ""; + } + if (options.prefix === void 0) { + options.prefix = "/#address="; + } + if (options.v4 === void 0) { + options.v4 = false; + } + var formFunction = this.correctForm; + if (options.v4) { + formFunction = this.to4in6; + } + if (options.className) { + return sprintf_js_1.sprintf('%2$s', options.prefix, formFunction.call(this), options.className); + } + return sprintf_js_1.sprintf('%2$s', options.prefix, formFunction.call(this)); + }; + Address62.prototype.group = function() { + if (this.elidedGroups === 0) { + return helpers.simpleGroup(this.address).join(":"); + } + assert(typeof this.elidedGroups === "number"); + assert(typeof this.elisionBegin === "number"); + var output = []; + var _a = this.address.split("::"), left = _a[0], right = _a[1]; + if (left.length) { + output.push.apply(output, helpers.simpleGroup(left)); + } else { + output.push(""); + } + var classes = ["hover-group"]; + for (var i = this.elisionBegin; i < this.elisionBegin + this.elidedGroups; i++) { + classes.push(sprintf_js_1.sprintf("group-%d", i)); + } + output.push(sprintf_js_1.sprintf('', classes.join(" "))); + if (right.length) { + output.push.apply(output, helpers.simpleGroup(right, this.elisionEnd)); + } else { + output.push(""); + } + if (this.is4()) { + assert(this.address4 instanceof ipv4_1.Address4); + output.pop(); + output.push(this.address4.groupForV6()); + } + return output.join(":"); + }; + Address62.prototype.regularExpressionString = function(substringSearch) { + if (substringSearch === void 0) { + substringSearch = false; + } + var output = []; + var address6 = new Address62(this.correctForm()); + if (address6.elidedGroups === 0) { + output.push(regular_expressions_1.simpleRegularExpression(address6.parsedAddress)); + } else if (address6.elidedGroups === constants6.GROUPS) { + output.push(regular_expressions_1.possibleElisions(constants6.GROUPS)); + } else { + var halves = address6.address.split("::"); + if (halves[0].length) { + output.push(regular_expressions_1.simpleRegularExpression(halves[0].split(":"))); + } + assert(typeof address6.elidedGroups === "number"); + output.push(regular_expressions_1.possibleElisions(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0)); + if (halves[1].length) { + output.push(regular_expressions_1.simpleRegularExpression(halves[1].split(":"))); + } + output = [output.join(":")]; + } + if (!substringSearch) { + output = __spreadArrays([ + "(?=^|", + regular_expressions_1.ADDRESS_BOUNDARY, + "|[^\\w\\:])(" + ], output, [ + ")(?=[^\\w\\:]|", + regular_expressions_1.ADDRESS_BOUNDARY, + "|$)" + ]); + } + return output.join(""); + }; + Address62.prototype.regularExpression = function(substringSearch) { + if (substringSearch === void 0) { + substringSearch = false; + } + return new RegExp(this.regularExpressionString(substringSearch), "i"); + }; + return Address62; + }(); + exports.Address6 = Address6; + } +}); + +// node_modules/ip-address/dist/ip-address.js +var require_ip_address = __commonJS({ + "node_modules/ip-address/dist/ip-address.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding(result, mod, k); + } + __setModuleDefault(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.v6 = exports.Address6 = exports.Address4 = void 0; + var ipv4_1 = require_ipv4(); + Object.defineProperty(exports, "Address4", { enumerable: true, get: function() { + return ipv4_1.Address4; + } }); + var ipv6_1 = require_ipv6(); + Object.defineProperty(exports, "Address6", { enumerable: true, get: function() { + return ipv6_1.Address6; + } }); + var helpers = __importStar(require_helpers()); + exports.v6 = { helpers }; + } +}); + +// node_modules/ip-cidr/index.js +var require_ip_cidr = __commonJS({ + "node_modules/ip-cidr/index.js"(exports, module) { + "use strict"; + var ipAddress = require_ip_address(); + var BigInteger = require_jsbn().BigInteger; + var IPCIDR2 = class { + constructor(cidr) { + if (typeof cidr !== "string" || !cidr.match("/")) { + throw new Error("Invalid CIDR address."); + } + const address = this.constructor.createAddress(cidr); + this.cidr = address.address; + this.ipAddressType = address.constructor; + this.address = address; + this.addressStart = address.startAddress(); + this.addressEnd = address.endAddress(); + this.addressStart.subnet = this.addressEnd.subnet = this.address.subnet; + this.addressStart.subnetMask = this.addressEnd.subnetMask = this.address.subnetMask; + this.size = new BigInteger(this.addressEnd.bigInteger().subtract(this.addressStart.bigInteger()).add(new BigInteger("1")).toString()); + } + contains(address) { + try { + if (!(address instanceof ipAddress.Address6) && !(address instanceof ipAddress.Address4)) { + if (typeof address == "object") { + address = this.ipAddressType.fromBigInteger(address); + } else { + address = this.constructor.createAddress(address); + } + } + return address.isInSubnet(this.address); + } catch (err) { + return false; + } + } + start(options) { + return this.constructor.formatIP(this.addressStart, options); + } + end(options) { + return this.constructor.formatIP(this.addressEnd, options); + } + toString() { + return this.cidr; + } + toRange(options) { + return [this.constructor.formatIP(this.addressStart, options), this.constructor.formatIP(this.addressEnd, options)]; + } + toObject(options) { + return { + start: this.constructor.formatIP(this.addressStart, options), + end: this.constructor.formatIP(this.addressEnd, options) + }; + } + toArray(options, results) { + options = options || {}; + const list = []; + const start = this.constructor.formatIP(this.addressStart, { type: "bigInteger" }); + const end = this.constructor.formatIP(this.addressEnd, { type: "bigInteger" }); + const length = end.subtract(start).add(new BigInteger("1")); + const info = this.getChunkInfo(length, options); + if (results) { + Object.assign(results, info); + } + this.loopInfo(info, (val) => { + const num = start.add(val); + const ip = this.constructor.formatIP(this.ipAddressType.fromBigInteger(num), options); + list.push(ip); + }); + return list; + } + loop(fn, options, results) { + options = options || {}; + const promise = []; + const start = this.constructor.formatIP(this.addressStart, { type: "bigInteger" }); + const end = this.constructor.formatIP(this.addressEnd, { type: "bigInteger" }); + const length = end.subtract(start).add(new BigInteger("1")); + const info = this.getChunkInfo(length, options); + if (results) { + Object.assign(results, info); + } + this.loopInfo(info, (val) => { + const num = start.add(val); + const ip = this.constructor.formatIP(this.ipAddressType.fromBigInteger(num), options); + promise.push(fn(ip)); + }); + return Promise.all(promise); + } + loopInfo(info, fn) { + let i = info.from; + while (i.compareTo(info.to) < 0) { + fn(i); + i = i.add(new BigInteger("1")); + } + } + getChunkInfo(length, options) { + let from = options.from; + let limit = options.limit; + let to = options.to; + let maxLength; + const addressBigInteger = this.constructor.formatIP(this.address, { type: "bigInteger" }); + const getBigInteger = (val) => { + if (typeof val == "string" && val.match(/:|\./)) { + return this.constructor.formatIP(this.constructor.createAddress(val), { type: "bigInteger" }).subtract(addressBigInteger); + } else if (typeof val != "object") { + return new BigInteger(val + ""); + } + return val; + }; + from = getBigInteger(from !== void 0 ? from : 0); + if (to !== void 0) { + to = getBigInteger(to); + limit = to.subtract(from); + } else { + limit = limit !== void 0 ? getBigInteger(limit) : length; + } + maxLength = length.subtract(from); + if (limit.compareTo(maxLength) > 0) { + limit = maxLength; + } + to = from.add(limit); + return { + from, + to, + limit, + length + }; + } + }; + IPCIDR2.formatIP = function(address, options) { + options = options || {}; + if (options.type == "bigInteger") { + return new BigInteger(address.bigInteger().toString()); + } else if (options.type == "addressObject") { + return address; + } + return address.addressMinusSuffix; + }; + IPCIDR2.createAddress = function(val) { + if (typeof val !== "string") { + throw new Error("Invalid IP address."); + } + val.match(/:.\./) && (val = val.split(":").pop()); + const ipAddressType = val.match(":") ? ipAddress.Address6 : ipAddress.Address4; + let ip = new ipAddressType(val); + if (ip.v4 && val.match(":") && ip.address4) { + ip = ip.address4; + } + if (ip.v4) { + const parts = ip.addressMinusSuffix.split("."); + for (let i = 0; i < parts.length; i++) { + const part = parts[i].split("/")[0]; + if (part[0] == "0" && part.length > 1) { + throw new Error("Invalid IPv4 address."); + } + } + } + return ip; + }; + IPCIDR2.isValidAddress = function(address) { + try { + return !!this.createAddress(address); + } catch (err) { + return false; + } + }; + IPCIDR2.isValidCIDR = function(address) { + if (typeof address !== "string" || !address.match("/")) { + return false; + } + try { + return !!this.createAddress(address); + } catch (err) { + return false; + } + }; + module.exports = IPCIDR2; + } +}); + +// src/cidr.js +var import_ip_cidr = __toESM(require_ip_cidr()); +var chunk = "0".repeat(1024 * 5); +var cidr_default = { + async fetch(request, env, ctx) { + const isin = checkIPInCIDR("192.168.1.1", "102.1.5.2/24"); + return new Response(null, { + status: 101 + }); + } +}; +function checkIPInCIDR(ip, cidr) { + const cidrObject = new import_ip_cidr.default(cidr); + return cidrObject.contains(ip); +} +export { + cidr_default as default +}; +//# sourceMappingURL=cidr.js.map diff --git a/dist/cidr.js.map b/dist/cidr.js.map new file mode 100644 index 0000000..fe85482 --- /dev/null +++ b/dist/cidr.js.map @@ -0,0 +1,8 @@ +{ + "version": 3, + "sources": ["../node_modules/ip-address/dist/lib/common.js", "../node_modules/ip-address/dist/lib/v4/constants.js", "../node_modules/ip-address/dist/lib/address-error.js", "../node_modules/jsbn/index.js", "../node_modules/sprintf-js/src/sprintf.js", "../node_modules/ip-address/dist/lib/ipv4.js", "../node_modules/ip-address/dist/lib/v6/constants.js", "../node_modules/ip-address/dist/lib/v6/helpers.js", "../node_modules/ip-address/dist/lib/v6/regular-expressions.js", "../node_modules/ip-address/dist/lib/ipv6.js", "../node_modules/ip-address/dist/ip-address.js", "../node_modules/ip-cidr/index.js", "../src/cidr.js"], + "sourceRoot": "./dist", + "sourcesContent": ["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isCorrect = exports.isInSubnet = void 0;\nfunction isInSubnet(address) {\n if (this.subnetMask < address.subnetMask) {\n return false;\n }\n if (this.mask(address.subnetMask) === address.mask()) {\n return true;\n }\n return false;\n}\nexports.isInSubnet = isInSubnet;\nfunction isCorrect(defaultBits) {\n return function () {\n if (this.addressMinusSuffix !== this.correctForm()) {\n return false;\n }\n if (this.subnetMask === defaultBits && !this.parsedSubnet) {\n return true;\n }\n return this.parsedSubnet === String(this.subnetMask);\n };\n}\nexports.isCorrect = isCorrect;\n//# sourceMappingURL=common.js.map", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = void 0;\nexports.BITS = 32;\nexports.GROUPS = 4;\nexports.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/g;\nexports.RE_SUBNET_STRING = /\\/\\d{1,2}$/;\n//# sourceMappingURL=constants.js.map", "\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AddressError = void 0;\nvar AddressError = /** @class */ (function (_super) {\n __extends(AddressError, _super);\n function AddressError(message, parseMessage) {\n var _this = _super.call(this, message) || this;\n _this.name = 'AddressError';\n if (parseMessage !== null) {\n _this.parseMessage = parseMessage;\n }\n return _this;\n }\n return AddressError;\n}(Error));\nexports.AddressError = AddressError;\n//# sourceMappingURL=address-error.js.map", "(function(){\n\n // Copyright (c) 2005 Tom Wu\n // All Rights Reserved.\n // See \"LICENSE\" for details.\n\n // Basic JavaScript BN library - subset useful for RSA encryption.\n\n // Bits per digit\n var dbits;\n\n // JavaScript engine analysis\n var canary = 0xdeadbeefcafe;\n var j_lm = ((canary&0xffffff)==0xefcafe);\n\n // (public) Constructor\n function BigInteger(a,b,c) {\n if(a != null)\n if(\"number\" == typeof a) this.fromNumber(a,b,c);\n else if(b == null && \"string\" != typeof a) this.fromString(a,256);\n else this.fromString(a,b);\n }\n\n // return new, unset BigInteger\n function nbi() { return new BigInteger(null); }\n\n // am: Compute w_j += (x*this_i), propagate carries,\n // c is initial carry, returns final carry.\n // c < 3*dvalue, x < 2*dvalue, this_i < dvalue\n // We need to select the fastest one that works in this environment.\n\n // am1: use a single mult and divide to get the high bits,\n // max digit bits should be 26 because\n // max internal value = 2*dvalue^2-2*dvalue (< 2^53)\n function am1(i,x,w,j,c,n) {\n while(--n >= 0) {\n var v = x*this[i++]+w[j]+c;\n c = Math.floor(v/0x4000000);\n w[j++] = v&0x3ffffff;\n }\n return c;\n }\n // am2 avoids a big mult-and-extract completely.\n // Max digit bits should be <= 30 because we do bitwise ops\n // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)\n function am2(i,x,w,j,c,n) {\n var xl = x&0x7fff, xh = x>>15;\n while(--n >= 0) {\n var l = this[i]&0x7fff;\n var h = this[i++]>>15;\n var m = xh*l+h*xl;\n l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);\n c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);\n w[j++] = l&0x3fffffff;\n }\n return c;\n }\n // Alternately, set max digit bits to 28 since some\n // browsers slow down when dealing with 32-bit numbers.\n function am3(i,x,w,j,c,n) {\n var xl = x&0x3fff, xh = x>>14;\n while(--n >= 0) {\n var l = this[i]&0x3fff;\n var h = this[i++]>>14;\n var m = xh*l+h*xl;\n l = xl*l+((m&0x3fff)<<14)+w[j]+c;\n c = (l>>28)+(m>>14)+xh*h;\n w[j++] = l&0xfffffff;\n }\n return c;\n }\n var inBrowser = typeof navigator !== \"undefined\";\n if(inBrowser && j_lm && (navigator.appName == \"Microsoft Internet Explorer\")) {\n BigInteger.prototype.am = am2;\n dbits = 30;\n }\n else if(inBrowser && j_lm && (navigator.appName != \"Netscape\")) {\n BigInteger.prototype.am = am1;\n dbits = 26;\n }\n else { // Mozilla/Netscape seems to prefer am3\n BigInteger.prototype.am = am3;\n dbits = 28;\n }\n\n BigInteger.prototype.DB = dbits;\n BigInteger.prototype.DM = ((1<= 0; --i) r[i] = this[i];\n r.t = this.t;\n r.s = this.s;\n }\n\n // (protected) set from integer value x, -DV <= x < DV\n function bnpFromInt(x) {\n this.t = 1;\n this.s = (x<0)?-1:0;\n if(x > 0) this[0] = x;\n else if(x < -1) this[0] = x+this.DV;\n else this.t = 0;\n }\n\n // return bigint initialized to value\n function nbv(i) { var r = nbi(); r.fromInt(i); return r; }\n\n // (protected) set from string and radix\n function bnpFromString(s,b) {\n var k;\n if(b == 16) k = 4;\n else if(b == 8) k = 3;\n else if(b == 256) k = 8; // byte array\n else if(b == 2) k = 1;\n else if(b == 32) k = 5;\n else if(b == 4) k = 2;\n else { this.fromRadix(s,b); return; }\n this.t = 0;\n this.s = 0;\n var i = s.length, mi = false, sh = 0;\n while(--i >= 0) {\n var x = (k==8)?s[i]&0xff:intAt(s,i);\n if(x < 0) {\n if(s.charAt(i) == \"-\") mi = true;\n continue;\n }\n mi = false;\n if(sh == 0)\n this[this.t++] = x;\n else if(sh+k > this.DB) {\n this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<>(this.DB-sh));\n }\n else\n this[this.t-1] |= x<= this.DB) sh -= this.DB;\n }\n if(k == 8 && (s[0]&0x80) != 0) {\n this.s = -1;\n if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)< 0 && this[this.t-1] == c) --this.t;\n }\n\n // (public) return string representation in given radix\n function bnToString(b) {\n if(this.s < 0) return \"-\"+this.negate().toString(b);\n var k;\n if(b == 16) k = 4;\n else if(b == 8) k = 3;\n else if(b == 2) k = 1;\n else if(b == 32) k = 5;\n else if(b == 4) k = 2;\n else return this.toRadix(b);\n var km = (1< 0) {\n if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }\n while(i >= 0) {\n if(p < k) {\n d = (this[i]&((1<>(p+=this.DB-k);\n }\n else {\n d = (this[i]>>(p-=k))&km;\n if(p <= 0) { p += this.DB; --i; }\n }\n if(d > 0) m = true;\n if(m) r += int2char(d);\n }\n }\n return m?r:\"0\";\n }\n\n // (public) -this\n function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }\n\n // (public) |this|\n function bnAbs() { return (this.s<0)?this.negate():this; }\n\n // (public) return + if this > a, - if this < a, 0 if equal\n function bnCompareTo(a) {\n var r = this.s-a.s;\n if(r != 0) return r;\n var i = this.t;\n r = i-a.t;\n if(r != 0) return (this.s<0)?-r:r;\n while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;\n return 0;\n }\n\n // returns bit length of the integer x\n function nbits(x) {\n var r = 1, t;\n if((t=x>>>16) != 0) { x = t; r += 16; }\n if((t=x>>8) != 0) { x = t; r += 8; }\n if((t=x>>4) != 0) { x = t; r += 4; }\n if((t=x>>2) != 0) { x = t; r += 2; }\n if((t=x>>1) != 0) { x = t; r += 1; }\n return r;\n }\n\n // (public) return the number of bits in \"this\"\n function bnBitLength() {\n if(this.t <= 0) return 0;\n return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));\n }\n\n // (protected) r = this << n*DB\n function bnpDLShiftTo(n,r) {\n var i;\n for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];\n for(i = n-1; i >= 0; --i) r[i] = 0;\n r.t = this.t+n;\n r.s = this.s;\n }\n\n // (protected) r = this >> n*DB\n function bnpDRShiftTo(n,r) {\n for(var i = n; i < this.t; ++i) r[i-n] = this[i];\n r.t = Math.max(this.t-n,0);\n r.s = this.s;\n }\n\n // (protected) r = this << n\n function bnpLShiftTo(n,r) {\n var bs = n%this.DB;\n var cbs = this.DB-bs;\n var bm = (1<= 0; --i) {\n r[i+ds+1] = (this[i]>>cbs)|c;\n c = (this[i]&bm)<= 0; --i) r[i] = 0;\n r[ds] = c;\n r.t = this.t+ds+1;\n r.s = this.s;\n r.clamp();\n }\n\n // (protected) r = this >> n\n function bnpRShiftTo(n,r) {\n r.s = this.s;\n var ds = Math.floor(n/this.DB);\n if(ds >= this.t) { r.t = 0; return; }\n var bs = n%this.DB;\n var cbs = this.DB-bs;\n var bm = (1<>bs;\n for(var i = ds+1; i < this.t; ++i) {\n r[i-ds-1] |= (this[i]&bm)<>bs;\n }\n if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<>= this.DB;\n }\n if(a.t < this.t) {\n c -= a.s;\n while(i < this.t) {\n c += this[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n c += this.s;\n }\n else {\n c += this.s;\n while(i < a.t) {\n c -= a[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n c -= a.s;\n }\n r.s = (c<0)?-1:0;\n if(c < -1) r[i++] = this.DV+c;\n else if(c > 0) r[i++] = c;\n r.t = i;\n r.clamp();\n }\n\n // (protected) r = this * a, r != this,a (HAC 14.12)\n // \"this\" should be the larger one if appropriate.\n function bnpMultiplyTo(a,r) {\n var x = this.abs(), y = a.abs();\n var i = x.t;\n r.t = i+y.t;\n while(--i >= 0) r[i] = 0;\n for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);\n r.s = 0;\n r.clamp();\n if(this.s != a.s) BigInteger.ZERO.subTo(r,r);\n }\n\n // (protected) r = this^2, r != this (HAC 14.16)\n function bnpSquareTo(r) {\n var x = this.abs();\n var i = r.t = 2*x.t;\n while(--i >= 0) r[i] = 0;\n for(i = 0; i < x.t-1; ++i) {\n var c = x.am(i,x[i],r,2*i,0,1);\n if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {\n r[i+x.t] -= x.DV;\n r[i+x.t+1] = 1;\n }\n }\n if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);\n r.s = 0;\n r.clamp();\n }\n\n // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)\n // r != q, this != m. q or r may be null.\n function bnpDivRemTo(m,q,r) {\n var pm = m.abs();\n if(pm.t <= 0) return;\n var pt = this.abs();\n if(pt.t < pm.t) {\n if(q != null) q.fromInt(0);\n if(r != null) this.copyTo(r);\n return;\n }\n if(r == null) r = nbi();\n var y = nbi(), ts = this.s, ms = m.s;\n var nsh = this.DB-nbits(pm[pm.t-1]); // normalize modulus\n if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }\n else { pm.copyTo(y); pt.copyTo(r); }\n var ys = y.t;\n var y0 = y[ys-1];\n if(y0 == 0) return;\n var yt = y0*(1<1)?y[ys-2]>>this.F2:0);\n var d1 = this.FV/yt, d2 = (1<= 0) {\n r[r.t++] = 1;\n r.subTo(t,r);\n }\n BigInteger.ONE.dlShiftTo(ys,t);\n t.subTo(y,y); // \"negative\" y so we can replace sub with am later\n while(y.t < ys) y[y.t++] = 0;\n while(--j >= 0) {\n // Estimate quotient digit\n var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);\n if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out\n y.dlShiftTo(j,t);\n r.subTo(t,r);\n while(r[i] < --qd) r.subTo(t,r);\n }\n }\n if(q != null) {\n r.drShiftTo(ys,q);\n if(ts != ms) BigInteger.ZERO.subTo(q,q);\n }\n r.t = ys;\n r.clamp();\n if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder\n if(ts < 0) BigInteger.ZERO.subTo(r,r);\n }\n\n // (public) this mod a\n function bnMod(a) {\n var r = nbi();\n this.abs().divRemTo(a,null,r);\n if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);\n return r;\n }\n\n // Modular reduction using \"classic\" algorithm\n function Classic(m) { this.m = m; }\n function cConvert(x) {\n if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);\n else return x;\n }\n function cRevert(x) { return x; }\n function cReduce(x) { x.divRemTo(this.m,null,x); }\n function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }\n function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }\n\n Classic.prototype.convert = cConvert;\n Classic.prototype.revert = cRevert;\n Classic.prototype.reduce = cReduce;\n Classic.prototype.mulTo = cMulTo;\n Classic.prototype.sqrTo = cSqrTo;\n\n // (protected) return \"-1/this % 2^DB\"; useful for Mont. reduction\n // justification:\n // xy == 1 (mod m)\n // xy = 1+km\n // xy(2-xy) = (1+km)(1-km)\n // x[y(2-xy)] = 1-k^2m^2\n // x[y(2-xy)] == 1 (mod m^2)\n // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2\n // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.\n // JS multiply \"overflows\" differently from C/C++, so care is needed here.\n function bnpInvDigit() {\n if(this.t < 1) return 0;\n var x = this[0];\n if((x&1) == 0) return 0;\n var y = x&3; // y == 1/x mod 2^2\n y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4\n y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8\n y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16\n // last step - calculate inverse mod DV directly;\n // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints\n y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits\n // we really want the negative inverse, and -DV < y < DV\n return (y>0)?this.DV-y:-y;\n }\n\n // Montgomery reduction\n function Montgomery(m) {\n this.m = m;\n this.mp = m.invDigit();\n this.mpl = this.mp&0x7fff;\n this.mph = this.mp>>15;\n this.um = (1<<(m.DB-15))-1;\n this.mt2 = 2*m.t;\n }\n\n // xR mod m\n function montConvert(x) {\n var r = nbi();\n x.abs().dlShiftTo(this.m.t,r);\n r.divRemTo(this.m,null,r);\n if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);\n return r;\n }\n\n // x/R mod m\n function montRevert(x) {\n var r = nbi();\n x.copyTo(r);\n this.reduce(r);\n return r;\n }\n\n // x = x/R mod m (HAC 14.32)\n function montReduce(x) {\n while(x.t <= this.mt2) // pad x so am has enough room later\n x[x.t++] = 0;\n for(var i = 0; i < this.m.t; ++i) {\n // faster way of calculating u0 = x[i]*mp mod DV\n var j = x[i]&0x7fff;\n var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;\n // use am to combine the multiply-shift-add into one call\n j = i+this.m.t;\n x[j] += this.m.am(0,u0,x,i,0,this.m.t);\n // propagate carry\n while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }\n }\n x.clamp();\n x.drShiftTo(this.m.t,x);\n if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);\n }\n\n // r = \"x^2/R mod m\"; x != r\n function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }\n\n // r = \"xy/R mod m\"; x,y != r\n function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }\n\n Montgomery.prototype.convert = montConvert;\n Montgomery.prototype.revert = montRevert;\n Montgomery.prototype.reduce = montReduce;\n Montgomery.prototype.mulTo = montMulTo;\n Montgomery.prototype.sqrTo = montSqrTo;\n\n // (protected) true iff this is even\n function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }\n\n // (protected) this^e, e < 2^32, doing sqr and mul with \"r\" (HAC 14.79)\n function bnpExp(e,z) {\n if(e > 0xffffffff || e < 1) return BigInteger.ONE;\n var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;\n g.copyTo(r);\n while(--i >= 0) {\n z.sqrTo(r,r2);\n if((e&(1< 0) z.mulTo(r2,g,r);\n else { var t = r; r = r2; r2 = t; }\n }\n return z.revert(r);\n }\n\n // (public) this^e % m, 0 <= e < 2^32\n function bnModPowInt(e,m) {\n var z;\n if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);\n return this.exp(e,z);\n }\n\n // protected\n BigInteger.prototype.copyTo = bnpCopyTo;\n BigInteger.prototype.fromInt = bnpFromInt;\n BigInteger.prototype.fromString = bnpFromString;\n BigInteger.prototype.clamp = bnpClamp;\n BigInteger.prototype.dlShiftTo = bnpDLShiftTo;\n BigInteger.prototype.drShiftTo = bnpDRShiftTo;\n BigInteger.prototype.lShiftTo = bnpLShiftTo;\n BigInteger.prototype.rShiftTo = bnpRShiftTo;\n BigInteger.prototype.subTo = bnpSubTo;\n BigInteger.prototype.multiplyTo = bnpMultiplyTo;\n BigInteger.prototype.squareTo = bnpSquareTo;\n BigInteger.prototype.divRemTo = bnpDivRemTo;\n BigInteger.prototype.invDigit = bnpInvDigit;\n BigInteger.prototype.isEven = bnpIsEven;\n BigInteger.prototype.exp = bnpExp;\n\n // public\n BigInteger.prototype.toString = bnToString;\n BigInteger.prototype.negate = bnNegate;\n BigInteger.prototype.abs = bnAbs;\n BigInteger.prototype.compareTo = bnCompareTo;\n BigInteger.prototype.bitLength = bnBitLength;\n BigInteger.prototype.mod = bnMod;\n BigInteger.prototype.modPowInt = bnModPowInt;\n\n // \"constants\"\n BigInteger.ZERO = nbv(0);\n BigInteger.ONE = nbv(1);\n\n // Copyright (c) 2005-2009 Tom Wu\n // All Rights Reserved.\n // See \"LICENSE\" for details.\n\n // Extended JavaScript BN functions, required for RSA private ops.\n\n // Version 1.1: new BigInteger(\"0\", 10) returns \"proper\" zero\n // Version 1.2: square() API, isProbablePrime fix\n\n // (public)\n function bnClone() { var r = nbi(); this.copyTo(r); return r; }\n\n // (public) return value as integer\n function bnIntValue() {\n if(this.s < 0) {\n if(this.t == 1) return this[0]-this.DV;\n else if(this.t == 0) return -1;\n }\n else if(this.t == 1) return this[0];\n else if(this.t == 0) return 0;\n // assumes 16 < DB < 32\n return ((this[1]&((1<<(32-this.DB))-1))<>24; }\n\n // (public) return value as short (assumes DB>=16)\n function bnShortValue() { return (this.t==0)?this.s:(this[0]<<16)>>16; }\n\n // (protected) return x s.t. r^x < DV\n function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }\n\n // (public) 0 if this == 0, 1 if this > 0\n function bnSigNum() {\n if(this.s < 0) return -1;\n else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;\n else return 1;\n }\n\n // (protected) convert to radix string\n function bnpToRadix(b) {\n if(b == null) b = 10;\n if(this.signum() == 0 || b < 2 || b > 36) return \"0\";\n var cs = this.chunkSize(b);\n var a = Math.pow(b,cs);\n var d = nbv(a), y = nbi(), z = nbi(), r = \"\";\n this.divRemTo(d,y,z);\n while(y.signum() > 0) {\n r = (a+z.intValue()).toString(b).substr(1) + r;\n y.divRemTo(d,y,z);\n }\n return z.intValue().toString(b) + r;\n }\n\n // (protected) convert from radix string\n function bnpFromRadix(s,b) {\n this.fromInt(0);\n if(b == null) b = 10;\n var cs = this.chunkSize(b);\n var d = Math.pow(b,cs), mi = false, j = 0, w = 0;\n for(var i = 0; i < s.length; ++i) {\n var x = intAt(s,i);\n if(x < 0) {\n if(s.charAt(i) == \"-\" && this.signum() == 0) mi = true;\n continue;\n }\n w = b*w+x;\n if(++j >= cs) {\n this.dMultiply(d);\n this.dAddOffset(w,0);\n j = 0;\n w = 0;\n }\n }\n if(j > 0) {\n this.dMultiply(Math.pow(b,j));\n this.dAddOffset(w,0);\n }\n if(mi) BigInteger.ZERO.subTo(this,this);\n }\n\n // (protected) alternate constructor\n function bnpFromNumber(a,b,c) {\n if(\"number\" == typeof b) {\n // new BigInteger(int,int,RNG)\n if(a < 2) this.fromInt(1);\n else {\n this.fromNumber(a,c);\n if(!this.testBit(a-1)) // force MSB set\n this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);\n if(this.isEven()) this.dAddOffset(1,0); // force odd\n while(!this.isProbablePrime(b)) {\n this.dAddOffset(2,0);\n if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this);\n }\n }\n }\n else {\n // new BigInteger(int,RNG)\n var x = new Array(), t = a&7;\n x.length = (a>>3)+1;\n b.nextBytes(x);\n if(t > 0) x[0] &= ((1< 0) {\n if(p < this.DB && (d = this[i]>>p) != (this.s&this.DM)>>p)\n r[k++] = d|(this.s<<(this.DB-p));\n while(i >= 0) {\n if(p < 8) {\n d = (this[i]&((1<>(p+=this.DB-8);\n }\n else {\n d = (this[i]>>(p-=8))&0xff;\n if(p <= 0) { p += this.DB; --i; }\n }\n if((d&0x80) != 0) d |= -256;\n if(k == 0 && (this.s&0x80) != (d&0x80)) ++k;\n if(k > 0 || d != this.s) r[k++] = d;\n }\n }\n return r;\n }\n\n function bnEquals(a) { return(this.compareTo(a)==0); }\n function bnMin(a) { return(this.compareTo(a)<0)?this:a; }\n function bnMax(a) { return(this.compareTo(a)>0)?this:a; }\n\n // (protected) r = this op a (bitwise)\n function bnpBitwiseTo(a,op,r) {\n var i, f, m = Math.min(a.t,this.t);\n for(i = 0; i < m; ++i) r[i] = op(this[i],a[i]);\n if(a.t < this.t) {\n f = a.s&this.DM;\n for(i = m; i < this.t; ++i) r[i] = op(this[i],f);\n r.t = this.t;\n }\n else {\n f = this.s&this.DM;\n for(i = m; i < a.t; ++i) r[i] = op(f,a[i]);\n r.t = a.t;\n }\n r.s = op(this.s,a.s);\n r.clamp();\n }\n\n // (public) this & a\n function op_and(x,y) { return x&y; }\n function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; }\n\n // (public) this | a\n function op_or(x,y) { return x|y; }\n function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; }\n\n // (public) this ^ a\n function op_xor(x,y) { return x^y; }\n function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; }\n\n // (public) this & ~a\n function op_andnot(x,y) { return x&~y; }\n function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; }\n\n // (public) ~this\n function bnNot() {\n var r = nbi();\n for(var i = 0; i < this.t; ++i) r[i] = this.DM&~this[i];\n r.t = this.t;\n r.s = ~this.s;\n return r;\n }\n\n // (public) this << n\n function bnShiftLeft(n) {\n var r = nbi();\n if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r);\n return r;\n }\n\n // (public) this >> n\n function bnShiftRight(n) {\n var r = nbi();\n if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r);\n return r;\n }\n\n // return index of lowest 1-bit in x, x < 2^31\n function lbit(x) {\n if(x == 0) return -1;\n var r = 0;\n if((x&0xffff) == 0) { x >>= 16; r += 16; }\n if((x&0xff) == 0) { x >>= 8; r += 8; }\n if((x&0xf) == 0) { x >>= 4; r += 4; }\n if((x&3) == 0) { x >>= 2; r += 2; }\n if((x&1) == 0) ++r;\n return r;\n }\n\n // (public) returns index of lowest 1-bit (or -1 if none)\n function bnGetLowestSetBit() {\n for(var i = 0; i < this.t; ++i)\n if(this[i] != 0) return i*this.DB+lbit(this[i]);\n if(this.s < 0) return this.t*this.DB;\n return -1;\n }\n\n // return number of 1 bits in x\n function cbit(x) {\n var r = 0;\n while(x != 0) { x &= x-1; ++r; }\n return r;\n }\n\n // (public) return number of set bits\n function bnBitCount() {\n var r = 0, x = this.s&this.DM;\n for(var i = 0; i < this.t; ++i) r += cbit(this[i]^x);\n return r;\n }\n\n // (public) true iff nth bit is set\n function bnTestBit(n) {\n var j = Math.floor(n/this.DB);\n if(j >= this.t) return(this.s!=0);\n return((this[j]&(1<<(n%this.DB)))!=0);\n }\n\n // (protected) this op (1<>= this.DB;\n }\n if(a.t < this.t) {\n c += a.s;\n while(i < this.t) {\n c += this[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n c += this.s;\n }\n else {\n c += this.s;\n while(i < a.t) {\n c += a[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n c += a.s;\n }\n r.s = (c<0)?-1:0;\n if(c > 0) r[i++] = c;\n else if(c < -1) r[i++] = this.DV+c;\n r.t = i;\n r.clamp();\n }\n\n // (public) this + a\n function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; }\n\n // (public) this - a\n function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; }\n\n // (public) this * a\n function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; }\n\n // (public) this^2\n function bnSquare() { var r = nbi(); this.squareTo(r); return r; }\n\n // (public) this / a\n function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; }\n\n // (public) this % a\n function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; }\n\n // (public) [this/a,this%a]\n function bnDivideAndRemainder(a) {\n var q = nbi(), r = nbi();\n this.divRemTo(a,q,r);\n return new Array(q,r);\n }\n\n // (protected) this *= n, this >= 0, 1 < n < DV\n function bnpDMultiply(n) {\n this[this.t] = this.am(0,n-1,this,0,0,this.t);\n ++this.t;\n this.clamp();\n }\n\n // (protected) this += n << w words, this >= 0\n function bnpDAddOffset(n,w) {\n if(n == 0) return;\n while(this.t <= w) this[this.t++] = 0;\n this[w] += n;\n while(this[w] >= this.DV) {\n this[w] -= this.DV;\n if(++w >= this.t) this[this.t++] = 0;\n ++this[w];\n }\n }\n\n // A \"null\" reducer\n function NullExp() {}\n function nNop(x) { return x; }\n function nMulTo(x,y,r) { x.multiplyTo(y,r); }\n function nSqrTo(x,r) { x.squareTo(r); }\n\n NullExp.prototype.convert = nNop;\n NullExp.prototype.revert = nNop;\n NullExp.prototype.mulTo = nMulTo;\n NullExp.prototype.sqrTo = nSqrTo;\n\n // (public) this^e\n function bnPow(e) { return this.exp(e,new NullExp()); }\n\n // (protected) r = lower n words of \"this * a\", a.t <= n\n // \"this\" should be the larger one if appropriate.\n function bnpMultiplyLowerTo(a,n,r) {\n var i = Math.min(this.t+a.t,n);\n r.s = 0; // assumes a,this >= 0\n r.t = i;\n while(i > 0) r[--i] = 0;\n var j;\n for(j = r.t-this.t; i < j; ++i) r[i+this.t] = this.am(0,a[i],r,i,0,this.t);\n for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a[i],r,i,0,n-i);\n r.clamp();\n }\n\n // (protected) r = \"this * a\" without lower n words, n > 0\n // \"this\" should be the larger one if appropriate.\n function bnpMultiplyUpperTo(a,n,r) {\n --n;\n var i = r.t = this.t+a.t-n;\n r.s = 0; // assumes a,this >= 0\n while(--i >= 0) r[i] = 0;\n for(i = Math.max(n-this.t,0); i < a.t; ++i)\n r[this.t+i-n] = this.am(n-i,a[i],r,0,0,this.t+i-n);\n r.clamp();\n r.drShiftTo(1,r);\n }\n\n // Barrett modular reduction\n function Barrett(m) {\n // setup Barrett\n this.r2 = nbi();\n this.q3 = nbi();\n BigInteger.ONE.dlShiftTo(2*m.t,this.r2);\n this.mu = this.r2.divide(m);\n this.m = m;\n }\n\n function barrettConvert(x) {\n if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m);\n else if(x.compareTo(this.m) < 0) return x;\n else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }\n }\n\n function barrettRevert(x) { return x; }\n\n // x = x mod m (HAC 14.42)\n function barrettReduce(x) {\n x.drShiftTo(this.m.t-1,this.r2);\n if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); }\n this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);\n this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);\n while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1);\n x.subTo(this.r2,x);\n while(x.compareTo(this.m) >= 0) x.subTo(this.m,x);\n }\n\n // r = x^2 mod m; x != r\n function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); }\n\n // r = x*y mod m; x,y != r\n function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }\n\n Barrett.prototype.convert = barrettConvert;\n Barrett.prototype.revert = barrettRevert;\n Barrett.prototype.reduce = barrettReduce;\n Barrett.prototype.mulTo = barrettMulTo;\n Barrett.prototype.sqrTo = barrettSqrTo;\n\n // (public) this^e % m (HAC 14.85)\n function bnModPow(e,m) {\n var i = e.bitLength(), k, r = nbv(1), z;\n if(i <= 0) return r;\n else if(i < 18) k = 1;\n else if(i < 48) k = 3;\n else if(i < 144) k = 4;\n else if(i < 768) k = 5;\n else k = 6;\n if(i < 8)\n z = new Classic(m);\n else if(m.isEven())\n z = new Barrett(m);\n else\n z = new Montgomery(m);\n\n // precomputation\n var g = new Array(), n = 3, k1 = k-1, km = (1< 1) {\n var g2 = nbi();\n z.sqrTo(g[1],g2);\n while(n <= km) {\n g[n] = nbi();\n z.mulTo(g2,g[n-2],g[n]);\n n += 2;\n }\n }\n\n var j = e.t-1, w, is1 = true, r2 = nbi(), t;\n i = nbits(e[j])-1;\n while(j >= 0) {\n if(i >= k1) w = (e[j]>>(i-k1))&km;\n else {\n w = (e[j]&((1<<(i+1))-1))<<(k1-i);\n if(j > 0) w |= e[j-1]>>(this.DB+i-k1);\n }\n\n n = k;\n while((w&1) == 0) { w >>= 1; --n; }\n if((i -= n) < 0) { i += this.DB; --j; }\n if(is1) { // ret == 1, don't bother squaring or multiplying it\n g[w].copyTo(r);\n is1 = false;\n }\n else {\n while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; }\n if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; }\n z.mulTo(r2,g[w],r);\n }\n\n while(j >= 0 && (e[j]&(1< 0) {\n x.rShiftTo(g,x);\n y.rShiftTo(g,y);\n }\n while(x.signum() > 0) {\n if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);\n if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);\n if(x.compareTo(y) >= 0) {\n x.subTo(y,x);\n x.rShiftTo(1,x);\n }\n else {\n y.subTo(x,y);\n y.rShiftTo(1,y);\n }\n }\n if(g > 0) y.lShiftTo(g,y);\n return y;\n }\n\n // (protected) this % n, n < 2^26\n function bnpModInt(n) {\n if(n <= 0) return 0;\n var d = this.DV%n, r = (this.s<0)?n-1:0;\n if(this.t > 0)\n if(d == 0) r = this[0]%n;\n else for(var i = this.t-1; i >= 0; --i) r = (d*r+this[i])%n;\n return r;\n }\n\n // (public) 1/this % m (HAC 14.61)\n function bnModInverse(m) {\n var ac = m.isEven();\n if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;\n var u = m.clone(), v = this.clone();\n var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);\n while(u.signum() != 0) {\n while(u.isEven()) {\n u.rShiftTo(1,u);\n if(ac) {\n if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }\n a.rShiftTo(1,a);\n }\n else if(!b.isEven()) b.subTo(m,b);\n b.rShiftTo(1,b);\n }\n while(v.isEven()) {\n v.rShiftTo(1,v);\n if(ac) {\n if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }\n c.rShiftTo(1,c);\n }\n else if(!d.isEven()) d.subTo(m,d);\n d.rShiftTo(1,d);\n }\n if(u.compareTo(v) >= 0) {\n u.subTo(v,u);\n if(ac) a.subTo(c,a);\n b.subTo(d,b);\n }\n else {\n v.subTo(u,v);\n if(ac) c.subTo(a,c);\n d.subTo(b,d);\n }\n }\n if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;\n if(d.compareTo(m) >= 0) return d.subtract(m);\n if(d.signum() < 0) d.addTo(m,d); else return d;\n if(d.signum() < 0) return d.add(m); else return d;\n }\n\n var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997];\n var lplim = (1<<26)/lowprimes[lowprimes.length-1];\n\n // (public) test primality with certainty >= 1-.5^t\n function bnIsProbablePrime(t) {\n var i, x = this.abs();\n if(x.t == 1 && x[0] <= lowprimes[lowprimes.length-1]) {\n for(i = 0; i < lowprimes.length; ++i)\n if(x[0] == lowprimes[i]) return true;\n return false;\n }\n if(x.isEven()) return false;\n i = 1;\n while(i < lowprimes.length) {\n var m = lowprimes[i], j = i+1;\n while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];\n m = x.modInt(m);\n while(i < j) if(m%lowprimes[i++] == 0) return false;\n }\n return x.millerRabin(t);\n }\n\n // (protected) true if probably prime (HAC 4.24, Miller-Rabin)\n function bnpMillerRabin(t) {\n var n1 = this.subtract(BigInteger.ONE);\n var k = n1.getLowestSetBit();\n if(k <= 0) return false;\n var r = n1.shiftRight(k);\n t = (t+1)>>1;\n if(t > lowprimes.length) t = lowprimes.length;\n var a = nbi();\n for(var i = 0; i < t; ++i) {\n //Pick bases at random, instead of starting at 2\n a.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]);\n var y = a.modPow(r,this);\n if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {\n var j = 1;\n while(j++ < k && y.compareTo(n1) != 0) {\n y = y.modPowInt(2,this);\n if(y.compareTo(BigInteger.ONE) == 0) return false;\n }\n if(y.compareTo(n1) != 0) return false;\n }\n }\n return true;\n }\n\n // protected\n BigInteger.prototype.chunkSize = bnpChunkSize;\n BigInteger.prototype.toRadix = bnpToRadix;\n BigInteger.prototype.fromRadix = bnpFromRadix;\n BigInteger.prototype.fromNumber = bnpFromNumber;\n BigInteger.prototype.bitwiseTo = bnpBitwiseTo;\n BigInteger.prototype.changeBit = bnpChangeBit;\n BigInteger.prototype.addTo = bnpAddTo;\n BigInteger.prototype.dMultiply = bnpDMultiply;\n BigInteger.prototype.dAddOffset = bnpDAddOffset;\n BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;\n BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;\n BigInteger.prototype.modInt = bnpModInt;\n BigInteger.prototype.millerRabin = bnpMillerRabin;\n\n // public\n BigInteger.prototype.clone = bnClone;\n BigInteger.prototype.intValue = bnIntValue;\n BigInteger.prototype.byteValue = bnByteValue;\n BigInteger.prototype.shortValue = bnShortValue;\n BigInteger.prototype.signum = bnSigNum;\n BigInteger.prototype.toByteArray = bnToByteArray;\n BigInteger.prototype.equals = bnEquals;\n BigInteger.prototype.min = bnMin;\n BigInteger.prototype.max = bnMax;\n BigInteger.prototype.and = bnAnd;\n BigInteger.prototype.or = bnOr;\n BigInteger.prototype.xor = bnXor;\n BigInteger.prototype.andNot = bnAndNot;\n BigInteger.prototype.not = bnNot;\n BigInteger.prototype.shiftLeft = bnShiftLeft;\n BigInteger.prototype.shiftRight = bnShiftRight;\n BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;\n BigInteger.prototype.bitCount = bnBitCount;\n BigInteger.prototype.testBit = bnTestBit;\n BigInteger.prototype.setBit = bnSetBit;\n BigInteger.prototype.clearBit = bnClearBit;\n BigInteger.prototype.flipBit = bnFlipBit;\n BigInteger.prototype.add = bnAdd;\n BigInteger.prototype.subtract = bnSubtract;\n BigInteger.prototype.multiply = bnMultiply;\n BigInteger.prototype.divide = bnDivide;\n BigInteger.prototype.remainder = bnRemainder;\n BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;\n BigInteger.prototype.modPow = bnModPow;\n BigInteger.prototype.modInverse = bnModInverse;\n BigInteger.prototype.pow = bnPow;\n BigInteger.prototype.gcd = bnGCD;\n BigInteger.prototype.isProbablePrime = bnIsProbablePrime;\n\n // JSBN-specific extension\n BigInteger.prototype.square = bnSquare;\n\n // Expose the Barrett function\n BigInteger.prototype.Barrett = Barrett\n\n // BigInteger interfaces not implemented in jsbn:\n\n // BigInteger(int signum, byte[] magnitude)\n // double doubleValue()\n // float floatValue()\n // int hashCode()\n // long longValue()\n // static BigInteger valueOf(long val)\n\n // Random number generator - requires a PRNG backend, e.g. prng4.js\n\n // For best results, put code like\n // \n // in your main HTML document.\n\n var rng_state;\n var rng_pool;\n var rng_pptr;\n\n // Mix in a 32-bit integer into the pool\n function rng_seed_int(x) {\n rng_pool[rng_pptr++] ^= x & 255;\n rng_pool[rng_pptr++] ^= (x >> 8) & 255;\n rng_pool[rng_pptr++] ^= (x >> 16) & 255;\n rng_pool[rng_pptr++] ^= (x >> 24) & 255;\n if(rng_pptr >= rng_psize) rng_pptr -= rng_psize;\n }\n\n // Mix in the current time (w/milliseconds) into the pool\n function rng_seed_time() {\n rng_seed_int(new Date().getTime());\n }\n\n // Initialize the pool with junk if needed.\n if(rng_pool == null) {\n rng_pool = new Array();\n rng_pptr = 0;\n var t;\n if(typeof window !== \"undefined\" && window.crypto) {\n if (window.crypto.getRandomValues) {\n // Use webcrypto if available\n var ua = new Uint8Array(32);\n window.crypto.getRandomValues(ua);\n for(t = 0; t < 32; ++t)\n rng_pool[rng_pptr++] = ua[t];\n }\n else if(navigator.appName == \"Netscape\" && navigator.appVersion < \"5\") {\n // Extract entropy (256 bits) from NS4 RNG if available\n var z = window.crypto.random(32);\n for(t = 0; t < z.length; ++t)\n rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;\n }\n }\n while(rng_pptr < rng_psize) { // extract some randomness from Math.random()\n t = Math.floor(65536 * Math.random());\n rng_pool[rng_pptr++] = t >>> 8;\n rng_pool[rng_pptr++] = t & 255;\n }\n rng_pptr = 0;\n rng_seed_time();\n //rng_seed_int(window.screenX);\n //rng_seed_int(window.screenY);\n }\n\n function rng_get_byte() {\n if(rng_state == null) {\n rng_seed_time();\n rng_state = prng_newstate();\n rng_state.init(rng_pool);\n for(rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)\n rng_pool[rng_pptr] = 0;\n rng_pptr = 0;\n //rng_pool = null;\n }\n // TODO: allow reseeding after first request\n return rng_state.next();\n }\n\n function rng_get_bytes(ba) {\n var i;\n for(i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();\n }\n\n function SecureRandom() {}\n\n SecureRandom.prototype.nextBytes = rng_get_bytes;\n\n // prng4.js - uses Arcfour as a PRNG\n\n function Arcfour() {\n this.i = 0;\n this.j = 0;\n this.S = new Array();\n }\n\n // Initialize arcfour context from key, an array of ints, each from [0..255]\n function ARC4init(key) {\n var i, j, t;\n for(i = 0; i < 256; ++i)\n this.S[i] = i;\n j = 0;\n for(i = 0; i < 256; ++i) {\n j = (j + this.S[i] + key[i % key.length]) & 255;\n t = this.S[i];\n this.S[i] = this.S[j];\n this.S[j] = t;\n }\n this.i = 0;\n this.j = 0;\n }\n\n function ARC4next() {\n var t;\n this.i = (this.i + 1) & 255;\n this.j = (this.j + this.S[this.i]) & 255;\n t = this.S[this.i];\n this.S[this.i] = this.S[this.j];\n this.S[this.j] = t;\n return this.S[(t + this.S[this.i]) & 255];\n }\n\n Arcfour.prototype.init = ARC4init;\n Arcfour.prototype.next = ARC4next;\n\n // Plug in your RNG constructor here\n function prng_newstate() {\n return new Arcfour();\n }\n\n // Pool size must be a multiple of 4 and greater than 32.\n // An array of bytes the size of the pool will be passed to init()\n var rng_psize = 256;\n\n if (typeof exports !== 'undefined') {\n exports = module.exports = {\n default: BigInteger,\n BigInteger: BigInteger,\n SecureRandom: SecureRandom,\n };\n } else {\n this.jsbn = {\n BigInteger: BigInteger,\n SecureRandom: SecureRandom\n };\n }\n\n}).call(this);\n", "/* global window, exports, define */\n\n!function() {\n 'use strict'\n\n var re = {\n not_string: /[^s]/,\n not_bool: /[^t]/,\n not_type: /[^T]/,\n not_primitive: /[^v]/,\n number: /[diefg]/,\n numeric_arg: /[bcdiefguxX]/,\n json: /[j]/,\n not_json: /[^j]/,\n text: /^[^\\x25]+/,\n modulo: /^\\x25{2}/,\n placeholder: /^\\x25(?:([1-9]\\d*)\\$|\\(([^)]+)\\))?(\\+)?(0|'[^$])?(-)?(\\d+)?(?:\\.(\\d+))?([b-gijostTuvxX])/,\n key: /^([a-z_][a-z_\\d]*)/i,\n key_access: /^\\.([a-z_][a-z_\\d]*)/i,\n index_access: /^\\[(\\d+)\\]/,\n sign: /^[+-]/\n }\n\n function sprintf(key) {\n // `arguments` is not an array, but should be fine for this call\n return sprintf_format(sprintf_parse(key), arguments)\n }\n\n function vsprintf(fmt, argv) {\n return sprintf.apply(null, [fmt].concat(argv || []))\n }\n\n function sprintf_format(parse_tree, argv) {\n var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign\n for (i = 0; i < tree_length; i++) {\n if (typeof parse_tree[i] === 'string') {\n output += parse_tree[i]\n }\n else if (typeof parse_tree[i] === 'object') {\n ph = parse_tree[i] // convenience purposes only\n if (ph.keys) { // keyword argument\n arg = argv[cursor]\n for (k = 0; k < ph.keys.length; k++) {\n if (arg == undefined) {\n throw new Error(sprintf('[sprintf] Cannot access property \"%s\" of undefined value \"%s\"', ph.keys[k], ph.keys[k-1]))\n }\n arg = arg[ph.keys[k]]\n }\n }\n else if (ph.param_no) { // positional argument (explicit)\n arg = argv[ph.param_no]\n }\n else { // positional argument (implicit)\n arg = argv[cursor++]\n }\n\n if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {\n arg = arg()\n }\n\n if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {\n throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))\n }\n\n if (re.number.test(ph.type)) {\n is_positive = arg >= 0\n }\n\n switch (ph.type) {\n case 'b':\n arg = parseInt(arg, 10).toString(2)\n break\n case 'c':\n arg = String.fromCharCode(parseInt(arg, 10))\n break\n case 'd':\n case 'i':\n arg = parseInt(arg, 10)\n break\n case 'j':\n arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)\n break\n case 'e':\n arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()\n break\n case 'f':\n arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)\n break\n case 'g':\n arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)\n break\n case 'o':\n arg = (parseInt(arg, 10) >>> 0).toString(8)\n break\n case 's':\n arg = String(arg)\n arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n break\n case 't':\n arg = String(!!arg)\n arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n break\n case 'T':\n arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()\n arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n break\n case 'u':\n arg = parseInt(arg, 10) >>> 0\n break\n case 'v':\n arg = arg.valueOf()\n arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n break\n case 'x':\n arg = (parseInt(arg, 10) >>> 0).toString(16)\n break\n case 'X':\n arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()\n break\n }\n if (re.json.test(ph.type)) {\n output += arg\n }\n else {\n if (re.number.test(ph.type) && (!is_positive || ph.sign)) {\n sign = is_positive ? '+' : '-'\n arg = arg.toString().replace(re.sign, '')\n }\n else {\n sign = ''\n }\n pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '\n pad_length = ph.width - (sign + arg).length\n pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''\n output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)\n }\n }\n }\n return output\n }\n\n var sprintf_cache = Object.create(null)\n\n function sprintf_parse(fmt) {\n if (sprintf_cache[fmt]) {\n return sprintf_cache[fmt]\n }\n\n var _fmt = fmt, match, parse_tree = [], arg_names = 0\n while (_fmt) {\n if ((match = re.text.exec(_fmt)) !== null) {\n parse_tree.push(match[0])\n }\n else if ((match = re.modulo.exec(_fmt)) !== null) {\n parse_tree.push('%')\n }\n else if ((match = re.placeholder.exec(_fmt)) !== null) {\n if (match[2]) {\n arg_names |= 1\n var field_list = [], replacement_field = match[2], field_match = []\n if ((field_match = re.key.exec(replacement_field)) !== null) {\n field_list.push(field_match[1])\n while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {\n if ((field_match = re.key_access.exec(replacement_field)) !== null) {\n field_list.push(field_match[1])\n }\n else if ((field_match = re.index_access.exec(replacement_field)) !== null) {\n field_list.push(field_match[1])\n }\n else {\n throw new SyntaxError('[sprintf] failed to parse named argument key')\n }\n }\n }\n else {\n throw new SyntaxError('[sprintf] failed to parse named argument key')\n }\n match[2] = field_list\n }\n else {\n arg_names |= 2\n }\n if (arg_names === 3) {\n throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')\n }\n\n parse_tree.push(\n {\n placeholder: match[0],\n param_no: match[1],\n keys: match[2],\n sign: match[3],\n pad_char: match[4],\n align: match[5],\n width: match[6],\n precision: match[7],\n type: match[8]\n }\n )\n }\n else {\n throw new SyntaxError('[sprintf] unexpected placeholder')\n }\n _fmt = _fmt.substring(match[0].length)\n }\n return sprintf_cache[fmt] = parse_tree\n }\n\n /**\n * export to either browser or node.js\n */\n /* eslint-disable quote-props */\n if (typeof exports !== 'undefined') {\n exports['sprintf'] = sprintf\n exports['vsprintf'] = vsprintf\n }\n if (typeof window !== 'undefined') {\n window['sprintf'] = sprintf\n window['vsprintf'] = vsprintf\n\n if (typeof define === 'function' && define['amd']) {\n define(function() {\n return {\n 'sprintf': sprintf,\n 'vsprintf': vsprintf\n }\n })\n }\n }\n /* eslint-enable quote-props */\n}(); // eslint-disable-line\n", "\"use strict\";\n/* eslint-disable no-param-reassign */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Address4 = void 0;\nvar common = __importStar(require(\"./common\"));\nvar constants = __importStar(require(\"./v4/constants\"));\nvar address_error_1 = require(\"./address-error\");\nvar jsbn_1 = require(\"jsbn\");\nvar sprintf_js_1 = require(\"sprintf-js\");\n/**\n * Represents an IPv4 address\n * @class Address4\n * @param {string} address - An IPv4 address string\n */\nvar Address4 = /** @class */ (function () {\n function Address4(address) {\n this.groups = constants.GROUPS;\n this.parsedAddress = [];\n this.parsedSubnet = '';\n this.subnet = '/32';\n this.subnetMask = 32;\n this.v4 = true;\n /**\n * Returns true if the address is correct, false otherwise\n * @memberof Address4\n * @instance\n * @returns {Boolean}\n */\n this.isCorrect = common.isCorrect(constants.BITS);\n /**\n * Returns true if the given address is in the subnet of the current address\n * @memberof Address4\n * @instance\n * @returns {boolean}\n */\n this.isInSubnet = common.isInSubnet;\n this.address = address;\n var subnet = constants.RE_SUBNET_STRING.exec(address);\n if (subnet) {\n this.parsedSubnet = subnet[0].replace('/', '');\n this.subnetMask = parseInt(this.parsedSubnet, 10);\n this.subnet = \"/\" + this.subnetMask;\n if (this.subnetMask < 0 || this.subnetMask > constants.BITS) {\n throw new address_error_1.AddressError('Invalid subnet mask.');\n }\n address = address.replace(constants.RE_SUBNET_STRING, '');\n }\n this.addressMinusSuffix = address;\n this.parsedAddress = this.parse(address);\n }\n Address4.isValid = function (address) {\n try {\n // eslint-disable-next-line no-new\n new Address4(address);\n return true;\n }\n catch (e) {\n return false;\n }\n };\n /*\n * Parses a v4 address\n */\n Address4.prototype.parse = function (address) {\n var groups = address.split('.');\n if (!address.match(constants.RE_ADDRESS)) {\n throw new address_error_1.AddressError('Invalid IPv4 address.');\n }\n return groups;\n };\n /**\n * Returns the correct form of an address\n * @memberof Address4\n * @instance\n * @returns {String}\n */\n Address4.prototype.correctForm = function () {\n return this.parsedAddress.map(function (part) { return parseInt(part, 10); }).join('.');\n };\n /**\n * Converts a hex string to an IPv4 address object\n * @memberof Address4\n * @static\n * @param {string} hex - a hex string to convert\n * @returns {Address4}\n */\n Address4.fromHex = function (hex) {\n var padded = hex.replace(/:/g, '').padStart(8, '0');\n var groups = [];\n var i;\n for (i = 0; i < 8; i += 2) {\n var h = padded.slice(i, i + 2);\n groups.push(parseInt(h, 16));\n }\n return new Address4(groups.join('.'));\n };\n /**\n * Converts an integer into a IPv4 address object\n * @memberof Address4\n * @static\n * @param {integer} integer - a number to convert\n * @returns {Address4}\n */\n Address4.fromInteger = function (integer) {\n return Address4.fromHex(integer.toString(16));\n };\n /**\n * Converts an IPv4 address object to a hex string\n * @memberof Address4\n * @instance\n * @returns {String}\n */\n Address4.prototype.toHex = function () {\n return this.parsedAddress.map(function (part) { return sprintf_js_1.sprintf('%02x', parseInt(part, 10)); }).join(':');\n };\n /**\n * Converts an IPv4 address object to an array of bytes\n * @memberof Address4\n * @instance\n * @returns {Array}\n */\n Address4.prototype.toArray = function () {\n return this.parsedAddress.map(function (part) { return parseInt(part, 10); });\n };\n /**\n * Converts an IPv4 address object to an IPv6 address group\n * @memberof Address4\n * @instance\n * @returns {String}\n */\n Address4.prototype.toGroup6 = function () {\n var output = [];\n var i;\n for (i = 0; i < constants.GROUPS; i += 2) {\n var hex = sprintf_js_1.sprintf('%02x%02x', parseInt(this.parsedAddress[i], 10), parseInt(this.parsedAddress[i + 1], 10));\n output.push(sprintf_js_1.sprintf('%x', parseInt(hex, 16)));\n }\n return output.join(':');\n };\n /**\n * Returns the address as a BigInteger\n * @memberof Address4\n * @instance\n * @returns {BigInteger}\n */\n Address4.prototype.bigInteger = function () {\n return new jsbn_1.BigInteger(this.parsedAddress.map(function (n) { return sprintf_js_1.sprintf('%02x', parseInt(n, 10)); }).join(''), 16);\n };\n /**\n * Helper function getting start address.\n * @memberof Address4\n * @instance\n * @returns {BigInteger}\n */\n Address4.prototype._startAddress = function () {\n return new jsbn_1.BigInteger(this.mask() + '0'.repeat(constants.BITS - this.subnetMask), 2);\n };\n /**\n * The first address in the range given by this address' subnet.\n * Often referred to as the Network Address.\n * @memberof Address4\n * @instance\n * @returns {Address4}\n */\n Address4.prototype.startAddress = function () {\n return Address4.fromBigInteger(this._startAddress());\n };\n /**\n * The first host address in the range given by this address's subnet ie\n * the first address after the Network Address\n * @memberof Address4\n * @instance\n * @returns {Address4}\n */\n Address4.prototype.startAddressExclusive = function () {\n var adjust = new jsbn_1.BigInteger('1');\n return Address4.fromBigInteger(this._startAddress().add(adjust));\n };\n /**\n * Helper function getting end address.\n * @memberof Address4\n * @instance\n * @returns {BigInteger}\n */\n Address4.prototype._endAddress = function () {\n return new jsbn_1.BigInteger(this.mask() + '1'.repeat(constants.BITS - this.subnetMask), 2);\n };\n /**\n * The last address in the range given by this address' subnet\n * Often referred to as the Broadcast\n * @memberof Address4\n * @instance\n * @returns {Address4}\n */\n Address4.prototype.endAddress = function () {\n return Address4.fromBigInteger(this._endAddress());\n };\n /**\n * The last host address in the range given by this address's subnet ie\n * the last address prior to the Broadcast Address\n * @memberof Address4\n * @instance\n * @returns {Address4}\n */\n Address4.prototype.endAddressExclusive = function () {\n var adjust = new jsbn_1.BigInteger('1');\n return Address4.fromBigInteger(this._endAddress().subtract(adjust));\n };\n /**\n * Converts a BigInteger to a v4 address object\n * @memberof Address4\n * @static\n * @param {BigInteger} bigInteger - a BigInteger to convert\n * @returns {Address4}\n */\n Address4.fromBigInteger = function (bigInteger) {\n return Address4.fromInteger(parseInt(bigInteger.toString(), 10));\n };\n /**\n * Returns the first n bits of the address, defaulting to the\n * subnet mask\n * @memberof Address4\n * @instance\n * @returns {String}\n */\n Address4.prototype.mask = function (mask) {\n if (mask === undefined) {\n mask = this.subnetMask;\n }\n return this.getBitsBase2(0, mask);\n };\n /**\n * Returns the bits in the given range as a base-2 string\n * @memberof Address4\n * @instance\n * @returns {string}\n */\n Address4.prototype.getBitsBase2 = function (start, end) {\n return this.binaryZeroPad().slice(start, end);\n };\n /**\n * Returns true if the given address is a multicast address\n * @memberof Address4\n * @instance\n * @returns {boolean}\n */\n Address4.prototype.isMulticast = function () {\n return this.isInSubnet(new Address4('224.0.0.0/4'));\n };\n /**\n * Returns a zero-padded base-2 string representation of the address\n * @memberof Address4\n * @instance\n * @returns {string}\n */\n Address4.prototype.binaryZeroPad = function () {\n return this.bigInteger().toString(2).padStart(constants.BITS, '0');\n };\n /**\n * Groups an IPv4 address for inclusion at the end of an IPv6 address\n * @returns {String}\n */\n Address4.prototype.groupForV6 = function () {\n var segments = this.parsedAddress;\n return this.address.replace(constants.RE_ADDRESS, sprintf_js_1.sprintf('%s.%s', segments.slice(0, 2).join('.'), segments.slice(2, 4).join('.')));\n };\n return Address4;\n}());\nexports.Address4 = Address4;\n//# sourceMappingURL=ipv4.js.map", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = void 0;\nexports.BITS = 128;\nexports.GROUPS = 8;\n/**\n * Represents IPv6 address scopes\n * @memberof Address6\n * @static\n */\nexports.SCOPES = {\n 0: 'Reserved',\n 1: 'Interface local',\n 2: 'Link local',\n 4: 'Admin local',\n 5: 'Site local',\n 8: 'Organization local',\n 14: 'Global',\n 15: 'Reserved',\n};\n/**\n * Represents IPv6 address types\n * @memberof Address6\n * @static\n */\nexports.TYPES = {\n 'ff01::1/128': 'Multicast (All nodes on this interface)',\n 'ff01::2/128': 'Multicast (All routers on this interface)',\n 'ff02::1/128': 'Multicast (All nodes on this link)',\n 'ff02::2/128': 'Multicast (All routers on this link)',\n 'ff05::2/128': 'Multicast (All routers in this site)',\n 'ff02::5/128': 'Multicast (OSPFv3 AllSPF routers)',\n 'ff02::6/128': 'Multicast (OSPFv3 AllDR routers)',\n 'ff02::9/128': 'Multicast (RIP routers)',\n 'ff02::a/128': 'Multicast (EIGRP routers)',\n 'ff02::d/128': 'Multicast (PIM routers)',\n 'ff02::16/128': 'Multicast (MLDv2 reports)',\n 'ff01::fb/128': 'Multicast (mDNSv6)',\n 'ff02::fb/128': 'Multicast (mDNSv6)',\n 'ff05::fb/128': 'Multicast (mDNSv6)',\n 'ff02::1:2/128': 'Multicast (All DHCP servers and relay agents on this link)',\n 'ff05::1:2/128': 'Multicast (All DHCP servers and relay agents in this site)',\n 'ff02::1:3/128': 'Multicast (All DHCP servers on this link)',\n 'ff05::1:3/128': 'Multicast (All DHCP servers in this site)',\n '::/128': 'Unspecified',\n '::1/128': 'Loopback',\n 'ff00::/8': 'Multicast',\n 'fe80::/10': 'Link-local unicast',\n};\n/**\n * A regular expression that matches bad characters in an IPv6 address\n * @memberof Address6\n * @static\n */\nexports.RE_BAD_CHARACTERS = /([^0-9a-f:/%])/gi;\n/**\n * A regular expression that matches an incorrect IPv6 address\n * @memberof Address6\n * @static\n */\nexports.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\\/$)/gi;\n/**\n * A regular expression that matches an IPv6 subnet\n * @memberof Address6\n * @static\n */\nexports.RE_SUBNET_STRING = /\\/\\d{1,3}(?=%|$)/;\n/**\n * A regular expression that matches an IPv6 zone\n * @memberof Address6\n * @static\n */\nexports.RE_ZONE_STRING = /%.*$/;\nexports.RE_URL = new RegExp(/^\\[{0,1}([0-9a-f:]+)\\]{0,1}/);\nexports.RE_URL_WITH_PORT = new RegExp(/\\[([0-9a-f:]+)\\]:([0-9]{1,5})/);\n//# sourceMappingURL=constants.js.map", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.simpleGroup = exports.spanLeadingZeroes = exports.spanAll = exports.spanAllZeroes = void 0;\nvar sprintf_js_1 = require(\"sprintf-js\");\n/**\n * @returns {String} the string with all zeroes contained in a \n */\nfunction spanAllZeroes(s) {\n return s.replace(/(0+)/g, '$1');\n}\nexports.spanAllZeroes = spanAllZeroes;\n/**\n * @returns {String} the string with each character contained in a \n */\nfunction spanAll(s, offset) {\n if (offset === void 0) { offset = 0; }\n var letters = s.split('');\n return letters\n .map(function (n, i) {\n return sprintf_js_1.sprintf('%s', n, i + offset, spanAllZeroes(n));\n } // XXX Use #base-2 .value-0 instead?\n )\n .join('');\n}\nexports.spanAll = spanAll;\nfunction spanLeadingZeroesSimple(group) {\n return group.replace(/^(0+)/, '$1');\n}\n/**\n * @returns {String} the string with leading zeroes contained in a \n */\nfunction spanLeadingZeroes(address) {\n var groups = address.split(':');\n return groups.map(function (g) { return spanLeadingZeroesSimple(g); }).join(':');\n}\nexports.spanLeadingZeroes = spanLeadingZeroes;\n/**\n * Groups an address\n * @returns {String} a grouped address\n */\nfunction simpleGroup(addressString, offset) {\n if (offset === void 0) { offset = 0; }\n var groups = addressString.split(':');\n return groups.map(function (g, i) {\n if (/group-v4/.test(g)) {\n return g;\n }\n return sprintf_js_1.sprintf('%s', i + offset, spanLeadingZeroesSimple(g));\n });\n}\nexports.simpleGroup = simpleGroup;\n//# sourceMappingURL=helpers.js.map", "\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.possibleElisions = exports.simpleRegularExpression = exports.ADDRESS_BOUNDARY = exports.padGroup = exports.groupPossibilities = void 0;\nvar v6 = __importStar(require(\"./constants\"));\nvar sprintf_js_1 = require(\"sprintf-js\");\nfunction groupPossibilities(possibilities) {\n return sprintf_js_1.sprintf('(%s)', possibilities.join('|'));\n}\nexports.groupPossibilities = groupPossibilities;\nfunction padGroup(group) {\n if (group.length < 4) {\n return sprintf_js_1.sprintf('0{0,%d}%s', 4 - group.length, group);\n }\n return group;\n}\nexports.padGroup = padGroup;\nexports.ADDRESS_BOUNDARY = '[^A-Fa-f0-9:]';\nfunction simpleRegularExpression(groups) {\n var zeroIndexes = [];\n groups.forEach(function (group, i) {\n var groupInteger = parseInt(group, 16);\n if (groupInteger === 0) {\n zeroIndexes.push(i);\n }\n });\n // You can technically elide a single 0, this creates the regular expressions\n // to match that eventuality\n var possibilities = zeroIndexes.map(function (zeroIndex) {\n return groups\n .map(function (group, i) {\n if (i === zeroIndex) {\n var elision = i === 0 || i === v6.GROUPS - 1 ? ':' : '';\n return groupPossibilities([padGroup(group), elision]);\n }\n return padGroup(group);\n })\n .join(':');\n });\n // The simplest case\n possibilities.push(groups.map(padGroup).join(':'));\n return groupPossibilities(possibilities);\n}\nexports.simpleRegularExpression = simpleRegularExpression;\nfunction possibleElisions(elidedGroups, moreLeft, moreRight) {\n var left = moreLeft ? '' : ':';\n var right = moreRight ? '' : ':';\n var possibilities = [];\n // 1. elision of everything (::)\n if (!moreLeft && !moreRight) {\n possibilities.push('::');\n }\n // 2. complete elision of the middle\n if (moreLeft && moreRight) {\n possibilities.push('');\n }\n if ((moreRight && !moreLeft) || (!moreRight && moreLeft)) {\n // 3. complete elision of one side\n possibilities.push(':');\n }\n // 4. elision from the left side\n possibilities.push(sprintf_js_1.sprintf('%s(:0{1,4}){1,%d}', left, elidedGroups - 1));\n // 5. elision from the right side\n possibilities.push(sprintf_js_1.sprintf('(0{1,4}:){1,%d}%s', elidedGroups - 1, right));\n // 6. no elision\n possibilities.push(sprintf_js_1.sprintf('(0{1,4}:){%d}0{1,4}', elidedGroups - 1));\n // 7. elision (including sloppy elision) from the middle\n for (var groups = 1; groups < elidedGroups - 1; groups++) {\n for (var position = 1; position < elidedGroups - groups; position++) {\n possibilities.push(sprintf_js_1.sprintf('(0{1,4}:){%d}:(0{1,4}:){%d}0{1,4}', position, elidedGroups - position - groups - 1));\n }\n }\n return groupPossibilities(possibilities);\n}\nexports.possibleElisions = possibleElisions;\n//# sourceMappingURL=regular-expressions.js.map", "\"use strict\";\n/* eslint-disable prefer-destructuring */\n/* eslint-disable no-param-reassign */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n};\nvar __spreadArrays = (this && this.__spreadArrays) || function () {\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n r[k] = a[j];\n return r;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Address6 = void 0;\nvar common = __importStar(require(\"./common\"));\nvar constants4 = __importStar(require(\"./v4/constants\"));\nvar constants6 = __importStar(require(\"./v6/constants\"));\nvar helpers = __importStar(require(\"./v6/helpers\"));\nvar ipv4_1 = require(\"./ipv4\");\nvar regular_expressions_1 = require(\"./v6/regular-expressions\");\nvar address_error_1 = require(\"./address-error\");\nvar jsbn_1 = require(\"jsbn\");\nvar sprintf_js_1 = require(\"sprintf-js\");\nfunction assert(condition) {\n if (!condition) {\n throw new Error('Assertion failed.');\n }\n}\nfunction addCommas(number) {\n var r = /(\\d+)(\\d{3})/;\n while (r.test(number)) {\n number = number.replace(r, '$1,$2');\n }\n return number;\n}\nfunction spanLeadingZeroes4(n) {\n n = n.replace(/^(0{1,})([1-9]+)$/, '$1$2');\n n = n.replace(/^(0{1,})(0)$/, '$1$2');\n return n;\n}\n/*\n * A helper function to compact an array\n */\nfunction compact(address, slice) {\n var s1 = [];\n var s2 = [];\n var i;\n for (i = 0; i < address.length; i++) {\n if (i < slice[0]) {\n s1.push(address[i]);\n }\n else if (i > slice[1]) {\n s2.push(address[i]);\n }\n }\n return s1.concat(['compact']).concat(s2);\n}\nfunction paddedHex(octet) {\n return sprintf_js_1.sprintf('%04x', parseInt(octet, 16));\n}\nfunction unsignByte(b) {\n // eslint-disable-next-line no-bitwise\n return b & 0xff;\n}\n/**\n * Represents an IPv6 address\n * @class Address6\n * @param {string} address - An IPv6 address string\n * @param {number} [groups=8] - How many octets to parse\n * @example\n * var address = new Address6('2001::/32');\n */\nvar Address6 = /** @class */ (function () {\n function Address6(address, optionalGroups) {\n this.addressMinusSuffix = '';\n this.parsedSubnet = '';\n this.subnet = '/128';\n this.subnetMask = 128;\n this.v4 = false;\n this.zone = '';\n // #region Attributes\n /**\n * Returns true if the given address is in the subnet of the current address\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n this.isInSubnet = common.isInSubnet;\n /**\n * Returns true if the address is correct, false otherwise\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n this.isCorrect = common.isCorrect(constants6.BITS);\n if (optionalGroups === undefined) {\n this.groups = constants6.GROUPS;\n }\n else {\n this.groups = optionalGroups;\n }\n this.address = address;\n var subnet = constants6.RE_SUBNET_STRING.exec(address);\n if (subnet) {\n this.parsedSubnet = subnet[0].replace('/', '');\n this.subnetMask = parseInt(this.parsedSubnet, 10);\n this.subnet = \"/\" + this.subnetMask;\n if (Number.isNaN(this.subnetMask) ||\n this.subnetMask < 0 ||\n this.subnetMask > constants6.BITS) {\n throw new address_error_1.AddressError('Invalid subnet mask.');\n }\n address = address.replace(constants6.RE_SUBNET_STRING, '');\n }\n else if (/\\//.test(address)) {\n throw new address_error_1.AddressError('Invalid subnet mask.');\n }\n var zone = constants6.RE_ZONE_STRING.exec(address);\n if (zone) {\n this.zone = zone[0];\n address = address.replace(constants6.RE_ZONE_STRING, '');\n }\n this.addressMinusSuffix = address;\n this.parsedAddress = this.parse(this.addressMinusSuffix);\n }\n Address6.isValid = function (address) {\n try {\n // eslint-disable-next-line no-new\n new Address6(address);\n return true;\n }\n catch (e) {\n return false;\n }\n };\n /**\n * Convert a BigInteger to a v6 address object\n * @memberof Address6\n * @static\n * @param {BigInteger} bigInteger - a BigInteger to convert\n * @returns {Address6}\n * @example\n * var bigInteger = new BigInteger('1000000000000');\n * var address = Address6.fromBigInteger(bigInteger);\n * address.correctForm(); // '::e8:d4a5:1000'\n */\n Address6.fromBigInteger = function (bigInteger) {\n var hex = bigInteger.toString(16).padStart(32, '0');\n var groups = [];\n var i;\n for (i = 0; i < constants6.GROUPS; i++) {\n groups.push(hex.slice(i * 4, (i + 1) * 4));\n }\n return new Address6(groups.join(':'));\n };\n /**\n * Convert a URL (with optional port number) to an address object\n * @memberof Address6\n * @static\n * @param {string} url - a URL with optional port number\n * @example\n * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/');\n * addressAndPort.address.correctForm(); // 'ffff::'\n * addressAndPort.port; // 8080\n */\n Address6.fromURL = function (url) {\n var host;\n var port = null;\n var result;\n // If we have brackets parse them and find a port\n if (url.indexOf('[') !== -1 && url.indexOf(']:') !== -1) {\n result = constants6.RE_URL_WITH_PORT.exec(url);\n if (result === null) {\n return {\n error: 'failed to parse address with port',\n address: null,\n port: null,\n };\n }\n host = result[1];\n port = result[2];\n // If there's a URL extract the address\n }\n else if (url.indexOf('/') !== -1) {\n // Remove the protocol prefix\n url = url.replace(/^[a-z0-9]+:\\/\\//, '');\n // Parse the address\n result = constants6.RE_URL.exec(url);\n if (result === null) {\n return {\n error: 'failed to parse address from URL',\n address: null,\n port: null,\n };\n }\n host = result[1];\n // Otherwise just assign the URL to the host and let the library parse it\n }\n else {\n host = url;\n }\n // If there's a port convert it to an integer\n if (port) {\n port = parseInt(port, 10);\n // squelch out of range ports\n if (port < 0 || port > 65536) {\n port = null;\n }\n }\n else {\n // Standardize `undefined` to `null`\n port = null;\n }\n return {\n address: new Address6(host),\n port: port,\n };\n };\n /**\n * Create an IPv6-mapped address given an IPv4 address\n * @memberof Address6\n * @static\n * @param {string} address - An IPv4 address string\n * @returns {Address6}\n * @example\n * var address = Address6.fromAddress4('192.168.0.1');\n * address.correctForm(); // '::ffff:c0a8:1'\n * address.to4in6(); // '::ffff:192.168.0.1'\n */\n Address6.fromAddress4 = function (address) {\n var address4 = new ipv4_1.Address4(address);\n var mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask);\n return new Address6(\"::ffff:\" + address4.correctForm() + \"/\" + mask6);\n };\n /**\n * Return an address from ip6.arpa form\n * @memberof Address6\n * @static\n * @param {string} arpaFormAddress - an 'ip6.arpa' form address\n * @returns {Adress6}\n * @example\n * var address = Address6.fromArpa(e.f.f.f.3.c.2.6.f.f.f.e.6.6.8.e.1.0.6.7.9.4.e.c.0.0.0.0.1.0.0.2.ip6.arpa.)\n * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe'\n */\n Address6.fromArpa = function (arpaFormAddress) {\n // remove ending \".ip6.arpa.\" or just \".\"\n var address = arpaFormAddress.replace(/(\\.ip6\\.arpa)?\\.$/, '');\n var semicolonAmount = 7;\n // correct ip6.arpa form with ending removed will be 63 characters\n if (address.length !== 63) {\n throw new address_error_1.AddressError(\"Invalid 'ip6.arpa' form.\");\n }\n var parts = address.split('.').reverse();\n for (var i = semicolonAmount; i > 0; i--) {\n var insertIndex = i * 4;\n parts.splice(insertIndex, 0, ':');\n }\n address = parts.join('');\n return new Address6(address);\n };\n /**\n * Return the Microsoft UNC transcription of the address\n * @memberof Address6\n * @instance\n * @returns {String} the Microsoft UNC transcription of the address\n */\n Address6.prototype.microsoftTranscription = function () {\n return sprintf_js_1.sprintf('%s.ipv6-literal.net', this.correctForm().replace(/:/g, '-'));\n };\n /**\n * Return the first n bits of the address, defaulting to the subnet mask\n * @memberof Address6\n * @instance\n * @param {number} [mask=subnet] - the number of bits to mask\n * @returns {String} the first n bits of the address as a string\n */\n Address6.prototype.mask = function (mask) {\n if (mask === void 0) { mask = this.subnetMask; }\n return this.getBitsBase2(0, mask);\n };\n /**\n * Return the number of possible subnets of a given size in the address\n * @memberof Address6\n * @instance\n * @param {number} [size=128] - the subnet size\n * @returns {String}\n */\n // TODO: probably useful to have a numeric version of this too\n Address6.prototype.possibleSubnets = function (subnetSize) {\n if (subnetSize === void 0) { subnetSize = 128; }\n var availableBits = constants6.BITS - this.subnetMask;\n var subnetBits = Math.abs(subnetSize - constants6.BITS);\n var subnetPowers = availableBits - subnetBits;\n if (subnetPowers < 0) {\n return '0';\n }\n return addCommas(new jsbn_1.BigInteger('2', 10).pow(subnetPowers).toString(10));\n };\n /**\n * Helper function getting start address.\n * @memberof Address6\n * @instance\n * @returns {BigInteger}\n */\n Address6.prototype._startAddress = function () {\n return new jsbn_1.BigInteger(this.mask() + '0'.repeat(constants6.BITS - this.subnetMask), 2);\n };\n /**\n * The first address in the range given by this address' subnet\n * Often referred to as the Network Address.\n * @memberof Address6\n * @instance\n * @returns {Address6}\n */\n Address6.prototype.startAddress = function () {\n return Address6.fromBigInteger(this._startAddress());\n };\n /**\n * The first host address in the range given by this address's subnet ie\n * the first address after the Network Address\n * @memberof Address6\n * @instance\n * @returns {Address6}\n */\n Address6.prototype.startAddressExclusive = function () {\n var adjust = new jsbn_1.BigInteger('1');\n return Address6.fromBigInteger(this._startAddress().add(adjust));\n };\n /**\n * Helper function getting end address.\n * @memberof Address6\n * @instance\n * @returns {BigInteger}\n */\n Address6.prototype._endAddress = function () {\n return new jsbn_1.BigInteger(this.mask() + '1'.repeat(constants6.BITS - this.subnetMask), 2);\n };\n /**\n * The last address in the range given by this address' subnet\n * Often referred to as the Broadcast\n * @memberof Address6\n * @instance\n * @returns {Address6}\n */\n Address6.prototype.endAddress = function () {\n return Address6.fromBigInteger(this._endAddress());\n };\n /**\n * The last host address in the range given by this address's subnet ie\n * the last address prior to the Broadcast Address\n * @memberof Address6\n * @instance\n * @returns {Address6}\n */\n Address6.prototype.endAddressExclusive = function () {\n var adjust = new jsbn_1.BigInteger('1');\n return Address6.fromBigInteger(this._endAddress().subtract(adjust));\n };\n /**\n * Return the scope of the address\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.getScope = function () {\n var scope = constants6.SCOPES[this.getBits(12, 16).intValue()];\n if (this.getType() === 'Global unicast' && scope !== 'Link local') {\n scope = 'Global';\n }\n return scope || 'Unknown';\n };\n /**\n * Return the type of the address\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.getType = function () {\n for (var _i = 0, _a = Object.keys(constants6.TYPES); _i < _a.length; _i++) {\n var subnet = _a[_i];\n if (this.isInSubnet(new Address6(subnet))) {\n return constants6.TYPES[subnet];\n }\n }\n return 'Global unicast';\n };\n /**\n * Return the bits in the given range as a BigInteger\n * @memberof Address6\n * @instance\n * @returns {BigInteger}\n */\n Address6.prototype.getBits = function (start, end) {\n return new jsbn_1.BigInteger(this.getBitsBase2(start, end), 2);\n };\n /**\n * Return the bits in the given range as a base-2 string\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.getBitsBase2 = function (start, end) {\n return this.binaryZeroPad().slice(start, end);\n };\n /**\n * Return the bits in the given range as a base-16 string\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.getBitsBase16 = function (start, end) {\n var length = end - start;\n if (length % 4 !== 0) {\n throw new Error('Length of bits to retrieve must be divisible by four');\n }\n return this.getBits(start, end)\n .toString(16)\n .padStart(length / 4, '0');\n };\n /**\n * Return the bits that are set past the subnet mask length\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.getBitsPastSubnet = function () {\n return this.getBitsBase2(this.subnetMask, constants6.BITS);\n };\n /**\n * Return the reversed ip6.arpa form of the address\n * @memberof Address6\n * @param {Object} options\n * @param {boolean} options.omitSuffix - omit the \"ip6.arpa\" suffix\n * @instance\n * @returns {String}\n */\n Address6.prototype.reverseForm = function (options) {\n if (!options) {\n options = {};\n }\n var characters = Math.floor(this.subnetMask / 4);\n var reversed = this.canonicalForm()\n .replace(/:/g, '')\n .split('')\n .slice(0, characters)\n .reverse()\n .join('.');\n if (characters > 0) {\n if (options.omitSuffix) {\n return reversed;\n }\n return sprintf_js_1.sprintf('%s.ip6.arpa.', reversed);\n }\n if (options.omitSuffix) {\n return '';\n }\n return 'ip6.arpa.';\n };\n /**\n * Return the correct form of the address\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.correctForm = function () {\n var i;\n var groups = [];\n var zeroCounter = 0;\n var zeroes = [];\n for (i = 0; i < this.parsedAddress.length; i++) {\n var value = parseInt(this.parsedAddress[i], 16);\n if (value === 0) {\n zeroCounter++;\n }\n if (value !== 0 && zeroCounter > 0) {\n if (zeroCounter > 1) {\n zeroes.push([i - zeroCounter, i - 1]);\n }\n zeroCounter = 0;\n }\n }\n // Do we end with a string of zeroes?\n if (zeroCounter > 1) {\n zeroes.push([this.parsedAddress.length - zeroCounter, this.parsedAddress.length - 1]);\n }\n var zeroLengths = zeroes.map(function (n) { return n[1] - n[0] + 1; });\n if (zeroes.length > 0) {\n var index = zeroLengths.indexOf(Math.max.apply(Math, zeroLengths));\n groups = compact(this.parsedAddress, zeroes[index]);\n }\n else {\n groups = this.parsedAddress;\n }\n for (i = 0; i < groups.length; i++) {\n if (groups[i] !== 'compact') {\n groups[i] = parseInt(groups[i], 16).toString(16);\n }\n }\n var correct = groups.join(':');\n correct = correct.replace(/^compact$/, '::');\n correct = correct.replace(/^compact|compact$/, ':');\n correct = correct.replace(/compact/, '');\n return correct;\n };\n /**\n * Return a zero-padded base-2 string representation of the address\n * @memberof Address6\n * @instance\n * @returns {String}\n * @example\n * var address = new Address6('2001:4860:4001:803::1011');\n * address.binaryZeroPad();\n * // '0010000000000001010010000110000001000000000000010000100000000011\n * // 0000000000000000000000000000000000000000000000000001000000010001'\n */\n Address6.prototype.binaryZeroPad = function () {\n return this.bigInteger().toString(2).padStart(constants6.BITS, '0');\n };\n // TODO: Improve the semantics of this helper function\n Address6.prototype.parse4in6 = function (address) {\n var groups = address.split(':');\n var lastGroup = groups.slice(-1)[0];\n var address4 = lastGroup.match(constants4.RE_ADDRESS);\n if (address4) {\n this.parsedAddress4 = address4[0];\n this.address4 = new ipv4_1.Address4(this.parsedAddress4);\n for (var i = 0; i < this.address4.groups; i++) {\n if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) {\n throw new address_error_1.AddressError(\"IPv4 addresses can't have leading zeroes.\", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join('.')));\n }\n }\n this.v4 = true;\n groups[groups.length - 1] = this.address4.toGroup6();\n address = groups.join(':');\n }\n return address;\n };\n // TODO: Make private?\n Address6.prototype.parse = function (address) {\n address = this.parse4in6(address);\n var badCharacters = address.match(constants6.RE_BAD_CHARACTERS);\n if (badCharacters) {\n throw new address_error_1.AddressError(sprintf_js_1.sprintf('Bad character%s detected in address: %s', badCharacters.length > 1 ? 's' : '', badCharacters.join('')), address.replace(constants6.RE_BAD_CHARACTERS, '$1'));\n }\n var badAddress = address.match(constants6.RE_BAD_ADDRESS);\n if (badAddress) {\n throw new address_error_1.AddressError(sprintf_js_1.sprintf('Address failed regex: %s', badAddress.join('')), address.replace(constants6.RE_BAD_ADDRESS, '$1'));\n }\n var groups = [];\n var halves = address.split('::');\n if (halves.length === 2) {\n var first = halves[0].split(':');\n var last = halves[1].split(':');\n if (first.length === 1 && first[0] === '') {\n first = [];\n }\n if (last.length === 1 && last[0] === '') {\n last = [];\n }\n var remaining = this.groups - (first.length + last.length);\n if (!remaining) {\n throw new address_error_1.AddressError('Error parsing groups');\n }\n this.elidedGroups = remaining;\n this.elisionBegin = first.length;\n this.elisionEnd = first.length + this.elidedGroups;\n groups = groups.concat(first);\n for (var i = 0; i < remaining; i++) {\n groups.push('0');\n }\n groups = groups.concat(last);\n }\n else if (halves.length === 1) {\n groups = address.split(':');\n this.elidedGroups = 0;\n }\n else {\n throw new address_error_1.AddressError('Too many :: groups found');\n }\n groups = groups.map(function (group) { return sprintf_js_1.sprintf('%x', parseInt(group, 16)); });\n if (groups.length !== this.groups) {\n throw new address_error_1.AddressError('Incorrect number of groups found');\n }\n return groups;\n };\n /**\n * Return the canonical form of the address\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.canonicalForm = function () {\n return this.parsedAddress.map(paddedHex).join(':');\n };\n /**\n * Return the decimal form of the address\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.decimal = function () {\n return this.parsedAddress.map(function (n) { return sprintf_js_1.sprintf('%05d', parseInt(n, 16)); }).join(':');\n };\n /**\n * Return the address as a BigInteger\n * @memberof Address6\n * @instance\n * @returns {BigInteger}\n */\n Address6.prototype.bigInteger = function () {\n return new jsbn_1.BigInteger(this.parsedAddress.map(paddedHex).join(''), 16);\n };\n /**\n * Return the last two groups of this address as an IPv4 address string\n * @memberof Address6\n * @instance\n * @returns {Address4}\n * @example\n * var address = new Address6('2001:4860:4001::1825:bf11');\n * address.to4().correctForm(); // '24.37.191.17'\n */\n Address6.prototype.to4 = function () {\n var binary = this.binaryZeroPad().split('');\n return ipv4_1.Address4.fromHex(new jsbn_1.BigInteger(binary.slice(96, 128).join(''), 2).toString(16));\n };\n /**\n * Return the v4-in-v6 form of the address\n * @memberof Address6\n * @instance\n * @returns {String}\n */\n Address6.prototype.to4in6 = function () {\n var address4 = this.to4();\n var address6 = new Address6(this.parsedAddress.slice(0, 6).join(':'), 6);\n var correct = address6.correctForm();\n var infix = '';\n if (!/:$/.test(correct)) {\n infix = ':';\n }\n return correct + infix + address4.address;\n };\n /**\n * Return an object containing the Teredo properties of the address\n * @memberof Address6\n * @instance\n * @returns {Object}\n */\n Address6.prototype.inspectTeredo = function () {\n /*\n - Bits 0 to 31 are set to the Teredo prefix (normally 2001:0000::/32).\n - Bits 32 to 63 embed the primary IPv4 address of the Teredo server that\n is used.\n - Bits 64 to 79 can be used to define some flags. Currently only the\n higher order bit is used; it is set to 1 if the Teredo client is\n located behind a cone NAT, 0 otherwise. For Microsoft's Windows Vista\n and Windows Server 2008 implementations, more bits are used. In those\n implementations, the format for these 16 bits is \"CRAAAAUG AAAAAAAA\",\n where \"C\" remains the \"Cone\" flag. The \"R\" bit is reserved for future\n use. The \"U\" bit is for the Universal/Local flag (set to 0). The \"G\" bit\n is Individual/Group flag (set to 0). The A bits are set to a 12-bit\n randomly generated number chosen by the Teredo client to introduce\n additional protection for the Teredo node against IPv6-based scanning\n attacks.\n - Bits 80 to 95 contains the obfuscated UDP port number. This is the\n port number that is mapped by the NAT to the Teredo client with all\n bits inverted.\n - Bits 96 to 127 contains the obfuscated IPv4 address. This is the\n public IPv4 address of the NAT with all bits inverted.\n */\n var prefix = this.getBitsBase16(0, 32);\n var udpPort = this.getBits(80, 96).xor(new jsbn_1.BigInteger('ffff', 16)).toString();\n var server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64));\n var client4 = ipv4_1.Address4.fromHex(this.getBits(96, 128).xor(new jsbn_1.BigInteger('ffffffff', 16)).toString(16));\n var flags = this.getBits(64, 80);\n var flagsBase2 = this.getBitsBase2(64, 80);\n var coneNat = flags.testBit(15);\n var reserved = flags.testBit(14);\n var groupIndividual = flags.testBit(8);\n var universalLocal = flags.testBit(9);\n var nonce = new jsbn_1.BigInteger(flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16), 2).toString(10);\n return {\n prefix: sprintf_js_1.sprintf('%s:%s', prefix.slice(0, 4), prefix.slice(4, 8)),\n server4: server4.address,\n client4: client4.address,\n flags: flagsBase2,\n coneNat: coneNat,\n microsoft: {\n reserved: reserved,\n universalLocal: universalLocal,\n groupIndividual: groupIndividual,\n nonce: nonce,\n },\n udpPort: udpPort,\n };\n };\n /**\n * Return an object containing the 6to4 properties of the address\n * @memberof Address6\n * @instance\n * @returns {Object}\n */\n Address6.prototype.inspect6to4 = function () {\n /*\n - Bits 0 to 15 are set to the 6to4 prefix (2002::/16).\n - Bits 16 to 48 embed the IPv4 address of the 6to4 gateway that is used.\n */\n var prefix = this.getBitsBase16(0, 16);\n var gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48));\n return {\n prefix: sprintf_js_1.sprintf('%s', prefix.slice(0, 4)),\n gateway: gateway.address,\n };\n };\n /**\n * Return a v6 6to4 address from a v6 v4inv6 address\n * @memberof Address6\n * @instance\n * @returns {Address6}\n */\n Address6.prototype.to6to4 = function () {\n if (!this.is4()) {\n return null;\n }\n var addr6to4 = [\n '2002',\n this.getBitsBase16(96, 112),\n this.getBitsBase16(112, 128),\n '',\n '/16',\n ].join(':');\n return new Address6(addr6to4);\n };\n /**\n * Return a byte array\n * @memberof Address6\n * @instance\n * @returns {Array}\n */\n Address6.prototype.toByteArray = function () {\n var byteArray = this.bigInteger().toByteArray();\n // work around issue where `toByteArray` returns a leading 0 element\n if (byteArray.length === 17 && byteArray[0] === 0) {\n return byteArray.slice(1);\n }\n return byteArray;\n };\n /**\n * Return an unsigned byte array\n * @memberof Address6\n * @instance\n * @returns {Array}\n */\n Address6.prototype.toUnsignedByteArray = function () {\n return this.toByteArray().map(unsignByte);\n };\n /**\n * Convert a byte array to an Address6 object\n * @memberof Address6\n * @static\n * @returns {Address6}\n */\n Address6.fromByteArray = function (bytes) {\n return this.fromUnsignedByteArray(bytes.map(unsignByte));\n };\n /**\n * Convert an unsigned byte array to an Address6 object\n * @memberof Address6\n * @static\n * @returns {Address6}\n */\n Address6.fromUnsignedByteArray = function (bytes) {\n var BYTE_MAX = new jsbn_1.BigInteger('256', 10);\n var result = new jsbn_1.BigInteger('0', 10);\n var multiplier = new jsbn_1.BigInteger('1', 10);\n for (var i = bytes.length - 1; i >= 0; i--) {\n result = result.add(multiplier.multiply(new jsbn_1.BigInteger(bytes[i].toString(10), 10)));\n multiplier = multiplier.multiply(BYTE_MAX);\n }\n return Address6.fromBigInteger(result);\n };\n /**\n * Returns true if the address is in the canonical form, false otherwise\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n Address6.prototype.isCanonical = function () {\n return this.addressMinusSuffix === this.canonicalForm();\n };\n /**\n * Returns true if the address is a link local address, false otherwise\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n Address6.prototype.isLinkLocal = function () {\n // Zeroes are required, i.e. we can't check isInSubnet with 'fe80::/10'\n if (this.getBitsBase2(0, 64) ===\n '1111111010000000000000000000000000000000000000000000000000000000') {\n return true;\n }\n return false;\n };\n /**\n * Returns true if the address is a multicast address, false otherwise\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n Address6.prototype.isMulticast = function () {\n return this.getType() === 'Multicast';\n };\n /**\n * Returns true if the address is a v4-in-v6 address, false otherwise\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n Address6.prototype.is4 = function () {\n return this.v4;\n };\n /**\n * Returns true if the address is a Teredo address, false otherwise\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n Address6.prototype.isTeredo = function () {\n return this.isInSubnet(new Address6('2001::/32'));\n };\n /**\n * Returns true if the address is a 6to4 address, false otherwise\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n Address6.prototype.is6to4 = function () {\n return this.isInSubnet(new Address6('2002::/16'));\n };\n /**\n * Returns true if the address is a loopback address, false otherwise\n * @memberof Address6\n * @instance\n * @returns {boolean}\n */\n Address6.prototype.isLoopback = function () {\n return this.getType() === 'Loopback';\n };\n // #endregion\n // #region HTML\n /**\n * @returns {String} the address in link form with a default port of 80\n */\n Address6.prototype.href = function (optionalPort) {\n if (optionalPort === undefined) {\n optionalPort = '';\n }\n else {\n optionalPort = sprintf_js_1.sprintf(':%s', optionalPort);\n }\n return sprintf_js_1.sprintf('http://[%s]%s/', this.correctForm(), optionalPort);\n };\n /**\n * @returns {String} a link suitable for conveying the address via a URL hash\n */\n Address6.prototype.link = function (options) {\n if (!options) {\n options = {};\n }\n if (options.className === undefined) {\n options.className = '';\n }\n if (options.prefix === undefined) {\n options.prefix = '/#address=';\n }\n if (options.v4 === undefined) {\n options.v4 = false;\n }\n var formFunction = this.correctForm;\n if (options.v4) {\n formFunction = this.to4in6;\n }\n if (options.className) {\n return sprintf_js_1.sprintf('%2$s', options.prefix, formFunction.call(this), options.className);\n }\n return sprintf_js_1.sprintf('%2$s', options.prefix, formFunction.call(this));\n };\n /**\n * Groups an address\n * @returns {String}\n */\n Address6.prototype.group = function () {\n if (this.elidedGroups === 0) {\n // The simple case\n return helpers.simpleGroup(this.address).join(':');\n }\n assert(typeof this.elidedGroups === 'number');\n assert(typeof this.elisionBegin === 'number');\n // The elided case\n var output = [];\n var _a = this.address.split('::'), left = _a[0], right = _a[1];\n if (left.length) {\n output.push.apply(output, helpers.simpleGroup(left));\n }\n else {\n output.push('');\n }\n var classes = ['hover-group'];\n for (var i = this.elisionBegin; i < this.elisionBegin + this.elidedGroups; i++) {\n classes.push(sprintf_js_1.sprintf('group-%d', i));\n }\n output.push(sprintf_js_1.sprintf('', classes.join(' ')));\n if (right.length) {\n output.push.apply(output, helpers.simpleGroup(right, this.elisionEnd));\n }\n else {\n output.push('');\n }\n if (this.is4()) {\n assert(this.address4 instanceof ipv4_1.Address4);\n output.pop();\n output.push(this.address4.groupForV6());\n }\n return output.join(':');\n };\n // #endregion\n // #region Regular expressions\n /**\n * Generate a regular expression string that can be used to find or validate\n * all variations of this address\n * @memberof Address6\n * @instance\n * @param {boolean} substringSearch\n * @returns {string}\n */\n Address6.prototype.regularExpressionString = function (substringSearch) {\n if (substringSearch === void 0) { substringSearch = false; }\n var output = [];\n // TODO: revisit why this is necessary\n var address6 = new Address6(this.correctForm());\n if (address6.elidedGroups === 0) {\n // The simple case\n output.push(regular_expressions_1.simpleRegularExpression(address6.parsedAddress));\n }\n else if (address6.elidedGroups === constants6.GROUPS) {\n // A completely elided address\n output.push(regular_expressions_1.possibleElisions(constants6.GROUPS));\n }\n else {\n // A partially elided address\n var halves = address6.address.split('::');\n if (halves[0].length) {\n output.push(regular_expressions_1.simpleRegularExpression(halves[0].split(':')));\n }\n assert(typeof address6.elidedGroups === 'number');\n output.push(regular_expressions_1.possibleElisions(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0));\n if (halves[1].length) {\n output.push(regular_expressions_1.simpleRegularExpression(halves[1].split(':')));\n }\n output = [output.join(':')];\n }\n if (!substringSearch) {\n output = __spreadArrays([\n '(?=^|',\n regular_expressions_1.ADDRESS_BOUNDARY,\n '|[^\\\\w\\\\:])('\n ], output, [\n ')(?=[^\\\\w\\\\:]|',\n regular_expressions_1.ADDRESS_BOUNDARY,\n '|$)',\n ]);\n }\n return output.join('');\n };\n /**\n * Generate a regular expression that can be used to find or validate all\n * variations of this address.\n * @memberof Address6\n * @instance\n * @param {boolean} substringSearch\n * @returns {RegExp}\n */\n Address6.prototype.regularExpression = function (substringSearch) {\n if (substringSearch === void 0) { substringSearch = false; }\n return new RegExp(this.regularExpressionString(substringSearch), 'i');\n };\n return Address6;\n}());\nexports.Address6 = Address6;\n//# sourceMappingURL=ipv6.js.map", "\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.v6 = exports.Address6 = exports.Address4 = void 0;\nvar ipv4_1 = require(\"./lib/ipv4\");\nObject.defineProperty(exports, \"Address4\", { enumerable: true, get: function () { return ipv4_1.Address4; } });\nvar ipv6_1 = require(\"./lib/ipv6\");\nObject.defineProperty(exports, \"Address6\", { enumerable: true, get: function () { return ipv6_1.Address6; } });\nvar helpers = __importStar(require(\"./lib/v6/helpers\"));\nexports.v6 = { helpers: helpers };\n//# sourceMappingURL=ip-address.js.map", "\"use strict\";\n\nconst ipAddress = require('ip-address');\nconst BigInteger = require('jsbn').BigInteger;\n\nclass IPCIDR {\n constructor(cidr) {\n if(typeof cidr !== 'string' || !cidr.match('/')) {\n throw new Error('Invalid CIDR address.');\n }\n\n const address = this.constructor.createAddress(cidr);\n this.cidr = address.address;\n this.ipAddressType = address.constructor;\n this.address = address;\n this.addressStart = address.startAddress();\n this.addressEnd = address.endAddress(); \n this.addressStart.subnet = this.addressEnd.subnet = this.address.subnet;\n this.addressStart.subnetMask = this.addressEnd.subnetMask = this.address.subnetMask;\n this.size = new BigInteger(this.addressEnd.bigInteger().subtract(this.addressStart.bigInteger()).add(new BigInteger('1')).toString());\n }\n \n contains(address) {\n try {\n if(!(address instanceof ipAddress.Address6) && !(address instanceof ipAddress.Address4)) {\n if(typeof address == 'object') {\n address = this.ipAddressType.fromBigInteger(address);\n }\n else {\n address = this.constructor.createAddress(address);\n }\n }\n\n return address.isInSubnet(this.address)\n }\n catch(err) {\n return false;\n } \n }\n\n start(options) {\n return this.constructor.formatIP(this.addressStart, options);\n }\n\n end(options) {\n return this.constructor.formatIP(this.addressEnd, options);\n }\n\n toString() {\n return this.cidr;\n }\n\n toRange(options) {\n return [this.constructor.formatIP(this.addressStart, options), this.constructor.formatIP(this.addressEnd, options)];\n }\n\n toObject(options) {\n return {\n start: this.constructor.formatIP(this.addressStart, options),\n end: this.constructor.formatIP(this.addressEnd, options)\n };\n }\n\n toArray(options, results) {\n options = options || {};\n const list = [];\n const start = this.constructor.formatIP(this.addressStart, { type: 'bigInteger' });\n const end = this.constructor.formatIP(this.addressEnd, { type: 'bigInteger' });\n const length = end.subtract(start).add(new BigInteger('1'));\n const info = this.getChunkInfo(length, options);\n\n if(results) {\n Object.assign(results, info);\n }\n\n this.loopInfo(info, (val) => {\n const num = start.add(val);\n const ip = this.constructor.formatIP(this.ipAddressType.fromBigInteger(num), options);\n list.push(ip);\n });\n\n return list;\n }\n \n loop(fn, options, results) {\n options = options || {};\n const promise = [];\n const start = this.constructor.formatIP(this.addressStart, { type: 'bigInteger' });\n const end = this.constructor.formatIP(this.addressEnd, { type: 'bigInteger' });\n const length = end.subtract(start).add(new BigInteger('1'));\n const info = this.getChunkInfo(length, options);\n \n if(results) {\n Object.assign(results, info);\n }\n\n this.loopInfo(info, (val) => {\n const num = start.add(val);\n const ip = this.constructor.formatIP(this.ipAddressType.fromBigInteger(num), options);\n promise.push(fn(ip));\n });\n\n return Promise.all(promise);\n }\n\n loopInfo(info, fn) {\n let i = info.from;\n\n while(i.compareTo(info.to) < 0) {\n fn(i);\n i = i.add(new BigInteger('1'));\n }\n }\n\n getChunkInfo(length, options) {\n let from = options.from;\n let limit = options.limit;\n let to = options.to;\n let maxLength;\n const addressBigInteger = this.constructor.formatIP(this.address, { type: 'bigInteger' });\n\n const getBigInteger = (val) => {\n if(typeof val == 'string' && val.match(/:|\\./)) {\n return this.constructor.formatIP(this.constructor.createAddress(val), { type: 'bigInteger' }).subtract(addressBigInteger);\n }\n else if(typeof val != 'object') {\n return new BigInteger(val + '');\n }\n\n return val;\n }\n\n from = getBigInteger(from !== undefined? from: 0);\n\n if(to !== undefined) {\n to = getBigInteger(to);\n limit = to.subtract(from);\n }\n else {\n limit = limit !== undefined? getBigInteger(limit): length;\n } \n\n maxLength = length.subtract(from);\n \n if(limit.compareTo(maxLength) > 0) {\n limit = maxLength;\n }\n \n to = from.add(limit);\n return {\n from: from,\n to: to,\n limit: limit,\n length: length\n };\n }\n}\n\nIPCIDR.formatIP = function(address, options) {\n options = options || {};\n\n if (options.type == \"bigInteger\") {\n return new BigInteger(address.bigInteger().toString());\n }\n else if (options.type == \"addressObject\") {\n return address;\n }\n\n return address.addressMinusSuffix;\n}\n\nIPCIDR.createAddress = function (val) {\n if(typeof val !== 'string') {\n throw new Error('Invalid IP address.');\n }\n\n val.match(/:.\\./) && (val = val.split(':').pop());\n const ipAddressType = val.match(\":\")? ipAddress.Address6: ipAddress.Address4;\n let ip = new ipAddressType(val);\n\n if(ip.v4 && val.match(\":\") && ip.address4) {\n ip = ip.address4;\n }\n\n if(ip.v4) {\n const parts = ip.addressMinusSuffix.split('.');\n\n for(let i = 0; i < parts.length; i++) {\n const part = parts[i].split('/')[0];\n\n if(part[0] == '0' && part.length > 1) {\n throw new Error('Invalid IPv4 address.');\n }\n }\n }\n\n return ip\n}\n\nIPCIDR.isValidAddress = function (address) {\n try {\n return !!this.createAddress(address);\n }\n catch(err) {\n return false;\n }\n}\n\nIPCIDR.isValidCIDR = function (address) {\n if(typeof address !== 'string' || !address.match('/')) {\n return false;\n }\n\n try {\n return !!this.createAddress(address);\n }\n catch(err) {\n return false;\n }\n}\n\nmodule.exports = IPCIDR;\n", "\nimport IPCIDR from 'ip-cidr';\n\nconst chunk = '0'.repeat(1024 * 5);\nexport default {\n async fetch(request, env, ctx) {\n const isin = checkIPInCIDR(\"192.168.1.1\", \"102.1.5.2/24\");\n\n return new Response(null, {\n status: 101\n });\n\n \n },\n};\n\nfunction checkIPInCIDR(ip, cidr) {\n const cidrObject = new IPCIDR(cidr);\n \n // Check if the IP address is valid\n // if (!cidrObject.isValidAddress(ip)) {\n // return false;\n // }\n \n // Check if the IP address is within the CIDR range\n return cidrObject.contains(ip);\n }\n\nfunction delay(ms) {\n return new Promise((resolve) => {\n setTimeout(resolve, ms)\n })\n}"], + "mappings": "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", + "names": ["d", "b", "AddressError", "t", "z", "Address4", "require_constants", "Address6", "IPCIDR", "IPCIDR"] +} diff --git a/jsonconfig.json b/jsonconfig.json new file mode 100644 index 0000000..f593e12 --- /dev/null +++ b/jsonconfig.json @@ -0,0 +1,16 @@ +{ + "compilerOptions": { + "noEmit": true, + "module": "esnext", + "target": "ES2022", + "lib": ["ES2022"], + "strict": true, + "alwaysStrict": true, + "preserveConstEnums": true, + "moduleResolution": "node", + "sourceMap": true, + "types": ["@cloudflare/workers-types"] + }, + "include": ["src"], + "exclude": ["node_modules", "dist", "test"] +} \ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..02f490d --- /dev/null +++ b/package.json @@ -0,0 +1,21 @@ +{ + "name": "edgetunnel", + "version": "1.0.0", + "description": "Delete code, but keep the project for the sake of memories. I'm only create this project for fun, for try new things and for learn by doing. **I'm even not write any outside marketing post for this project. Just for my own fun...** But I feel emotional damage by the community.", + "main": "index.js", + "scripts": { + "deploy": "wrangler deploy", + "dev-vless": "wrangler dev src/worker-vless.js" + }, + "author": "", + "license": "ISC", + "devDependencies": { + "@cloudflare/workers-types": "^4.20230518.0", + "wrangler": "^3.0.1" + }, + "dependencies": { + "ip-cidr": "^3.1.0", + "ip-range-check": "^0.2.0", + "ipaddr.js": "^2.0.1" + } +} diff --git a/src/worker-vless.js b/src/worker-vless.js new file mode 100644 index 0000000..79e19a5 --- /dev/null +++ b/src/worker-vless.js @@ -0,0 +1,7188 @@ +import { connect } from 'cloudflare:sockets'; + +const userID = 'd342d11e-d424-4583-b36e-524ab1f0afa4'; + +// 1. 如果这个你不填写，并且你客户端的 IP 不是 China IP，那么就自动取你的客户端IP。有一定概率会失败。 +// 2. 如果你指定，你忽略一切条件，用你指定的IP。 +let proxyIP = ''; + +if (!isValidUUID(userID)) { + throw new Error('uuid is not valid'); +} + +export default { + /** + * @param {import("@cloudflare/workers-types").Request} request + * @param {{uuid: string}} env + * @param {import("@cloudflare/workers-types").ExecutionContext} ctx + * @returns {Promise} + */ + async fetch(request, env, ctx) { + try { + const upgradeHeader = request.headers.get('Upgrade'); + if (!upgradeHeader || upgradeHeader !== 'websocket') { + const url = new URL(request.url); + switch (url.pathname) { + case '/': + return new Response(JSON.stringify(request.cf), { status: 200 }); + default: + return new Response('Not found', { status: 404 }); + } + } else { + return await vlessOverWSHandler(request); + } + } catch (err) { + /** @type {Error} */ let e = err; + return new Response(e.toString()); + } + }, +}; + + + + +/** + * + * @param {import("@cloudflare/workers-types").Request} request + */ +async function vlessOverWSHandler(request) { + + const webSocketPair = new WebSocketPair(); + /** @type {import("@cloudflare/workers-types").WebSocket[]} */ + const [client, webSocket] = Object.values(webSocketPair); + + webSocket.accept(); + + let address = ''; + let portWithRandomLog = ''; + const log = (info, event) => { + console.log(`[${address}:${portWithRandomLog}] ${info}`, event || ''); + }; + const earlyDataHeader = request.headers.get('sec-websocket-protocol') || ''; + + // only try to get client ip as redirect ip when client is not in China + const isCN = request.headers.get('cf-ipcountry')?.toUpperCase() !== 'CN'; + const clientIP = isCN ? request.headers.get('cf-connecting-ip') || '' : ''; + + const readableWebSocketStream = makeReadableWebSocketStream(webSocket, earlyDataHeader, log); + + /** @type {import("@cloudflare/workers-types").Socket | null}*/ + let remoteSocket = null; + + // ws --> remote + readableWebSocketStream.pipeTo(new WritableStream({ + async write(chunk, controller) { + if (remoteSocket) { + const writer = remoteSocket.writable.getWriter() + await writer.write(chunk); + writer.releaseLock(); + return; + } + + const { + hasError, + message, + portRemote, + addressRemote, + addressType, + rawDataIndex, + vlessVersion = new Uint8Array([0, 0]), + isUDP, + } = processVlessHeader(chunk, userID); + address = addressRemote || ''; + portWithRandomLog = `${portRemote}--${Math.random()} ${isUDP ? 'udp ' : 'tcp ' + } `; + // if UDP but port not DNS port, close it + if (isUDP && portRemote != 53) { + // controller.error('UDP proxy only enable for DNS which is port 53'); + throw new Error('UDP proxy only enable for DNS which is port 53'); // cf seems has bug, controller.error will not end stream + return; + } + if (hasError) { + console.log('----------------------hasError----------', message); + // throw new Error(message); + // controller.error(message); + throw new Error(message); // cf seems has bug, controller.error will not end stream + // webSocket.close(1000, message); + return; + } + const vlessResponseHeader = new Uint8Array([vlessVersion[0], 0]); + const rawClientData = chunk.slice(rawDataIndex); + // get remote address IP + let redirectIp = ''; + // due to cf connect method can't connect cf own ip, so we use proxy ip + const isCFIp = await isCloudFlareIP(addressType, addressRemote); + if(isCFIp) { + redirectIp = proxyIP || clientIP; + console.log(`is cf ip ${addressRemote} redirect to ${redirectIp}`); + } + const tcpSocket = connect({ + hostname: redirectIp || addressRemote, + port: portRemote, + }); + remoteSocket = tcpSocket; + log(`connected`); + const writer = tcpSocket.writable.getWriter(); + await writer.write(rawClientData); // first write, nomal is tls client hello + writer.releaseLock(); + + // when remoteSocket is ready, pass to websocket + // remote--> ws + remoteSocketToWS(tcpSocket, webSocket, log, vlessResponseHeader) + // let remoteConnectionReadyResolve = null; + // remoteConnectionReadyResolve(tcpSocket); + }, + close() { + log(`readableWebSocketStream is close`); + }, + abort(reason) { + log(`readableWebSocketStream is abort`, JSON.stringify(reason)); + }, + })).catch((err) => { + log('readableWebSocketStream pipeTo error', err); + }); + + return new Response(null, { + status: 101, + webSocket: client, + }); +} + +/** + * + * @param {import("@cloudflare/workers-types").WebSocket} webSocketServer + * @param {string} earlyDataHeader for ws 0rtt + * @param {(info: string)=> void} log for ws 0rtt + */ +function makeReadableWebSocketStream(webSocketServer, earlyDataHeader, log) { + let readableStreamCancel = false; + const stream = new ReadableStream({ + start(controller) { + webSocketServer.addEventListener('message', (event) => { + if (readableStreamCancel) { + return; + } + const message = event.data; + controller.enqueue(message); + }); + + // The event means that the client closed the client -> server stream. + // However, the server -> client stream is still open until you call close() on the server side. + // The WebSocket protocol says that a separate close message must be sent in each direction to fully close the socket. + webSocketServer.addEventListener('close', () => { + // client send close, need close server + // is stream is cancel, skip controller.close + safeCloseWebSocket(webSocketServer); + if (readableStreamCancel) { + return; + } + controller.close(); + } + ); + webSocketServer.addEventListener('error', (err) => { + log('webSocketServer has error'); + controller.error(err); + } + ); + // for ws 0rtt + const { earlyData, error } = base64ToArrayBuffer(earlyDataHeader); + if (error) { + controller.error(error); + } else if (earlyData) { + controller.enqueue(earlyData); + } + }, + + pull(controller) { + // if ws can stop read if stream is full, we can implement backpressure + // https://streams.spec.whatwg.org/#example-rs-push-backpressure + }, + cancel(reason) { + // 1. pipe WritableStream has error, this cancel will called, so ws handle server close into here + // 2. if readableStream is cancel, all controller.close/enqueue need skip, + // 3. but from testing controller.error still work even if readableStream is cancel + if (readableStreamCancel) { + return; + } + log(`ReadableStream was canceled, due to ${reason}`) + readableStreamCancel = true; + safeCloseWebSocket(webSocketServer); + } + }); + + return stream; + +} + +//https://github.com/v2ray/v2ray-core/issues/2636 +// 1 字节 16 字节 1 字节 M 字节 1 字节 2 字节 1 字节 S 字节 X 字节 +// 协议版本 等价 UUID 附加信息长度 M (附加信息 ProtoBuf) 指令(udp/tcp) 端口 地址类型 地址 请求数据 +// 00 00 01 01bb(443) 02(ip/host) +// 1 字节 1 字节 N 字节 Y 字节 +// 协议版本，与请求的一致 附加信息长度 N 附加信息 ProtoBuf 响应数据 + +/** + * + * @param { ArrayBuffer} vlessBuffer + * @param {string} userID + * @returns + */ +function processVlessHeader( + vlessBuffer, + userID +) { + if (vlessBuffer.byteLength < 24) { + // console.log('invalid data'); + // controller.error('invalid data'); + return { + hasError: true, + message: 'invalid data', + }; + } + const version = new Uint8Array(vlessBuffer.slice(0, 1)); + let isValidUser = false; + let isUDP = false; + if (stringify(new Uint8Array(vlessBuffer.slice(1, 17))) === userID) { + isValidUser = true; + } + if (!isValidUser) { + return { + hasError: true, + message: 'invalid user', + }; + } + + const optLength = new Uint8Array(vlessBuffer.slice(17, 18))[0]; + //skip opt for now + + const command = new Uint8Array( + vlessBuffer.slice(18 + optLength, 18 + optLength + 1) + )[0]; + + // 0x01 TCP + // 0x02 UDP + // 0x03 MUX + if (command === 1) { + } else if (command === 2) { + isUDP = true; + } else { + return { + hasError: true, + message: `command ${command} is not support, command 01-tcp,02-udp,03-mux`, + }; + } + const portIndex = 18 + optLength + 1; + const portBuffer = vlessBuffer.slice(portIndex, portIndex + 2); + // port is big-Endian in raw data etc 80 == 0x005d + const portRemote = new DataView(portBuffer).getUint16(0); + + let addressIndex = portIndex + 2; + const addressBuffer = new Uint8Array( + vlessBuffer.slice(addressIndex, addressIndex + 1) + ); + + // 1--> ipv4 addressLength =4 + // 2--> domain name addressLength=addressBuffer[1] + // 3--> ipv6 addressLength =16 + const addressType = addressBuffer[0]; + let addressLength = 0; + let addressValueIndex = addressIndex + 1; + let addressValue = ''; + switch (addressType) { + case 1: + addressLength = 4; + addressValue = new Uint8Array( + vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength) + ).join('.'); + break; + case 2: + addressLength = new Uint8Array( + vlessBuffer.slice(addressValueIndex, addressValueIndex + 1) + )[0]; + addressValueIndex += 1; + addressValue = new TextDecoder().decode( + vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength) + ); + break; + case 3: + addressLength = 16; + const dataView = new DataView( + vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength) + ); + // 2001:0db8:85a3:0000:0000:8a2e:0370:7334 + const ipv6 = []; + for (let i = 0; i < 8; i++) { + ipv6.push(dataView.getUint16(i * 2).toString(16)); + } + addressValue = ipv6.join(':'); + // console.log('---------', addressValue) + // seems no need add [] for ipv6 + // if (addressValue) { + // addressValue = `[${addressValue}]`; + // } + break; + default: + return { + hasError: true, + message: `invild addressType is ${addressType}`, + }; + } + if (!addressValue) { + // console.log(`[${address}:${port}] addressValue is empty`); + // controller.error(`[${address}:${portWithRandomLog}] addressValue is empty`); + return { + hasError: true, + message: `addressValue is empty, addressType is ${addressType}`, + }; + } + + return { + hasError: false, + addressRemote: addressValue, + addressType, + portRemote, + rawDataIndex: addressValueIndex + addressLength, + vlessVersion: version, + isUDP, + }; +} + +/** + * + * @param {import("@cloudflare/workers-types").Socket} remoteSocket + * @param {import("@cloudflare/workers-types").WebSocket} webSocket + * @param {*} log + */ +function remoteSocketToWS(remoteSocket, webSocket, log, vlessResponseHeader) { + // remote--> ws + let remoteChunkCount = 0; + let chunks = []; + remoteSocket.readable + .pipeTo( + new WritableStream({ + start() { + if (webSocket.readyState === WS_READY_STATE_OPEN) { + webSocket.send(vlessResponseHeader); + } + }, + /** + * + * @param {Uint8Array} chunk + * @param {*} controller + */ + async write(chunk, controller) { + remoteChunkCount++; + if (webSocket.readyState === WS_READY_STATE_OPEN) { + + // if (remoteChunkCount < 20) { + // webSocket.send(chunk); + // } else { + // // webSocket.send(chunk); + // // await delay(1); + // chunks.push(chunk); + // if(chunks.length > 500){ // 4kb * 500 = 2M/s + // webSocket.send(new Uint8Array(chunks)); + // chunks = []; + // await delay(500); // 4kb * 1000 = 4m/s + // } + // } + if (remoteChunkCount > 20000) { + // cf one package is 4096 byte(4kb), 4096 * 20000 = 80M + await delay(1); + } + webSocket.send(chunk); + console.log(chunk.byteLength); + } else { + controller.error( + 'webSocket.readyState is not open, maybe close' + ); + } + }, + close() { + log(`remoteConnection!.readable is close`); + safeCloseWebSocket(webSocket); + }, + abort(reason) { + console.error(`remoteConnection!.readable abort`, reason); + }, + }) + ) + .catch((error) => { + console.error( + `remoteSocketToWS has exception `, + error.stack || error + ); + safeCloseWebSocket(webSocket); + }); +} + +/** + * + * @param {string} base64Str + * @returns + */ +function base64ToArrayBuffer(base64Str) { + if (!base64Str) { + return { error: null }; + } + try { + // go use modified Base64 for URL rfc4648 which js atob not support + base64Str = base64Str.replace(/-/g, '+').replace(/_/g, '/'); + const decode = atob(base64Str); + const arryBuffer = Uint8Array.from(decode, (c) => c.charCodeAt(0)); + return { earlyData: arryBuffer.buffer, error: null }; + } catch (error) { + return { error }; + } +} + +/** + * // 1--> ipv4 addressLength =4 + * // 2--> domain name addressLength=addressBuffer[1] + * // 3--> ipv6 addressLength =16 + * @param {number | undefined} addressType + * @param {string | undefined} addressRemote + */ +async function isCloudFlareIP(addressType, addressRemote) { + if(!addressType || !addressRemote){ + return false; + } + // not deal with ipv6 + if (addressType === 3) { + return false; + } + + if (addressType === 1) { + return isIPv4InCFCIDR(addressRemote); + } + + if(addressType === 2) + { + const domainIP = await doh(addressRemote); + console.log(' domainIP ', domainIP); + return isIPv4InCFCIDR(domainIP); + } + return false; +} + + +/** + * + * @param {string} domain + * @returns + */ +async function doh(domain) { + const doh = "https://cloudflare-dns.com/dns-query"; + const response = await fetch(`${doh}?name=${domain}`, { + method: "GET", + headers: { + "Accept": "application/dns-json" + } + }); + const data = await response.json(); + const ans = data?.Answer; + //https://developers.cloudflare.com/1.1.1.1/encryption/dns-over-https/make-api-requests/dns-json/ + return ans?.find((record) => record.type === 1)?.data; +}; + +/** + * This is not real UUID validation + * @param {string} uuid + */ +function isValidUUID(uuid) { + const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i; + return uuidRegex.test(uuid); +} + +/** + * + * @param {number} ms + * @returns + */ +function delay(ms) { + return new Promise((resolve, rej) => { + setTimeout(resolve, ms); + }); +} + + +const WS_READY_STATE_OPEN = 1; +const WS_READY_STATE_CLOSING = 2; +/** + * Normally, WebSocket will not has exceptions when close. + * @param {import("@cloudflare/workers-types").WebSocket} socket + */ +function safeCloseWebSocket(socket) { + try { + if (socket.readyState === WS_READY_STATE_OPEN || socket.readyState === WS_READY_STATE_CLOSING) { + socket.close(); + } + } catch (error) { + console.error('safeCloseWebSocket error', error); + } +} + +const byteToHex = []; +for (let i = 0; i < 256; ++i) { + byteToHex.push((i + 256).toString(16).slice(1)); +} +function unsafeStringify(arr, offset = 0) { + return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); +} +function stringify(arr, offset = 0) { + const uuid = unsafeStringify(arr, offset); + if (!isValidUUID(uuid)) { + throw TypeError("Stringified UUID is invalid"); + } + return uuid; +} + +/** + * + * @param {string} ip + * @returns + */ +function isIPv4InCFCIDR(ip) { + const currentIPNum = convertIp2Num(ip); + // if not valid number, return false + if(!currentIPNum){ + return false; + } + + // 134866688 / -256 + // 134866689: 1000000010011110011100000001 + // -256: 11111111111111111111100000000000 + // 134866688 1000000010011110011100000000 + return cidrNumberList.some(({ipNumber, ipMask}) => (currentIPNum & ipMask) === ipNumber); +} + +/** + * + * @param {string} ip + */ + +function convertIp2Num(ip){ + const ipParts = ip.split('.'); + if(ipParts.length !== 4){ + return 0; + } + let ipNumber = 0; + for (const ipPart of ipParts) { + ipNumber = (ipNumber << 8) + parseInt(ipPart, 10); // 8.9.231.0 --> 134866688// 134866688 --> 1000000010011110011100000000 + } + + return ipNumber >>> 0; // unsgined int +} + + +const cidrList = [ + "1.0.0.0/24", + "1.1.1.0/24", + "8.6.144.0/24", + "8.6.145.0/24", + "8.6.146.0/24", + "8.9.231.0/24", + "8.10.148.0/24", + "8.14.199.0/24", + "8.14.201.0/24", + "8.14.202.0/24", + "8.14.203.0/24", + "8.14.204.0/24", + "8.17.205.0/24", + "8.17.206.0/24", + "8.18.50.0/24", + "8.18.113.0/24", + "8.18.194.0/24", + "8.18.195.0/24", + "8.18.196.0/24", + "8.19.8.0/24", + "8.20.100.0/24", + "8.20.101.0/24", + "8.20.103.0/24", + "8.20.122.0/24", + "8.20.123.0/24", + "8.20.124.0/24", + "8.20.125.0/24", + "8.20.126.0/24", + "8.20.253.0/24", + "8.21.8.0/24", + "8.21.9.0/24", + "8.21.10.0/24", + "8.21.13.0/24", + "8.21.110.0/24", + "8.21.111.0/24", + "8.21.239.0/24", + "8.23.139.0/24", + "8.23.240.0/24", + "8.24.87.0/24", + "8.24.242.0/24", + "8.24.243.0/24", + "8.24.244.0/24", + "8.25.96.0/24", + "8.25.97.0/24", + "8.25.249.0/24", + "8.26.180.0/24", + "8.26.182.0/24", + "8.27.64.0/24", + "8.27.66.0/24", + "8.27.67.0/24", + "8.27.68.0/24", + "8.27.69.0/24", + "8.27.79.0/24", + "8.28.20.0/24", + "8.28.82.0/24", + "8.28.126.0/24", + "8.28.213.0/24", + "8.29.105.0/24", + "8.29.230.0/24", + "8.29.231.0/24", + "8.30.234.0/24", + "8.31.2.0/24", + "8.31.160.0/24", + "8.31.161.0/24", + "8.34.69.0/24", + "8.34.70.0/24", + "8.34.71.0/24", + "8.34.200.0/24", + "8.34.201.0/24", + "8.34.202.0/24", + "8.35.57.0/24", + "8.35.58.0/24", + "8.35.59.0/24", + "8.35.149.0/24", + "8.35.211.0/24", + "8.36.216.0/24", + "8.36.217.0/24", + "8.36.218.0/24", + "8.36.219.0/24", + "8.36.220.0/24", + "8.37.41.0/24", + "8.37.43.0/24", + "8.38.147.0/24", + "8.38.148.0/24", + "8.38.149.0/24", + "8.38.172.0/24", + "8.39.6.0/24", + "8.39.18.0/24", + "8.39.125.0/24", + "8.39.126.0/24", + "8.39.201.0/24", + "8.39.202.0/24", + "8.39.203.0/24", + "8.39.204.0/24", + "8.39.205.0/24", + "8.39.206.0/24", + "8.39.207.0/24", + "8.39.212.0/24", + "8.39.213.0/24", + "8.39.214.0/24", + "8.39.215.0/24", + "8.40.26.0/24", + "8.40.27.0/24", + "8.40.28.0/24", + "8.40.29.0/24", + "8.40.30.0/24", + "8.40.31.0/24", + "8.40.107.0/24", + "8.40.111.0/24", + "8.40.140.0/24", + "8.41.5.0/24", + "8.41.6.0/24", + "8.41.7.0/24", + "8.41.36.0/24", + "8.41.37.0/24", + "8.42.51.0/24", + "8.42.52.0/24", + "8.42.54.0/24", + "8.42.55.0/24", + "8.42.161.0/24", + "8.42.164.0/24", + "8.42.172.0/24", + "8.42.245.0/24", + "8.43.121.0/24", + "8.43.122.0/24", + "8.43.123.0/24", + "8.43.224.0/24", + "8.43.225.0/24", + "8.43.226.0/24", + "8.44.0.0/24", + "8.44.1.0/24", + "8.44.2.0/24", + "8.44.3.0/24", + "8.44.6.0/24", + "8.44.58.0/24", + "8.44.60.0/24", + "8.44.61.0/24", + "8.44.62.0/24", + "8.44.63.0/24", + "8.45.41.0/24", + "8.45.43.0/24", + "8.45.44.0/24", + "8.45.45.0/24", + "8.45.46.0/24", + "8.45.47.0/24", + "8.45.97.0/24", + "8.45.101.0/24", + "8.45.102.0/24", + "8.45.108.0/24", + "8.45.111.0/24", + "8.45.144.0/24", + "8.45.145.0/24", + "8.45.146.0/24", + "8.45.147.0/24", + "8.46.113.0/24", + "8.46.114.0/24", + "8.46.115.0/24", + "8.46.117.0/24", + "8.46.118.0/24", + "8.46.119.0/24", + "8.47.9.0/24", + "8.47.12.0/24", + "8.47.13.0/24", + "8.47.14.0/24", + "8.47.15.0/24", + "8.47.69.0/24", + "8.47.71.0/24", + "8.48.130.0/24", + "8.48.132.0/24", + "8.48.133.0/24", + "8.48.134.0/24", + "23.227.37.0/24", + "23.227.38.0/24", + "23.227.39.0/24", + "23.227.60.0/24", + "64.68.192.0/24", + "65.110.63.0/24", + "66.235.200.0/24", + "68.67.65.0/24", + "91.234.214.0/24", + "103.21.244.0/24", + "103.22.200.0/24", + "103.22.201.0/24", + "103.22.202.0/24", + "103.22.203.0/24", + "103.81.228.0/24", + "104.16.0.0/24", + "104.16.1.0/24", + "104.16.2.0/24", + "104.16.3.0/24", + "104.16.4.0/24", + "104.16.5.0/24", + "104.16.6.0/24", + "104.16.7.0/24", + "104.16.8.0/24", + "104.16.9.0/24", + "104.16.10.0/24", + "104.16.11.0/24", + "104.16.12.0/24", + "104.16.13.0/24", + "104.16.14.0/24", + "104.16.15.0/24", + "104.16.16.0/24", + "104.16.17.0/24", + "104.16.18.0/24", + "104.16.19.0/24", + "104.16.20.0/24", + "104.16.21.0/24", + "104.16.22.0/24", + "104.16.23.0/24", + "104.16.24.0/24", + "104.16.25.0/24", + "104.16.26.0/24", + "104.16.27.0/24", + "104.16.28.0/24", + "104.16.29.0/24", + "104.16.30.0/24", + "104.16.31.0/24", + "104.16.32.0/24", + "104.16.33.0/24", + "104.16.34.0/24", + "104.16.35.0/24", + "104.16.36.0/24", + "104.16.37.0/24", + "104.16.38.0/24", + "104.16.39.0/24", + "104.16.40.0/24", + "104.16.41.0/24", + "104.16.42.0/24", + "104.16.43.0/24", + "104.16.44.0/24", + "104.16.45.0/24", + "104.16.46.0/24", + "104.16.47.0/24", + "104.16.48.0/24", + "104.16.49.0/24", + "104.16.50.0/24", + "104.16.51.0/24", + "104.16.52.0/24", + "104.16.53.0/24", + "104.16.54.0/24", + "104.16.55.0/24", + "104.16.56.0/24", + "104.16.57.0/24", + "104.16.58.0/24", + "104.16.59.0/24", + "104.16.60.0/24", + "104.16.61.0/24", + "104.16.62.0/24", + "104.16.63.0/24", + "104.16.64.0/24", + "104.16.65.0/24", + "104.16.66.0/24", + "104.16.67.0/24", + "104.16.68.0/24", + "104.16.69.0/24", + "104.16.70.0/24", + "104.16.71.0/24", + "104.16.72.0/24", + "104.16.73.0/24", + "104.16.74.0/24", + "104.16.75.0/24", + "104.16.76.0/24", + "104.16.77.0/24", + "104.16.78.0/24", + "104.16.79.0/24", + "104.16.80.0/24", + "104.16.81.0/24", + "104.16.82.0/24", + "104.16.83.0/24", + "104.16.84.0/24", + "104.16.85.0/24", + "104.16.86.0/24", + "104.16.87.0/24", + "104.16.88.0/24", + "104.16.89.0/24", + "104.16.90.0/24", + "104.16.91.0/24", + "104.16.92.0/24", + "104.16.93.0/24", + "104.16.94.0/24", + "104.16.95.0/24", + "104.16.96.0/24", + "104.16.97.0/24", + "104.16.98.0/24", + "104.16.99.0/24", + "104.16.100.0/24", + "104.16.101.0/24", + "104.16.102.0/24", + "104.16.103.0/24", + "104.16.104.0/24", + "104.16.105.0/24", + "104.16.106.0/24", + "104.16.107.0/24", + "104.16.108.0/24", + "104.16.109.0/24", + "104.16.110.0/24", + "104.16.111.0/24", + "104.16.112.0/24", + "104.16.113.0/24", + "104.16.114.0/24", + "104.16.115.0/24", + "104.16.116.0/24", + "104.16.117.0/24", + "104.16.118.0/24", + "104.16.119.0/24", + "104.16.120.0/24", + "104.16.121.0/24", + "104.16.122.0/24", + "104.16.123.0/24", + "104.16.124.0/24", + "104.16.125.0/24", + "104.16.126.0/24", + "104.16.127.0/24", + "104.16.128.0/24", + "104.16.129.0/24", + "104.16.130.0/24", + "104.16.131.0/24", + "104.16.132.0/24", + "104.16.133.0/24", + "104.16.134.0/24", + "104.16.135.0/24", + "104.16.136.0/24", + "104.16.137.0/24", + "104.16.138.0/24", + "104.16.139.0/24", + "104.16.140.0/24", + "104.16.141.0/24", + "104.16.142.0/24", + "104.16.143.0/24", + "104.16.144.0/24", + "104.16.145.0/24", + "104.16.146.0/24", + "104.16.147.0/24", + "104.16.148.0/24", + "104.16.149.0/24", + "104.16.150.0/24", + "104.16.151.0/24", + "104.16.152.0/24", + "104.16.153.0/24", + "104.16.154.0/24", + "104.16.155.0/24", + "104.16.156.0/24", + "104.16.157.0/24", + "104.16.158.0/24", + "104.16.159.0/24", + "104.16.160.0/24", + "104.16.161.0/24", + "104.16.162.0/24", + "104.16.163.0/24", + "104.16.164.0/24", + "104.16.165.0/24", + "104.16.166.0/24", + "104.16.167.0/24", + "104.16.168.0/24", + "104.16.169.0/24", + "104.16.170.0/24", + "104.16.171.0/24", + "104.16.172.0/24", + "104.16.173.0/24", + "104.16.174.0/24", + "104.16.175.0/24", + "104.16.176.0/24", + "104.16.177.0/24", + "104.16.178.0/24", + "104.16.179.0/24", + "104.16.180.0/24", + "104.16.181.0/24", + "104.16.182.0/24", + "104.16.183.0/24", + "104.16.184.0/24", + "104.16.185.0/24", + "104.16.186.0/24", + "104.16.187.0/24", + "104.16.188.0/24", + "104.16.189.0/24", + "104.16.190.0/24", + "104.16.191.0/24", + "104.16.192.0/24", + "104.16.193.0/24", + "104.16.194.0/24", + "104.16.195.0/24", + "104.16.196.0/24", + "104.16.197.0/24", + "104.16.198.0/24", + "104.16.199.0/24", + "104.16.200.0/24", + "104.16.201.0/24", + "104.16.202.0/24", + "104.16.203.0/24", + "104.16.204.0/24", + "104.16.205.0/24", + "104.16.206.0/24", + "104.16.207.0/24", + "104.16.208.0/24", + "104.16.209.0/24", + "104.16.210.0/24", + "104.16.211.0/24", + "104.16.212.0/24", + "104.16.213.0/24", + "104.16.214.0/24", + "104.16.215.0/24", + "104.16.216.0/24", + "104.16.217.0/24", + "104.16.218.0/24", + "104.16.219.0/24", + "104.16.220.0/24", + "104.16.221.0/24", + "104.16.222.0/24", + "104.16.223.0/24", + "104.16.224.0/24", + "104.16.225.0/24", + "104.16.226.0/24", + "104.16.227.0/24", + "104.16.228.0/24", + "104.16.229.0/24", + "104.16.230.0/24", + "104.16.231.0/24", + "104.16.232.0/24", + "104.16.233.0/24", + "104.16.234.0/24", + "104.16.235.0/24", + "104.16.236.0/24", + "104.16.237.0/24", + "104.16.238.0/24", + "104.16.239.0/24", + "104.16.240.0/24", + "104.16.241.0/24", + "104.16.242.0/24", + "104.16.243.0/24", + "104.16.244.0/24", + "104.16.245.0/24", + "104.16.246.0/24", + "104.16.247.0/24", + "104.16.248.0/24", + "104.16.249.0/24", + "104.16.250.0/24", + "104.16.251.0/24", + "104.16.252.0/24", + "104.16.253.0/24", + "104.16.254.0/24", + "104.16.255.0/24", + "104.17.0.0/24", + "104.17.1.0/24", + "104.17.2.0/24", + "104.17.3.0/24", + "104.17.4.0/24", + "104.17.5.0/24", + "104.17.6.0/24", + "104.17.7.0/24", + "104.17.8.0/24", + "104.17.9.0/24", + "104.17.10.0/24", + "104.17.11.0/24", + "104.17.12.0/24", + "104.17.13.0/24", + "104.17.14.0/24", + "104.17.15.0/24", + "104.17.16.0/24", + "104.17.17.0/24", + "104.17.18.0/24", + "104.17.19.0/24", + "104.17.20.0/24", + "104.17.21.0/24", + "104.17.22.0/24", + "104.17.23.0/24", + "104.17.24.0/24", + "104.17.25.0/24", + "104.17.26.0/24", + "104.17.27.0/24", + "104.17.28.0/24", + "104.17.29.0/24", + "104.17.30.0/24", + "104.17.31.0/24", + "104.17.32.0/24", + "104.17.33.0/24", + "104.17.34.0/24", + "104.17.35.0/24", + "104.17.36.0/24", + "104.17.37.0/24", + "104.17.38.0/24", + "104.17.39.0/24", + "104.17.40.0/24", + "104.17.41.0/24", + "104.17.42.0/24", + "104.17.43.0/24", + "104.17.44.0/24", + "104.17.45.0/24", + "104.17.46.0/24", + "104.17.47.0/24", + "104.17.48.0/24", + "104.17.49.0/24", + "104.17.50.0/24", + "104.17.51.0/24", + "104.17.52.0/24", + "104.17.53.0/24", + "104.17.54.0/24", + "104.17.55.0/24", + "104.17.56.0/24", + "104.17.57.0/24", + "104.17.58.0/24", + "104.17.59.0/24", + "104.17.60.0/24", + "104.17.61.0/24", + "104.17.62.0/24", + "104.17.63.0/24", + "104.17.64.0/24", + "104.17.65.0/24", + "104.17.66.0/24", + "104.17.67.0/24", + "104.17.68.0/24", + "104.17.69.0/24", + "104.17.70.0/24", + "104.17.71.0/24", + "104.17.72.0/24", + "104.17.73.0/24", + "104.17.74.0/24", + "104.17.75.0/24", + "104.17.76.0/24", + "104.17.77.0/24", + "104.17.78.0/24", + "104.17.79.0/24", + "104.17.80.0/24", + "104.17.81.0/24", + "104.17.82.0/24", + "104.17.83.0/24", + "104.17.84.0/24", + "104.17.85.0/24", + "104.17.86.0/24", + "104.17.87.0/24", + "104.17.88.0/24", + "104.17.89.0/24", + "104.17.90.0/24", + "104.17.91.0/24", + "104.17.92.0/24", + "104.17.93.0/24", + "104.17.94.0/24", + "104.17.95.0/24", + "104.17.96.0/24", + "104.17.97.0/24", + "104.17.98.0/24", + "104.17.99.0/24", + "104.17.100.0/24", + "104.17.101.0/24", + "104.17.102.0/24", + "104.17.103.0/24", + "104.17.104.0/24", + "104.17.105.0/24", + "104.17.106.0/24", + "104.17.107.0/24", + "104.17.108.0/24", + "104.17.109.0/24", + "104.17.110.0/24", + "104.17.111.0/24", + "104.17.112.0/24", + "104.17.113.0/24", + "104.17.114.0/24", + "104.17.115.0/24", + "104.17.116.0/24", + "104.17.117.0/24", + "104.17.118.0/24", + "104.17.119.0/24", + "104.17.120.0/24", + "104.17.121.0/24", + "104.17.122.0/24", + "104.17.123.0/24", + "104.17.124.0/24", + "104.17.125.0/24", + "104.17.126.0/24", + "104.17.127.0/24", + "104.17.128.0/24", + "104.17.129.0/24", + "104.17.130.0/24", + "104.17.131.0/24", + "104.17.132.0/24", + "104.17.133.0/24", + "104.17.134.0/24", + "104.17.135.0/24", + "104.17.136.0/24", + "104.17.137.0/24", + "104.17.138.0/24", + "104.17.139.0/24", + "104.17.140.0/24", + "104.17.141.0/24", + "104.17.142.0/24", + "104.17.143.0/24", + "104.17.144.0/24", + "104.17.145.0/24", + "104.17.146.0/24", + "104.17.147.0/24", + "104.17.148.0/24", + "104.17.149.0/24", + "104.17.150.0/24", + "104.17.151.0/24", + "104.17.152.0/24", + "104.17.153.0/24", + "104.17.154.0/24", + "104.17.155.0/24", + "104.17.156.0/24", + "104.17.157.0/24", + "104.17.158.0/24", + "104.17.159.0/24", + "104.17.160.0/24", + "104.17.161.0/24", + "104.17.162.0/24", + "104.17.163.0/24", + "104.17.164.0/24", + "104.17.165.0/24", + "104.17.166.0/24", + "104.17.167.0/24", + "104.17.168.0/24", + "104.17.169.0/24", + "104.17.170.0/24", + "104.17.171.0/24", + "104.17.172.0/24", + "104.17.173.0/24", + "104.17.174.0/24", + "104.17.175.0/24", + "104.17.176.0/24", + "104.17.177.0/24", + "104.17.178.0/24", + "104.17.179.0/24", + "104.17.180.0/24", + "104.17.181.0/24", + "104.17.182.0/24", + "104.17.183.0/24", + "104.17.184.0/24", + "104.17.185.0/24", + "104.17.186.0/24", + "104.17.187.0/24", + "104.17.188.0/24", + "104.17.189.0/24", + "104.17.190.0/24", + "104.17.191.0/24", + "104.17.192.0/24", + "104.17.193.0/24", + "104.17.194.0/24", + "104.17.195.0/24", + "104.17.196.0/24", + "104.17.197.0/24", + "104.17.198.0/24", + "104.17.199.0/24", + "104.17.200.0/24", + "104.17.201.0/24", + "104.17.202.0/24", + "104.17.203.0/24", + "104.17.204.0/24", + "104.17.205.0/24", + "104.17.206.0/24", + "104.17.207.0/24", + "104.17.208.0/24", + "104.17.209.0/24", + "104.17.210.0/24", + "104.17.211.0/24", + "104.17.212.0/24", + "104.17.213.0/24", + "104.17.214.0/24", + "104.17.215.0/24", + "104.17.216.0/24", + "104.17.217.0/24", + "104.17.218.0/24", + "104.17.219.0/24", + "104.17.220.0/24", + "104.17.221.0/24", + "104.17.222.0/24", + "104.17.223.0/24", + "104.17.224.0/24", + "104.17.225.0/24", + "104.17.226.0/24", + "104.17.227.0/24", + "104.17.228.0/24", + "104.17.229.0/24", + "104.17.230.0/24", + "104.17.231.0/24", + "104.17.232.0/24", + "104.17.233.0/24", + "104.17.234.0/24", + "104.17.235.0/24", + "104.17.236.0/24", + "104.17.237.0/24", + "104.17.238.0/24", + "104.17.239.0/24", + "104.17.240.0/24", + "104.17.241.0/24", + "104.17.242.0/24", + "104.17.243.0/24", + "104.17.244.0/24", + "104.17.245.0/24", + "104.17.246.0/24", + "104.17.247.0/24", + "104.17.248.0/24", + "104.17.249.0/24", + "104.17.250.0/24", + "104.17.251.0/24", + "104.17.252.0/24", + "104.17.253.0/24", + "104.17.254.0/24", + "104.17.255.0/24", + "104.18.0.0/24", + "104.18.1.0/24", + "104.18.2.0/24", + "104.18.3.0/24", + "104.18.4.0/24", + "104.18.5.0/24", + "104.18.6.0/24", + "104.18.7.0/24", + "104.18.8.0/24", + "104.18.9.0/24", + "104.18.10.0/24", + "104.18.11.0/24", + "104.18.12.0/24", + "104.18.13.0/24", + "104.18.14.0/24", + "104.18.15.0/24", + "104.18.16.0/24", + "104.18.17.0/24", + "104.18.18.0/24", + "104.18.19.0/24", + "104.18.20.0/24", + "104.18.21.0/24", + "104.18.22.0/24", + "104.18.23.0/24", + "104.18.24.0/24", + "104.18.25.0/24", + "104.18.26.0/24", + "104.18.27.0/24", + "104.18.28.0/24", + "104.18.29.0/24", + "104.18.30.0/24", + "104.18.31.0/24", + "104.18.32.0/24", + "104.18.33.0/24", + "104.18.34.0/24", + "104.18.35.0/24", + "104.18.36.0/24", + "104.18.37.0/24", + "104.18.38.0/24", + "104.18.39.0/24", + "104.18.40.0/24", + "104.18.41.0/24", + "104.18.42.0/24", + "104.18.43.0/24", + "104.18.44.0/24", + "104.18.45.0/24", + "104.18.46.0/24", + "104.18.47.0/24", + "104.18.48.0/24", + "104.18.49.0/24", + "104.18.50.0/24", + "104.18.51.0/24", + "104.18.52.0/24", + "104.18.53.0/24", + "104.18.54.0/24", + "104.18.55.0/24", + "104.18.56.0/24", + "104.18.57.0/24", + "104.18.58.0/24", + "104.18.59.0/24", + "104.18.60.0/24", + "104.18.61.0/24", + "104.18.62.0/24", + "104.18.63.0/24", + "104.18.64.0/24", + "104.18.65.0/24", + "104.18.66.0/24", + "104.18.67.0/24", + "104.18.68.0/24", + "104.18.69.0/24", + "104.18.70.0/24", + "104.18.71.0/24", + "104.18.72.0/24", + "104.18.73.0/24", + "104.18.74.0/24", + "104.18.75.0/24", + "104.18.76.0/24", + "104.18.77.0/24", + "104.18.78.0/24", + "104.18.79.0/24", + "104.18.80.0/24", + "104.18.81.0/24", + "104.18.82.0/24", + "104.18.83.0/24", + "104.18.84.0/24", + "104.18.85.0/24", + "104.18.86.0/24", + "104.18.87.0/24", + "104.18.88.0/24", + "104.18.89.0/24", + "104.18.90.0/24", + "104.18.91.0/24", + "104.18.92.0/24", + "104.18.93.0/24", + "104.18.94.0/24", + "104.18.95.0/24", + "104.18.96.0/24", + "104.18.97.0/24", + "104.18.98.0/24", + "104.18.99.0/24", + "104.18.100.0/24", + "104.18.101.0/24", + "104.18.102.0/24", + "104.18.103.0/24", + "104.18.104.0/24", + "104.18.105.0/24", + "104.18.106.0/24", + "104.18.107.0/24", + "104.18.108.0/24", + "104.18.109.0/24", + "104.18.110.0/24", + "104.18.111.0/24", + "104.18.112.0/24", + "104.18.113.0/24", + "104.18.114.0/24", + "104.18.115.0/24", + "104.18.116.0/24", + "104.18.117.0/24", + "104.18.118.0/24", + "104.18.119.0/24", + "104.18.120.0/24", + "104.18.121.0/24", + "104.18.122.0/24", + "104.18.123.0/24", + "104.18.124.0/24", + "104.18.125.0/24", + "104.18.126.0/24", + "104.18.127.0/24", + "104.18.128.0/24", + "104.18.129.0/24", + "104.18.130.0/24", + "104.18.131.0/24", + "104.18.132.0/24", + "104.18.133.0/24", + "104.18.134.0/24", + "104.18.135.0/24", + "104.18.136.0/24", + "104.18.137.0/24", + "104.18.138.0/24", + "104.18.139.0/24", + "104.18.140.0/24", + "104.18.141.0/24", + "104.18.142.0/24", + "104.18.143.0/24", + "104.18.144.0/24", + "104.18.145.0/24", + "104.18.146.0/24", + "104.18.147.0/24", + "104.18.148.0/24", + "104.18.149.0/24", + "104.18.150.0/24", + "104.18.151.0/24", + "104.18.152.0/24", + "104.18.153.0/24", + "104.18.154.0/24", + "104.18.155.0/24", + "104.18.156.0/24", + "104.18.157.0/24", + "104.18.158.0/24", + "104.18.159.0/24", + "104.18.160.0/24", + "104.18.161.0/24", + "104.18.162.0/24", + "104.18.163.0/24", + "104.18.164.0/24", + "104.18.165.0/24", + "104.18.166.0/24", + "104.18.167.0/24", + "104.18.168.0/24", + "104.18.169.0/24", + "104.18.170.0/24", + "104.18.171.0/24", + "104.18.172.0/24", + "104.18.173.0/24", + "104.18.174.0/24", + "104.18.175.0/24", + "104.18.176.0/24", + "104.18.177.0/24", + "104.18.178.0/24", + "104.18.179.0/24", + "104.18.180.0/24", + "104.18.181.0/24", + "104.18.182.0/24", + "104.18.183.0/24", + "104.18.184.0/24", + "104.18.185.0/24", + "104.18.186.0/24", + "104.18.187.0/24", + "104.18.188.0/24", + "104.18.189.0/24", + "104.18.190.0/24", + "104.18.191.0/24", + "104.18.192.0/24", + "104.18.193.0/24", + "104.18.194.0/24", + "104.18.195.0/24", + "104.18.196.0/24", + "104.18.197.0/24", + "104.18.198.0/24", + "104.18.199.0/24", + "104.18.200.0/24", + "104.18.201.0/24", + "104.18.202.0/24", + "104.18.203.0/24", + "104.18.204.0/24", + "104.18.205.0/24", + "104.18.206.0/24", + "104.18.207.0/24", + "104.18.208.0/24", + "104.18.209.0/24", + "104.18.210.0/24", + "104.18.211.0/24", + "104.18.212.0/24", + "104.18.213.0/24", + "104.18.214.0/24", + "104.18.215.0/24", + "104.18.216.0/24", + "104.18.217.0/24", + "104.18.218.0/24", + "104.18.219.0/24", + "104.18.220.0/24", + "104.18.221.0/24", + "104.18.222.0/24", + "104.18.223.0/24", + "104.18.224.0/24", + "104.18.225.0/24", + "104.18.226.0/24", + "104.18.227.0/24", + "104.18.228.0/24", + "104.18.229.0/24", + "104.18.230.0/24", + "104.18.231.0/24", + "104.18.232.0/24", + "104.18.233.0/24", + "104.18.234.0/24", + "104.18.235.0/24", + "104.18.236.0/24", + "104.18.237.0/24", + "104.18.238.0/24", + "104.18.239.0/24", + "104.18.240.0/24", + "104.18.241.0/24", + "104.18.242.0/24", + "104.18.243.0/24", + "104.18.244.0/24", + "104.18.245.0/24", + "104.18.246.0/24", + "104.18.247.0/24", + "104.18.248.0/24", + "104.18.249.0/24", + "104.18.250.0/24", + "104.18.251.0/24", + "104.18.252.0/24", + "104.18.253.0/24", + "104.18.254.0/24", + "104.18.255.0/24", + "104.19.0.0/24", + "104.19.1.0/24", + "104.19.2.0/24", + "104.19.3.0/24", + "104.19.4.0/24", + "104.19.5.0/24", + "104.19.6.0/24", + "104.19.7.0/24", + "104.19.8.0/24", + "104.19.9.0/24", + "104.19.10.0/24", + "104.19.11.0/24", + "104.19.12.0/24", + "104.19.13.0/24", + "104.19.14.0/24", + "104.19.15.0/24", + "104.19.16.0/24", + "104.19.17.0/24", + "104.19.18.0/24", + "104.19.19.0/24", + "104.19.20.0/24", + "104.19.21.0/24", + "104.19.22.0/24", + "104.19.23.0/24", + "104.19.24.0/24", + "104.19.25.0/24", + "104.19.26.0/24", + "104.19.27.0/24", + "104.19.28.0/24", + "104.19.29.0/24", + "104.19.30.0/24", + "104.19.31.0/24", + "104.19.32.0/24", + "104.19.33.0/24", + "104.19.34.0/24", + "104.19.35.0/24", + "104.19.36.0/24", + "104.19.37.0/24", + "104.19.38.0/24", + "104.19.39.0/24", + "104.19.40.0/24", + "104.19.41.0/24", + "104.19.42.0/24", + "104.19.43.0/24", + "104.19.44.0/24", + "104.19.45.0/24", + "104.19.46.0/24", + "104.19.47.0/24", + "104.19.48.0/24", + "104.19.49.0/24", + "104.19.50.0/24", + "104.19.51.0/24", + "104.19.52.0/24", + "104.19.53.0/24", + "104.19.54.0/24", + "104.19.55.0/24", + "104.19.56.0/24", + "104.19.57.0/24", + "104.19.58.0/24", + "104.19.59.0/24", + "104.19.60.0/24", + "104.19.61.0/24", + "104.19.62.0/24", + "104.19.63.0/24", + "104.19.64.0/24", + "104.19.65.0/24", + "104.19.66.0/24", + "104.19.67.0/24", + "104.19.68.0/24", + "104.19.69.0/24", + "104.19.70.0/24", + "104.19.71.0/24", + "104.19.72.0/24", + "104.19.73.0/24", + "104.19.74.0/24", + "104.19.75.0/24", + "104.19.76.0/24", + "104.19.77.0/24", + "104.19.78.0/24", + "104.19.79.0/24", + "104.19.80.0/24", + "104.19.81.0/24", + "104.19.82.0/24", + "104.19.83.0/24", + "104.19.84.0/24", + "104.19.85.0/24", + "104.19.86.0/24", + "104.19.87.0/24", + "104.19.88.0/24", + "104.19.89.0/24", + "104.19.90.0/24", + "104.19.91.0/24", + "104.19.92.0/24", + "104.19.93.0/24", + "104.19.94.0/24", + "104.19.95.0/24", + "104.19.96.0/24", + "104.19.97.0/24", + "104.19.98.0/24", + "104.19.99.0/24", + "104.19.100.0/24", + "104.19.101.0/24", + "104.19.102.0/24", + "104.19.103.0/24", + "104.19.104.0/24", + "104.19.105.0/24", + "104.19.106.0/24", + "104.19.107.0/24", + "104.19.108.0/24", + "104.19.109.0/24", + "104.19.110.0/24", + "104.19.111.0/24", + "104.19.112.0/24", + "104.19.113.0/24", + "104.19.114.0/24", + "104.19.115.0/24", + "104.19.116.0/24", + "104.19.117.0/24", + "104.19.118.0/24", + "104.19.119.0/24", + "104.19.120.0/24", + "104.19.121.0/24", + "104.19.122.0/24", + "104.19.123.0/24", + "104.19.124.0/24", + "104.19.125.0/24", + "104.19.126.0/24", + "104.19.127.0/24", + "104.19.128.0/24", + "104.19.129.0/24", + "104.19.130.0/24", + "104.19.131.0/24", + "104.19.132.0/24", + "104.19.133.0/24", + "104.19.134.0/24", + "104.19.135.0/24", + "104.19.136.0/24", + "104.19.137.0/24", + "104.19.138.0/24", + "104.19.139.0/24", + "104.19.140.0/24", + "104.19.141.0/24", + "104.19.142.0/24", + "104.19.143.0/24", + "104.19.144.0/24", + "104.19.145.0/24", + "104.19.146.0/24", + "104.19.147.0/24", + "104.19.148.0/24", + "104.19.149.0/24", + "104.19.150.0/24", + "104.19.151.0/24", + "104.19.152.0/24", + "104.19.153.0/24", + "104.19.154.0/24", + "104.19.155.0/24", + "104.19.156.0/24", + "104.19.157.0/24", + "104.19.158.0/24", + "104.19.159.0/24", + "104.19.160.0/24", + "104.19.161.0/24", + "104.19.162.0/24", + "104.19.163.0/24", + "104.19.164.0/24", + "104.19.165.0/24", + "104.19.166.0/24", + "104.19.167.0/24", + "104.19.168.0/24", + "104.19.169.0/24", + "104.19.170.0/24", + "104.19.171.0/24", + "104.19.172.0/24", + "104.19.173.0/24", + "104.19.174.0/24", + "104.19.175.0/24", + "104.19.176.0/24", + "104.19.177.0/24", + "104.19.178.0/24", + "104.19.179.0/24", + "104.19.180.0/24", + "104.19.181.0/24", + "104.19.182.0/24", + "104.19.183.0/24", + "104.19.184.0/24", + "104.19.185.0/24", + "104.19.186.0/24", + "104.19.187.0/24", + "104.19.188.0/24", + "104.19.189.0/24", + "104.19.190.0/24", + "104.19.191.0/24", + "104.19.192.0/24", + "104.19.193.0/24", + "104.19.194.0/24", + "104.19.195.0/24", + "104.19.196.0/24", + "104.19.197.0/24", + "104.19.198.0/24", + "104.19.199.0/24", + "104.19.200.0/24", + "104.19.201.0/24", + "104.19.202.0/24", + "104.19.203.0/24", + "104.19.204.0/24", + "104.19.205.0/24", + "104.19.206.0/24", + "104.19.207.0/24", + "104.19.208.0/24", + "104.19.209.0/24", + "104.19.210.0/24", + "104.19.211.0/24", + "104.19.212.0/24", + "104.19.213.0/24", + "104.19.214.0/24", + "104.19.215.0/24", + "104.19.216.0/24", + "104.19.217.0/24", + "104.19.218.0/24", + "104.19.219.0/24", + "104.19.220.0/24", + "104.19.221.0/24", + "104.19.222.0/24", + "104.19.223.0/24", + "104.19.224.0/24", + "104.19.225.0/24", + "104.19.226.0/24", + "104.19.227.0/24", + "104.19.228.0/24", + "104.19.229.0/24", + "104.19.230.0/24", + "104.19.231.0/24", + "104.19.232.0/24", + "104.19.233.0/24", + "104.19.234.0/24", + "104.19.235.0/24", + "104.19.236.0/24", + "104.19.237.0/24", + "104.19.238.0/24", + "104.19.239.0/24", + "104.19.240.0/24", + "104.19.241.0/24", + "104.19.242.0/24", + "104.19.243.0/24", + "104.19.244.0/24", + "104.19.245.0/24", + "104.19.246.0/24", + "104.19.247.0/24", + "104.19.248.0/24", + "104.19.249.0/24", + "104.19.250.0/24", + "104.19.251.0/24", + "104.19.252.0/24", + "104.19.253.0/24", + "104.19.254.0/24", + "104.19.255.0/24", + "104.20.0.0/24", + "104.20.1.0/24", + "104.20.2.0/24", + "104.20.3.0/24", + "104.20.4.0/24", + "104.20.5.0/24", + "104.20.6.0/24", + "104.20.7.0/24", + "104.20.8.0/24", + "104.20.9.0/24", + "104.20.10.0/24", + "104.20.11.0/24", + "104.20.12.0/24", + "104.20.13.0/24", + "104.20.14.0/24", + "104.20.15.0/24", + "104.20.16.0/24", + "104.20.17.0/24", + "104.20.18.0/24", + "104.20.19.0/24", + "104.20.20.0/24", + "104.20.21.0/24", + "104.20.22.0/24", + "104.20.23.0/24", + "104.20.24.0/24", + "104.20.25.0/24", + "104.20.26.0/24", + "104.20.27.0/24", + "104.20.28.0/24", + "104.20.29.0/24", + "104.20.30.0/24", + "104.20.31.0/24", + "104.20.32.0/24", + "104.20.33.0/24", + "104.20.34.0/24", + "104.20.35.0/24", + "104.20.36.0/24", + "104.20.37.0/24", + "104.20.38.0/24", + "104.20.39.0/24", + "104.20.40.0/24", + "104.20.41.0/24", + "104.20.42.0/24", + "104.20.43.0/24", + "104.20.44.0/24", + "104.20.45.0/24", + "104.20.46.0/24", + "104.20.47.0/24", + "104.20.48.0/24", + "104.20.49.0/24", + "104.20.50.0/24", + "104.20.51.0/24", + "104.20.52.0/24", + "104.20.53.0/24", + "104.20.54.0/24", + "104.20.55.0/24", + "104.20.56.0/24", + "104.20.57.0/24", + "104.20.58.0/24", + "104.20.59.0/24", + "104.20.60.0/24", + "104.20.61.0/24", + "104.20.62.0/24", + "104.20.63.0/24", + "104.20.64.0/24", + "104.20.65.0/24", + "104.20.66.0/24", + "104.20.67.0/24", + "104.20.68.0/24", + "104.20.69.0/24", + "104.20.70.0/24", + "104.20.71.0/24", + "104.20.72.0/24", + "104.20.73.0/24", + "104.20.74.0/24", + "104.20.75.0/24", + "104.20.76.0/24", + "104.20.77.0/24", + "104.20.78.0/24", + "104.20.79.0/24", + "104.20.80.0/24", + "104.20.81.0/24", + "104.20.82.0/24", + "104.20.83.0/24", + "104.20.84.0/24", + "104.20.85.0/24", + "104.20.86.0/24", + "104.20.87.0/24", + "104.20.88.0/24", + "104.20.89.0/24", + "104.20.90.0/24", + "104.20.91.0/24", + "104.20.92.0/24", + "104.20.93.0/24", + "104.20.94.0/24", + "104.20.95.0/24", + "104.20.96.0/24", + "104.20.97.0/24", + "104.20.98.0/24", + "104.20.99.0/24", + "104.20.100.0/24", + "104.20.101.0/24", + "104.20.102.0/24", + "104.20.103.0/24", + "104.20.104.0/24", + "104.20.105.0/24", + "104.20.106.0/24", + "104.20.107.0/24", + "104.20.108.0/24", + "104.20.109.0/24", + "104.20.110.0/24", + "104.20.111.0/24", + "104.20.112.0/24", + "104.20.113.0/24", + "104.20.114.0/24", + "104.20.115.0/24", + "104.20.116.0/24", + "104.20.117.0/24", + "104.20.118.0/24", + "104.20.119.0/24", + "104.20.120.0/24", + "104.20.121.0/24", + "104.20.122.0/24", + "104.20.123.0/24", + "104.20.124.0/24", + "104.20.125.0/24", + "104.20.126.0/24", + "104.20.127.0/24", + "104.20.128.0/24", + "104.20.129.0/24", + "104.20.130.0/24", + "104.20.131.0/24", + "104.20.132.0/24", + "104.20.133.0/24", + "104.20.134.0/24", + "104.20.135.0/24", + "104.20.136.0/24", + "104.20.137.0/24", + "104.20.138.0/24", + "104.20.139.0/24", + "104.20.140.0/24", + "104.20.141.0/24", + "104.20.142.0/24", + "104.20.143.0/24", + "104.20.144.0/24", + "104.20.145.0/24", + "104.20.146.0/24", + "104.20.147.0/24", + "104.20.148.0/24", + "104.20.149.0/24", + "104.20.150.0/24", + "104.20.151.0/24", + "104.20.152.0/24", + "104.20.153.0/24", + "104.20.154.0/24", + "104.20.155.0/24", + "104.20.156.0/24", + "104.20.157.0/24", + "104.20.158.0/24", + "104.20.159.0/24", + "104.20.160.0/24", + "104.20.161.0/24", + "104.20.162.0/24", + "104.20.163.0/24", + "104.20.164.0/24", + "104.20.165.0/24", + "104.20.166.0/24", + "104.20.167.0/24", + "104.20.168.0/24", + "104.20.169.0/24", + "104.20.170.0/24", + "104.20.171.0/24", + "104.20.172.0/24", + "104.20.173.0/24", + "104.20.174.0/24", + "104.20.175.0/24", + "104.20.176.0/24", + "104.20.177.0/24", + "104.20.178.0/24", + "104.20.179.0/24", + "104.20.180.0/24", + "104.20.181.0/24", + "104.20.182.0/24", + "104.20.183.0/24", + "104.20.184.0/24", + "104.20.185.0/24", + "104.20.186.0/24", + "104.20.187.0/24", + "104.20.188.0/24", + "104.20.189.0/24", + "104.20.190.0/24", + "104.20.191.0/24", + "104.20.192.0/24", + "104.20.193.0/24", + "104.20.194.0/24", + "104.20.195.0/24", + "104.20.196.0/24", + "104.20.197.0/24", + "104.20.198.0/24", + "104.20.199.0/24", + "104.20.200.0/24", + "104.20.201.0/24", + "104.20.202.0/24", + "104.20.203.0/24", + "104.20.204.0/24", + "104.20.205.0/24", + "104.20.206.0/24", + "104.20.207.0/24", + "104.20.208.0/24", + "104.20.209.0/24", + "104.20.210.0/24", + "104.20.211.0/24", + "104.20.212.0/24", + "104.20.213.0/24", + "104.20.214.0/24", + "104.20.215.0/24", + "104.20.216.0/24", + "104.20.217.0/24", + "104.20.218.0/24", + "104.20.219.0/24", + "104.20.220.0/24", + "104.20.221.0/24", + "104.20.222.0/24", + "104.20.223.0/24", + "104.20.224.0/24", + "104.20.225.0/24", + "104.20.226.0/24", + "104.20.227.0/24", + "104.20.228.0/24", + "104.20.229.0/24", + "104.20.230.0/24", + "104.20.231.0/24", + "104.20.232.0/24", + "104.20.233.0/24", + "104.20.234.0/24", + "104.20.235.0/24", + "104.20.236.0/24", + "104.20.237.0/24", + "104.20.238.0/24", + "104.20.239.0/24", + "104.20.240.0/24", + "104.20.241.0/24", + "104.20.242.0/24", + "104.20.243.0/24", + "104.20.244.0/24", + "104.20.245.0/24", + "104.20.246.0/24", + "104.20.247.0/24", + "104.20.248.0/24", + "104.20.249.0/24", + "104.20.250.0/24", + "104.20.251.0/24", + "104.20.252.0/24", + "104.20.253.0/24", + "104.20.254.0/24", + "104.20.255.0/24", + "104.21.0.0/24", + "104.21.1.0/24", + "104.21.2.0/24", + "104.21.3.0/24", + "104.21.4.0/24", + "104.21.5.0/24", + "104.21.6.0/24", + "104.21.7.0/24", + "104.21.8.0/24", + "104.21.9.0/24", + "104.21.10.0/24", + "104.21.11.0/24", + "104.21.12.0/24", + "104.21.13.0/24", + "104.21.14.0/24", + "104.21.15.0/24", + "104.21.16.0/24", + "104.21.17.0/24", + "104.21.18.0/24", + "104.21.19.0/24", + "104.21.20.0/24", + "104.21.21.0/24", + "104.21.22.0/24", + "104.21.23.0/24", + "104.21.24.0/24", + "104.21.25.0/24", + "104.21.26.0/24", + "104.21.27.0/24", + "104.21.28.0/24", + "104.21.29.0/24", + "104.21.30.0/24", + "104.21.31.0/24", + "104.21.32.0/24", + "104.21.33.0/24", + "104.21.34.0/24", + "104.21.35.0/24", + "104.21.36.0/24", + "104.21.37.0/24", + "104.21.38.0/24", + "104.21.39.0/24", + "104.21.40.0/24", + "104.21.41.0/24", + "104.21.42.0/24", + "104.21.43.0/24", + "104.21.44.0/24", + "104.21.45.0/24", + "104.21.46.0/24", + "104.21.47.0/24", + "104.21.48.0/24", + "104.21.49.0/24", + "104.21.50.0/24", + "104.21.51.0/24", + "104.21.52.0/24", + "104.21.53.0/24", + "104.21.54.0/24", + "104.21.55.0/24", + "104.21.56.0/24", + "104.21.57.0/24", + "104.21.58.0/24", + "104.21.59.0/24", + "104.21.60.0/24", + "104.21.61.0/24", + "104.21.62.0/24", + "104.21.63.0/24", + "104.21.64.0/24", + "104.21.65.0/24", + "104.21.66.0/24", + "104.21.67.0/24", + "104.21.68.0/24", + "104.21.69.0/24", + "104.21.70.0/24", + "104.21.71.0/24", + "104.21.72.0/24", + "104.21.73.0/24", + "104.21.74.0/24", + "104.21.75.0/24", + "104.21.76.0/24", + "104.21.77.0/24", + "104.21.78.0/24", + "104.21.79.0/24", + "104.21.80.0/24", + "104.21.81.0/24", + "104.21.82.0/24", + "104.21.83.0/24", + "104.21.84.0/24", + "104.21.85.0/24", + "104.21.86.0/24", + "104.21.87.0/24", + "104.21.88.0/24", + "104.21.89.0/24", + "104.21.90.0/24", + "104.21.91.0/24", + "104.21.92.0/24", + "104.21.93.0/24", + "104.21.94.0/24", + "104.21.95.0/24", + "104.21.96.0/24", + "104.21.97.0/24", + "104.21.98.0/24", + "104.21.99.0/24", + "104.21.100.0/24", + "104.21.101.0/24", + "104.21.102.0/24", + "104.21.103.0/24", + "104.21.104.0/24", + "104.21.105.0/24", + "104.21.106.0/24", + "104.21.107.0/24", + "104.21.108.0/24", + "104.21.109.0/24", + "104.21.110.0/24", + "104.21.111.0/24", + "104.21.112.0/24", + "104.21.113.0/24", + "104.21.114.0/24", + "104.21.115.0/24", + "104.21.116.0/24", + "104.21.117.0/24", + "104.21.118.0/24", + "104.21.119.0/24", + "104.21.120.0/24", + "104.21.121.0/24", + "104.21.122.0/24", + "104.21.123.0/24", + "104.21.124.0/24", + "104.21.125.0/24", + "104.21.126.0/24", + "104.21.127.0/24", + "104.21.128.0/24", + "104.21.129.0/24", + "104.21.130.0/24", + "104.21.131.0/24", + "104.21.132.0/24", + "104.21.133.0/24", + "104.21.134.0/24", + "104.21.135.0/24", + "104.21.136.0/24", + "104.21.137.0/24", + "104.21.138.0/24", + "104.21.139.0/24", + "104.21.140.0/24", + "104.21.141.0/24", + "104.21.142.0/24", + "104.21.143.0/24", + "104.21.144.0/24", + "104.21.145.0/24", + "104.21.146.0/24", + "104.21.147.0/24", + "104.21.148.0/24", + "104.21.149.0/24", + "104.21.150.0/24", + "104.21.151.0/24", + "104.21.152.0/24", + "104.21.153.0/24", + "104.21.154.0/24", + "104.21.155.0/24", + "104.21.156.0/24", + "104.21.157.0/24", + "104.21.158.0/24", + "104.21.159.0/24", + "104.21.160.0/24", + "104.21.161.0/24", + "104.21.162.0/24", + "104.21.163.0/24", + "104.21.164.0/24", + "104.21.165.0/24", + "104.21.166.0/24", + "104.21.167.0/24", + "104.21.168.0/24", + "104.21.169.0/24", + "104.21.170.0/24", + "104.21.171.0/24", + "104.21.172.0/24", + "104.21.173.0/24", + "104.21.174.0/24", + "104.21.175.0/24", + "104.21.176.0/24", + "104.21.177.0/24", + "104.21.178.0/24", + "104.21.179.0/24", + "104.21.180.0/24", + "104.21.181.0/24", + "104.21.182.0/24", + "104.21.183.0/24", + "104.21.184.0/24", + "104.21.185.0/24", + "104.21.186.0/24", + "104.21.187.0/24", + "104.21.188.0/24", + "104.21.189.0/24", + "104.21.190.0/24", + "104.21.191.0/24", + "104.21.192.0/24", + "104.21.193.0/24", + "104.21.194.0/24", + "104.21.195.0/24", + "104.21.196.0/24", + "104.21.197.0/24", + "104.21.198.0/24", + "104.21.199.0/24", + "104.21.200.0/24", + "104.21.201.0/24", + "104.21.202.0/24", + "104.21.203.0/24", + "104.21.204.0/24", + "104.21.205.0/24", + "104.21.206.0/24", + "104.21.207.0/24", + "104.21.208.0/24", + "104.21.209.0/24", + "104.21.210.0/24", + "104.21.211.0/24", + "104.21.212.0/24", + "104.21.213.0/24", + "104.21.214.0/24", + "104.21.215.0/24", + "104.21.216.0/24", + "104.21.217.0/24", + "104.21.218.0/24", + "104.21.219.0/24", + "104.21.220.0/24", + "104.21.221.0/24", + "104.21.222.0/24", + "104.21.223.0/24", + "104.21.224.0/24", + "104.21.225.0/24", + "104.21.226.0/24", + "104.21.227.0/24", + "104.21.228.0/24", + "104.21.229.0/24", + "104.21.230.0/24", + "104.21.231.0/24", + "104.21.232.0/24", + "104.21.233.0/24", + "104.21.234.0/24", + "104.21.235.0/24", + "104.21.236.0/24", + "104.21.237.0/24", + "104.21.238.0/24", + "104.21.239.0/24", + "104.21.240.0/24", + "104.21.241.0/24", + "104.21.242.0/24", + "104.21.243.0/24", + "104.21.244.0/24", + "104.21.245.0/24", + "104.21.246.0/24", + "104.21.247.0/24", + "104.21.248.0/24", + "104.21.249.0/24", + "104.21.250.0/24", + "104.21.251.0/24", + "104.21.252.0/24", + "104.21.253.0/24", + "104.21.254.0/24", + "104.21.255.0/24", + "104.22.0.0/24", + "104.22.1.0/24", + "104.22.2.0/24", + "104.22.3.0/24", + "104.22.4.0/24", + "104.22.5.0/24", + "104.22.6.0/24", + "104.22.7.0/24", + "104.22.8.0/24", + "104.22.9.0/24", + "104.22.10.0/24", + "104.22.11.0/24", + "104.22.12.0/24", + "104.22.13.0/24", + "104.22.14.0/24", + "104.22.15.0/24", + "104.22.16.0/24", + "104.22.17.0/24", + "104.22.18.0/24", + "104.22.19.0/24", + "104.22.20.0/24", + "104.22.21.0/24", + "104.22.22.0/24", + "104.22.23.0/24", + "104.22.24.0/24", + "104.22.25.0/24", + "104.22.26.0/24", + "104.22.27.0/24", + "104.22.28.0/24", + "104.22.29.0/24", + "104.22.30.0/24", + "104.22.31.0/24", + "104.22.32.0/24", + "104.22.33.0/24", + "104.22.34.0/24", + "104.22.35.0/24", + "104.22.36.0/24", + "104.22.37.0/24", + "104.22.38.0/24", + "104.22.39.0/24", + "104.22.40.0/24", + "104.22.41.0/24", + "104.22.42.0/24", + "104.22.43.0/24", + "104.22.44.0/24", + "104.22.45.0/24", + "104.22.46.0/24", + "104.22.47.0/24", + "104.22.48.0/24", + "104.22.49.0/24", + "104.22.50.0/24", + "104.22.51.0/24", + "104.22.52.0/24", + "104.22.53.0/24", + "104.22.54.0/24", + "104.22.55.0/24", + "104.22.56.0/24", + "104.22.57.0/24", + "104.22.58.0/24", + "104.22.59.0/24", + "104.22.60.0/24", + "104.22.61.0/24", + "104.22.62.0/24", + "104.22.63.0/24", + "104.22.64.0/24", + "104.22.65.0/24", + "104.22.66.0/24", + "104.22.67.0/24", + "104.22.68.0/24", + "104.22.69.0/24", + "104.22.70.0/24", + "104.22.71.0/24", + "104.22.72.0/24", + "104.22.73.0/24", + "104.22.74.0/24", + "104.22.75.0/24", + "104.22.76.0/24", + "104.22.77.0/24", + "104.22.78.0/24", + "104.22.79.0/24", + "104.22.80.0/24", + "104.22.81.0/24", + "104.22.82.0/24", + "104.22.83.0/24", + "104.22.84.0/24", + "104.22.85.0/24", + "104.22.86.0/24", + "104.22.87.0/24", + "104.22.88.0/24", + "104.22.89.0/24", + "104.22.90.0/24", + "104.22.91.0/24", + "104.22.92.0/24", + "104.22.93.0/24", + "104.22.94.0/24", + "104.22.95.0/24", + "104.22.96.0/24", + "104.22.97.0/24", + "104.22.98.0/24", + "104.22.99.0/24", + "104.22.100.0/24", + "104.22.101.0/24", + "104.22.102.0/24", + "104.22.103.0/24", + "104.22.104.0/24", + "104.22.105.0/24", + "104.22.106.0/24", + "104.22.107.0/24", + "104.22.108.0/24", + "104.22.109.0/24", + "104.22.110.0/24", + "104.22.111.0/24", + "104.22.112.0/24", + "104.22.113.0/24", + "104.22.114.0/24", + "104.22.115.0/24", + "104.22.116.0/24", + "104.22.117.0/24", + "104.22.118.0/24", + "104.22.119.0/24", + "104.22.120.0/24", + "104.22.121.0/24", + "104.22.122.0/24", + "104.22.123.0/24", + "104.22.124.0/24", + "104.22.125.0/24", + "104.22.126.0/24", + "104.22.127.0/24", + "104.22.128.0/24", + "104.22.129.0/24", + "104.22.130.0/24", + "104.22.131.0/24", + "104.22.132.0/24", + "104.22.133.0/24", + "104.22.134.0/24", + "104.22.135.0/24", + "104.22.136.0/24", + "104.22.137.0/24", + "104.22.138.0/24", + "104.22.139.0/24", + "104.22.140.0/24", + "104.22.141.0/24", + "104.22.142.0/24", + "104.22.143.0/24", + "104.22.144.0/24", + "104.22.145.0/24", + "104.22.146.0/24", + "104.22.147.0/24", + "104.22.148.0/24", + "104.22.149.0/24", + "104.22.150.0/24", + "104.22.151.0/24", + "104.22.152.0/24", + "104.22.153.0/24", + "104.22.154.0/24", + "104.22.155.0/24", + "104.22.156.0/24", + "104.22.157.0/24", + "104.22.158.0/24", + "104.22.159.0/24", + "104.22.160.0/24", + "104.22.161.0/24", + "104.22.162.0/24", + "104.22.163.0/24", + "104.22.164.0/24", + "104.22.165.0/24", + "104.22.166.0/24", + "104.22.167.0/24", + "104.22.168.0/24", + "104.22.169.0/24", + "104.22.170.0/24", + "104.22.171.0/24", + "104.22.172.0/24", + "104.22.173.0/24", + "104.22.174.0/24", + "104.22.175.0/24", + "104.22.176.0/24", + "104.22.177.0/24", + "104.22.178.0/24", + "104.22.179.0/24", + "104.22.180.0/24", + "104.22.181.0/24", + "104.22.182.0/24", + "104.22.183.0/24", + "104.22.184.0/24", + "104.22.185.0/24", + "104.22.186.0/24", + "104.22.187.0/24", + "104.22.188.0/24", + "104.22.189.0/24", + "104.22.190.0/24", + "104.22.191.0/24", + "104.22.192.0/24", + "104.22.193.0/24", + "104.22.194.0/24", + "104.22.195.0/24", + "104.22.196.0/24", + "104.22.197.0/24", + "104.22.198.0/24", + "104.22.199.0/24", + "104.22.200.0/24", + "104.22.201.0/24", + "104.22.202.0/24", + "104.22.203.0/24", + "104.22.204.0/24", + "104.22.205.0/24", + "104.22.206.0/24", + "104.22.207.0/24", + "104.22.208.0/24", + "104.22.209.0/24", + "104.22.210.0/24", + "104.22.211.0/24", + "104.22.212.0/24", + "104.22.213.0/24", + "104.22.214.0/24", + "104.22.215.0/24", + "104.22.216.0/24", + "104.22.217.0/24", + "104.22.218.0/24", + "104.22.219.0/24", + "104.22.220.0/24", + "104.22.221.0/24", + "104.22.222.0/24", + "104.22.223.0/24", + "104.22.224.0/24", + "104.22.225.0/24", + "104.22.226.0/24", + "104.22.227.0/24", + "104.22.228.0/24", + "104.22.229.0/24", + "104.22.230.0/24", + "104.22.231.0/24", + "104.22.232.0/24", + "104.22.233.0/24", + "104.22.234.0/24", + "104.22.235.0/24", + "104.22.236.0/24", + "104.22.237.0/24", + "104.22.238.0/24", + "104.22.239.0/24", + "104.22.240.0/24", + "104.22.241.0/24", + "104.22.242.0/24", + "104.22.243.0/24", + "104.22.244.0/24", + "104.22.245.0/24", + "104.22.246.0/24", + "104.22.247.0/24", + "104.22.248.0/24", + "104.22.249.0/24", + "104.22.250.0/24", + "104.22.251.0/24", + "104.22.252.0/24", + "104.22.253.0/24", + "104.22.254.0/24", + "104.22.255.0/24", + "104.23.0.0/24", + "104.23.1.0/24", + "104.23.2.0/24", + "104.23.3.0/24", + "104.23.4.0/24", + "104.23.5.0/24", + "104.23.6.0/24", + "104.23.7.0/24", + "104.23.8.0/24", + "104.23.9.0/24", + "104.23.10.0/24", + "104.23.11.0/24", + "104.23.12.0/24", + "104.23.13.0/24", + "104.23.14.0/24", + "104.23.15.0/24", + "104.23.16.0/24", + "104.23.17.0/24", + "104.23.18.0/24", + "104.23.19.0/24", + "104.23.20.0/24", + "104.23.21.0/24", + "104.23.22.0/24", + "104.23.23.0/24", + "104.23.24.0/24", + "104.23.25.0/24", + "104.23.26.0/24", + "104.23.27.0/24", + "104.23.28.0/24", + "104.23.29.0/24", + "104.23.30.0/24", + "104.23.31.0/24", + "104.23.32.0/24", + "104.23.33.0/24", + "104.23.34.0/24", + "104.23.35.0/24", + "104.23.36.0/24", + "104.23.37.0/24", + "104.23.38.0/24", + "104.23.39.0/24", + "104.23.40.0/24", + "104.23.41.0/24", + "104.23.42.0/24", + "104.23.43.0/24", + "104.23.44.0/24", + "104.23.45.0/24", + "104.23.46.0/24", + "104.23.47.0/24", + "104.23.48.0/24", + "104.23.49.0/24", + "104.23.50.0/24", + "104.23.51.0/24", + "104.23.52.0/24", + "104.23.53.0/24", + "104.23.54.0/24", + "104.23.55.0/24", + "104.23.56.0/24", + "104.23.57.0/24", + "104.23.58.0/24", + "104.23.59.0/24", + "104.23.60.0/24", + "104.23.61.0/24", + "104.23.62.0/24", + "104.23.63.0/24", + "104.23.64.0/24", + "104.23.65.0/24", + "104.23.66.0/24", + "104.23.67.0/24", + "104.23.68.0/24", + "104.23.69.0/24", + "104.23.70.0/24", + "104.23.71.0/24", + "104.23.72.0/24", + "104.23.73.0/24", + "104.23.74.0/24", + "104.23.75.0/24", + "104.23.76.0/24", + "104.23.77.0/24", + "104.23.78.0/24", + "104.23.79.0/24", + "104.23.80.0/24", + "104.23.81.0/24", + "104.23.82.0/24", + "104.23.83.0/24", + "104.23.84.0/24", + "104.23.85.0/24", + "104.23.86.0/24", + "104.23.87.0/24", + "104.23.88.0/24", + "104.23.89.0/24", + "104.23.90.0/24", + "104.23.91.0/24", + "104.23.92.0/24", + "104.23.93.0/24", + "104.23.94.0/24", + "104.23.95.0/24", + "104.23.96.0/24", + "104.23.97.0/24", + "104.23.98.0/24", + "104.23.99.0/24", + "104.23.100.0/24", + "104.23.101.0/24", + "104.23.102.0/24", + "104.23.103.0/24", + "104.23.104.0/24", + "104.23.105.0/24", + "104.23.106.0/24", + "104.23.107.0/24", + "104.23.108.0/24", + "104.23.109.0/24", + "104.23.110.0/24", + "104.23.111.0/24", + "104.23.112.0/24", + "104.23.113.0/24", + "104.23.114.0/24", + "104.23.115.0/24", + "104.23.116.0/24", + "104.23.117.0/24", + "104.23.118.0/24", + "104.23.119.0/24", + "104.23.120.0/24", + "104.23.121.0/24", + "104.23.122.0/24", + "104.23.123.0/24", + "104.23.124.0/24", + "104.23.125.0/24", + "104.23.126.0/24", + "104.23.127.0/24", + "104.23.128.0/24", + "104.23.129.0/24", + "104.23.130.0/24", + "104.23.131.0/24", + "104.23.132.0/24", + "104.23.133.0/24", + "104.23.134.0/24", + "104.23.135.0/24", + "104.23.136.0/24", + "104.23.137.0/24", + "104.23.138.0/24", + "104.23.139.0/24", + "104.23.140.0/24", + "104.23.141.0/24", + "104.23.142.0/24", + "104.23.143.0/24", + "104.23.144.0/24", + "104.23.145.0/24", + "104.23.146.0/24", + "104.23.147.0/24", + "104.23.148.0/24", + "104.23.149.0/24", + "104.23.150.0/24", + "104.23.151.0/24", + "104.23.152.0/24", + "104.23.153.0/24", + "104.23.154.0/24", + "104.23.155.0/24", + "104.23.156.0/24", + "104.23.157.0/24", + "104.23.158.0/24", + "104.23.159.0/24", + "104.23.160.0/24", + "104.23.161.0/24", + "104.23.162.0/24", + "104.23.163.0/24", + "104.23.164.0/24", + "104.23.165.0/24", + "104.23.166.0/24", + "104.23.167.0/24", + "104.23.168.0/24", + "104.23.169.0/24", + "104.23.170.0/24", + "104.23.171.0/24", + "104.23.172.0/24", + "104.23.173.0/24", + "104.23.174.0/24", + "104.23.175.0/24", + "104.23.176.0/24", + "104.23.177.0/24", + "104.23.178.0/24", + "104.23.179.0/24", + "104.23.180.0/24", + "104.23.181.0/24", + "104.23.182.0/24", + "104.23.183.0/24", + "104.23.184.0/24", + "104.23.185.0/24", + "104.23.186.0/24", + "104.23.187.0/24", + "104.23.188.0/24", + "104.23.189.0/24", + "104.23.190.0/24", + "104.23.191.0/24", + "104.23.192.0/24", + "104.23.193.0/24", + "104.23.194.0/24", + "104.23.195.0/24", + "104.23.196.0/24", + "104.23.197.0/24", + "104.23.198.0/24", + "104.23.199.0/24", + "104.23.200.0/24", + "104.23.201.0/24", + "104.23.202.0/24", + "104.23.203.0/24", + "104.23.204.0/24", + "104.23.205.0/24", + "104.23.206.0/24", + "104.23.207.0/24", + "104.23.208.0/24", + "104.23.209.0/24", + "104.23.210.0/24", + "104.23.211.0/24", + "104.23.212.0/24", + "104.23.213.0/24", + "104.23.214.0/24", + "104.23.215.0/24", + "104.23.216.0/24", + "104.23.217.0/24", + "104.23.218.0/24", + "104.23.219.0/24", + "104.23.220.0/24", + "104.23.221.0/24", + "104.23.222.0/24", + "104.23.223.0/24", + "104.23.224.0/24", + "104.23.225.0/24", + "104.23.226.0/24", + "104.23.227.0/24", + "104.23.228.0/24", + "104.23.229.0/24", + "104.23.230.0/24", + "104.23.231.0/24", + "104.23.232.0/24", + "104.23.233.0/24", + "104.23.234.0/24", + "104.23.235.0/24", + "104.23.236.0/24", + "104.23.237.0/24", + "104.23.238.0/24", + "104.23.239.0/24", + "104.23.240.0/24", + "104.23.241.0/24", + "104.23.242.0/24", + "104.23.243.0/24", + "104.23.244.0/24", + "104.23.245.0/24", + "104.23.246.0/24", + "104.23.247.0/24", + "104.23.248.0/24", + "104.23.249.0/24", + "104.23.250.0/24", + "104.23.251.0/24", + "104.23.252.0/24", + "104.23.253.0/24", + "104.23.254.0/24", + "104.23.255.0/24", + "104.24.0.0/24", + "104.24.1.0/24", + "104.24.2.0/24", + "104.24.3.0/24", + "104.24.4.0/24", + "104.24.5.0/24", + "104.24.6.0/24", + "104.24.7.0/24", + "104.24.8.0/24", + "104.24.9.0/24", + "104.24.10.0/24", + "104.24.11.0/24", + "104.24.12.0/24", + "104.24.13.0/24", + "104.24.14.0/24", + "104.24.15.0/24", + "104.24.16.0/24", + "104.24.17.0/24", + "104.24.18.0/24", + "104.24.19.0/24", + "104.24.20.0/24", + "104.24.21.0/24", + "104.24.22.0/24", + "104.24.23.0/24", + "104.24.24.0/24", + "104.24.25.0/24", + "104.24.26.0/24", + "104.24.27.0/24", + "104.24.28.0/24", + "104.24.29.0/24", + "104.24.30.0/24", + "104.24.31.0/24", + "104.24.32.0/24", + "104.24.33.0/24", + "104.24.34.0/24", + "104.24.35.0/24", + "104.24.36.0/24", + "104.24.37.0/24", + "104.24.38.0/24", + "104.24.39.0/24", + "104.24.40.0/24", + "104.24.41.0/24", + "104.24.42.0/24", + "104.24.43.0/24", + "104.24.44.0/24", + "104.24.45.0/24", + "104.24.46.0/24", + "104.24.47.0/24", + "104.24.48.0/24", + "104.24.49.0/24", + "104.24.50.0/24", + "104.24.51.0/24", + "104.24.52.0/24", + "104.24.53.0/24", + "104.24.54.0/24", + "104.24.55.0/24", + "104.24.56.0/24", + "104.24.57.0/24", + "104.24.58.0/24", + "104.24.59.0/24", + "104.24.60.0/24", + "104.24.61.0/24", + "104.24.62.0/24", + "104.24.63.0/24", + "104.24.64.0/24", + "104.24.65.0/24", + "104.24.66.0/24", + "104.24.67.0/24", + "104.24.68.0/24", + "104.24.69.0/24", + "104.24.70.0/24", + "104.24.71.0/24", + "104.24.72.0/24", + "104.24.73.0/24", + "104.24.74.0/24", + "104.24.75.0/24", + "104.24.76.0/24", + "104.24.77.0/24", + "104.24.78.0/24", + "104.24.79.0/24", + "104.24.80.0/24", + "104.24.81.0/24", + "104.24.82.0/24", + "104.24.83.0/24", + "104.24.84.0/24", + "104.24.85.0/24", + "104.24.86.0/24", + "104.24.87.0/24", + "104.24.88.0/24", + "104.24.89.0/24", + "104.24.90.0/24", + "104.24.91.0/24", + "104.24.92.0/24", + "104.24.93.0/24", + "104.24.94.0/24", + "104.24.95.0/24", + "104.24.96.0/24", + "104.24.97.0/24", + "104.24.98.0/24", + "104.24.99.0/24", + "104.24.100.0/24", + "104.24.101.0/24", + "104.24.102.0/24", + "104.24.103.0/24", + "104.24.104.0/24", + "104.24.105.0/24", + "104.24.106.0/24", + "104.24.107.0/24", + "104.24.108.0/24", + "104.24.109.0/24", + "104.24.110.0/24", + "104.24.111.0/24", + "104.24.112.0/24", + "104.24.113.0/24", + "104.24.114.0/24", + "104.24.115.0/24", + "104.24.116.0/24", + "104.24.117.0/24", + "104.24.118.0/24", + "104.24.119.0/24", + "104.24.120.0/24", + "104.24.121.0/24", + "104.24.122.0/24", + "104.24.123.0/24", + "104.24.124.0/24", + "104.24.125.0/24", + "104.24.126.0/24", + "104.24.127.0/24", + "104.24.128.0/24", + "104.24.129.0/24", + "104.24.130.0/24", + "104.24.131.0/24", + "104.24.132.0/24", + "104.24.133.0/24", + "104.24.134.0/24", + "104.24.135.0/24", + "104.24.136.0/24", + "104.24.137.0/24", + "104.24.138.0/24", + "104.24.139.0/24", + "104.24.140.0/24", + "104.24.141.0/24", + "104.24.142.0/24", + "104.24.143.0/24", + "104.24.144.0/24", + "104.24.145.0/24", + "104.24.146.0/24", + "104.24.147.0/24", + "104.24.148.0/24", + "104.24.149.0/24", + "104.24.150.0/24", + "104.24.151.0/24", + "104.24.152.0/24", + "104.24.153.0/24", + "104.24.154.0/24", + "104.24.155.0/24", + "104.24.156.0/24", + "104.24.157.0/24", + "104.24.158.0/24", + "104.24.159.0/24", + "104.24.160.0/24", + "104.24.161.0/24", + "104.24.162.0/24", + "104.24.163.0/24", + "104.24.164.0/24", + "104.24.165.0/24", + "104.24.166.0/24", + "104.24.167.0/24", + "104.24.168.0/24", + "104.24.169.0/24", + "104.24.170.0/24", + "104.24.171.0/24", + "104.24.172.0/24", + "104.24.173.0/24", + "104.24.174.0/24", + "104.24.175.0/24", + "104.24.176.0/24", + "104.24.177.0/24", + "104.24.178.0/24", + "104.24.179.0/24", + "104.24.180.0/24", + "104.24.181.0/24", + "104.24.182.0/24", + "104.24.183.0/24", + "104.24.184.0/24", + "104.24.185.0/24", + "104.24.186.0/24", + "104.24.187.0/24", + "104.24.188.0/24", + "104.24.189.0/24", + "104.24.190.0/24", + "104.24.191.0/24", + "104.24.192.0/24", + "104.24.193.0/24", + "104.24.194.0/24", + "104.24.195.0/24", + "104.24.196.0/24", + "104.24.197.0/24", + "104.24.198.0/24", + "104.24.199.0/24", + "104.24.200.0/24", + "104.24.201.0/24", + "104.24.202.0/24", + "104.24.203.0/24", + "104.24.204.0/24", + "104.24.205.0/24", + "104.24.206.0/24", + "104.24.207.0/24", + "104.24.208.0/24", + "104.24.209.0/24", + "104.24.210.0/24", + "104.24.211.0/24", + "104.24.212.0/24", + "104.24.213.0/24", + "104.24.214.0/24", + "104.24.215.0/24", + "104.24.216.0/24", + "104.24.217.0/24", + "104.24.218.0/24", + "104.24.219.0/24", + "104.24.220.0/24", + "104.24.221.0/24", + "104.24.222.0/24", + "104.24.223.0/24", + "104.24.224.0/24", + "104.24.225.0/24", + "104.24.226.0/24", + "104.24.227.0/24", + "104.24.228.0/24", + "104.24.229.0/24", + "104.24.230.0/24", + "104.24.231.0/24", + "104.24.232.0/24", + "104.24.233.0/24", + "104.24.234.0/24", + "104.24.235.0/24", + "104.24.236.0/24", + "104.24.237.0/24", + "104.24.238.0/24", + "104.24.239.0/24", + "104.24.240.0/24", + "104.24.241.0/24", + "104.24.242.0/24", + "104.24.243.0/24", + "104.24.244.0/24", + "104.24.245.0/24", + "104.24.246.0/24", + "104.24.247.0/24", + "104.24.248.0/24", + "104.24.249.0/24", + "104.24.250.0/24", + "104.24.251.0/24", + "104.24.252.0/24", + "104.24.253.0/24", + "104.24.254.0/24", + "104.24.255.0/24", + "104.25.0.0/24", + "104.25.1.0/24", + "104.25.2.0/24", + "104.25.3.0/24", + "104.25.4.0/24", + "104.25.5.0/24", + "104.25.6.0/24", + "104.25.7.0/24", + "104.25.8.0/24", + "104.25.9.0/24", + "104.25.10.0/24", + "104.25.11.0/24", + "104.25.12.0/24", + "104.25.13.0/24", + "104.25.14.0/24", + "104.25.15.0/24", + "104.25.16.0/24", + "104.25.17.0/24", + "104.25.18.0/24", + "104.25.19.0/24", + "104.25.20.0/24", + "104.25.21.0/24", + "104.25.22.0/24", + "104.25.23.0/24", + "104.25.24.0/24", + "104.25.25.0/24", + "104.25.26.0/24", + "104.25.27.0/24", + "104.25.28.0/24", + "104.25.29.0/24", + "104.25.30.0/24", + "104.25.31.0/24", + "104.25.32.0/24", + "104.25.33.0/24", + "104.25.34.0/24", + "104.25.35.0/24", + "104.25.36.0/24", + "104.25.37.0/24", + "104.25.38.0/24", + "104.25.39.0/24", + "104.25.40.0/24", + "104.25.41.0/24", + "104.25.42.0/24", + "104.25.43.0/24", + "104.25.44.0/24", + "104.25.45.0/24", + "104.25.46.0/24", + "104.25.47.0/24", + "104.25.48.0/24", + "104.25.49.0/24", + "104.25.50.0/24", + "104.25.51.0/24", + "104.25.52.0/24", + "104.25.53.0/24", + "104.25.54.0/24", + "104.25.55.0/24", + "104.25.56.0/24", + "104.25.57.0/24", + "104.25.58.0/24", + "104.25.59.0/24", + "104.25.60.0/24", + "104.25.61.0/24", + "104.25.62.0/24", + "104.25.63.0/24", + "104.25.64.0/24", + "104.25.65.0/24", + "104.25.66.0/24", + "104.25.67.0/24", + "104.25.68.0/24", + "104.25.69.0/24", + "104.25.70.0/24", + "104.25.71.0/24", + "104.25.72.0/24", + "104.25.73.0/24", + "104.25.74.0/24", + "104.25.75.0/24", + "104.25.76.0/24", + "104.25.77.0/24", + "104.25.78.0/24", + "104.25.79.0/24", + "104.25.80.0/24", + "104.25.81.0/24", + "104.25.82.0/24", + "104.25.83.0/24", + "104.25.84.0/24", + "104.25.85.0/24", + "104.25.86.0/24", + "104.25.87.0/24", + "104.25.88.0/24", + "104.25.89.0/24", + "104.25.90.0/24", + "104.25.91.0/24", + "104.25.92.0/24", + "104.25.93.0/24", + "104.25.94.0/24", + "104.25.95.0/24", + "104.25.96.0/24", + "104.25.97.0/24", + "104.25.98.0/24", + "104.25.99.0/24", + "104.25.100.0/24", + "104.25.101.0/24", + "104.25.102.0/24", + "104.25.103.0/24", + "104.25.104.0/24", + "104.25.105.0/24", + "104.25.106.0/24", + "104.25.107.0/24", + "104.25.108.0/24", + "104.25.109.0/24", + "104.25.110.0/24", + "104.25.111.0/24", + "104.25.112.0/24", + "104.25.113.0/24", + "104.25.114.0/24", + "104.25.115.0/24", + "104.25.116.0/24", + "104.25.117.0/24", + "104.25.118.0/24", + "104.25.119.0/24", + "104.25.120.0/24", + "104.25.121.0/24", + "104.25.122.0/24", + "104.25.123.0/24", + "104.25.124.0/24", + "104.25.125.0/24", + "104.25.126.0/24", + "104.25.127.0/24", + "104.25.128.0/24", + "104.25.129.0/24", + "104.25.130.0/24", + "104.25.131.0/24", + "104.25.132.0/24", + "104.25.133.0/24", + "104.25.134.0/24", + "104.25.135.0/24", + "104.25.136.0/24", + "104.25.137.0/24", + "104.25.138.0/24", + "104.25.139.0/24", + "104.25.140.0/24", + "104.25.141.0/24", + "104.25.142.0/24", + "104.25.143.0/24", + "104.25.144.0/24", + "104.25.145.0/24", + "104.25.146.0/24", + "104.25.147.0/24", + "104.25.148.0/24", + "104.25.149.0/24", + "104.25.150.0/24", + "104.25.151.0/24", + "104.25.152.0/24", + "104.25.153.0/24", + "104.25.154.0/24", + "104.25.155.0/24", + "104.25.156.0/24", + "104.25.157.0/24", + "104.25.158.0/24", + "104.25.159.0/24", + "104.25.160.0/24", + "104.25.161.0/24", + "104.25.162.0/24", + "104.25.163.0/24", + "104.25.164.0/24", + "104.25.165.0/24", + "104.25.166.0/24", + "104.25.167.0/24", + "104.25.168.0/24", + "104.25.169.0/24", + "104.25.170.0/24", + "104.25.171.0/24", + "104.25.172.0/24", + "104.25.173.0/24", + "104.25.174.0/24", + "104.25.175.0/24", + "104.25.176.0/24", + "104.25.177.0/24", + "104.25.178.0/24", + "104.25.179.0/24", + "104.25.180.0/24", + "104.25.181.0/24", + "104.25.182.0/24", + "104.25.183.0/24", + "104.25.184.0/24", + "104.25.185.0/24", + "104.25.186.0/24", + "104.25.187.0/24", + "104.25.188.0/24", + "104.25.189.0/24", + "104.25.190.0/24", + "104.25.191.0/24", + "104.25.192.0/24", + "104.25.193.0/24", + "104.25.194.0/24", + "104.25.195.0/24", + "104.25.196.0/24", + "104.25.197.0/24", + "104.25.198.0/24", + "104.25.199.0/24", + "104.25.200.0/24", + "104.25.201.0/24", + "104.25.202.0/24", + "104.25.203.0/24", + "104.25.204.0/24", + "104.25.205.0/24", + "104.25.206.0/24", + "104.25.207.0/24", + "104.25.208.0/24", + "104.25.209.0/24", + "104.25.210.0/24", + "104.25.211.0/24", + "104.25.212.0/24", + "104.25.213.0/24", + "104.25.214.0/24", + "104.25.215.0/24", + "104.25.216.0/24", + "104.25.217.0/24", + "104.25.218.0/24", + "104.25.219.0/24", + "104.25.220.0/24", + "104.25.221.0/24", + "104.25.222.0/24", + "104.25.223.0/24", + "104.25.224.0/24", + "104.25.225.0/24", + "104.25.226.0/24", + "104.25.227.0/24", + "104.25.228.0/24", + "104.25.229.0/24", + "104.25.230.0/24", + "104.25.231.0/24", + "104.25.232.0/24", + "104.25.233.0/24", + "104.25.234.0/24", + "104.25.235.0/24", + "104.25.236.0/24", + "104.25.237.0/24", + "104.25.238.0/24", + "104.25.239.0/24", + "104.25.240.0/24", + "104.25.241.0/24", + "104.25.242.0/24", + "104.25.243.0/24", + "104.25.244.0/24", + "104.25.245.0/24", + "104.25.246.0/24", + "104.25.247.0/24", + "104.25.248.0/24", + "104.25.249.0/24", + "104.25.250.0/24", + "104.25.251.0/24", + "104.25.252.0/24", + "104.25.253.0/24", + "104.25.254.0/24", + "104.25.255.0/24", + "104.26.0.0/24", + "104.26.1.0/24", + "104.26.2.0/24", + "104.26.3.0/24", + "104.26.4.0/24", + "104.26.5.0/24", + "104.26.6.0/24", + "104.26.7.0/24", + "104.26.8.0/24", + "104.26.9.0/24", + "104.26.10.0/24", + "104.26.11.0/24", + "104.26.12.0/24", + "104.26.13.0/24", + "104.26.14.0/24", + "104.26.15.0/24", + "104.26.16.0/24", + "104.26.17.0/24", + "104.26.18.0/24", + "104.26.19.0/24", + "104.26.20.0/24", + "104.26.21.0/24", + "104.26.22.0/24", + "104.26.23.0/24", + "104.26.24.0/24", + "104.26.25.0/24", + "104.26.26.0/24", + "104.26.27.0/24", + "104.26.28.0/24", + "104.26.29.0/24", + "104.26.30.0/24", + "104.26.31.0/24", + "104.26.32.0/24", + "104.26.33.0/24", + "104.26.34.0/24", + "104.26.35.0/24", + "104.26.36.0/24", + "104.26.37.0/24", + "104.26.38.0/24", + "104.26.39.0/24", + "104.26.40.0/24", + "104.26.41.0/24", + "104.26.42.0/24", + "104.26.43.0/24", + "104.26.44.0/24", + "104.26.45.0/24", + "104.26.46.0/24", + "104.26.47.0/24", + "104.26.48.0/24", + "104.26.49.0/24", + "104.26.50.0/24", + "104.26.51.0/24", + "104.26.52.0/24", + "104.26.53.0/24", + "104.26.54.0/24", + "104.26.55.0/24", + "104.26.56.0/24", + "104.26.57.0/24", + "104.26.58.0/24", + "104.26.59.0/24", + "104.26.60.0/24", + "104.26.61.0/24", + "104.26.62.0/24", + "104.26.63.0/24", + "104.26.64.0/24", + "104.26.65.0/24", + "104.26.66.0/24", + "104.26.67.0/24", + "104.26.68.0/24", + "104.26.69.0/24", + "104.26.70.0/24", + "104.26.71.0/24", + "104.26.72.0/24", + "104.26.73.0/24", + "104.26.74.0/24", + "104.26.75.0/24", + "104.26.76.0/24", + "104.26.77.0/24", + "104.26.78.0/24", + "104.26.79.0/24", + "104.26.80.0/24", + "104.26.81.0/24", + "104.26.82.0/24", + "104.26.83.0/24", + "104.26.84.0/24", + "104.26.85.0/24", + "104.26.86.0/24", + "104.26.87.0/24", + "104.26.88.0/24", + "104.26.89.0/24", + "104.26.90.0/24", + "104.26.91.0/24", + "104.26.92.0/24", + "104.26.93.0/24", + "104.26.94.0/24", + "104.26.95.0/24", + "104.26.96.0/24", + "104.26.97.0/24", + "104.26.98.0/24", + "104.26.99.0/24", + "104.26.100.0/24", + "104.26.101.0/24", + "104.26.102.0/24", + "104.26.103.0/24", + "104.26.104.0/24", + "104.26.105.0/24", + "104.26.106.0/24", + "104.26.107.0/24", + "104.26.108.0/24", + "104.26.109.0/24", + "104.26.110.0/24", + "104.26.111.0/24", + "104.26.112.0/24", + "104.26.113.0/24", + "104.26.114.0/24", + "104.26.115.0/24", + "104.26.116.0/24", + "104.26.117.0/24", + "104.26.118.0/24", + "104.26.119.0/24", + "104.26.120.0/24", + "104.26.121.0/24", + "104.26.122.0/24", + "104.26.123.0/24", + "104.26.124.0/24", + "104.26.125.0/24", + "104.26.126.0/24", + "104.26.127.0/24", + "104.26.128.0/24", + "104.26.129.0/24", + "104.26.130.0/24", + "104.26.131.0/24", + "104.26.132.0/24", + "104.26.133.0/24", + "104.26.134.0/24", + "104.26.135.0/24", + "104.26.136.0/24", + "104.26.137.0/24", + "104.26.138.0/24", + "104.26.139.0/24", + "104.26.140.0/24", + "104.26.141.0/24", + "104.26.142.0/24", + "104.26.143.0/24", + "104.26.144.0/24", + "104.26.145.0/24", + "104.26.146.0/24", + "104.26.147.0/24", + "104.26.148.0/24", + "104.26.149.0/24", + "104.26.150.0/24", + "104.26.151.0/24", + "104.26.152.0/24", + "104.26.153.0/24", + "104.26.154.0/24", + "104.26.155.0/24", + "104.26.156.0/24", + "104.26.157.0/24", + "104.26.158.0/24", + "104.26.159.0/24", + "104.26.160.0/24", + "104.26.161.0/24", + "104.26.162.0/24", + "104.26.163.0/24", + "104.26.164.0/24", + "104.26.165.0/24", + "104.26.166.0/24", + "104.26.167.0/24", + "104.26.168.0/24", + "104.26.169.0/24", + "104.26.170.0/24", + "104.26.171.0/24", + "104.26.172.0/24", + "104.26.173.0/24", + "104.26.174.0/24", + "104.26.175.0/24", + "104.26.176.0/24", + "104.26.177.0/24", + "104.26.178.0/24", + "104.26.179.0/24", + "104.26.180.0/24", + "104.26.181.0/24", + "104.26.182.0/24", + "104.26.183.0/24", + "104.26.184.0/24", + "104.26.185.0/24", + "104.26.186.0/24", + "104.26.187.0/24", + "104.26.188.0/24", + "104.26.189.0/24", + "104.26.190.0/24", + "104.26.191.0/24", + "104.26.192.0/24", + "104.26.193.0/24", + "104.26.194.0/24", + "104.26.195.0/24", + "104.26.196.0/24", + "104.26.197.0/24", + "104.26.198.0/24", + "104.26.199.0/24", + "104.26.200.0/24", + "104.26.201.0/24", + "104.26.202.0/24", + "104.26.203.0/24", + "104.26.204.0/24", + "104.26.205.0/24", + "104.26.206.0/24", + "104.26.207.0/24", + "104.26.208.0/24", + "104.26.209.0/24", + "104.26.210.0/24", + "104.26.211.0/24", + "104.26.212.0/24", + "104.26.213.0/24", + "104.26.214.0/24", + "104.26.215.0/24", + "104.26.216.0/24", + "104.26.217.0/24", + "104.26.218.0/24", + "104.26.219.0/24", + "104.26.220.0/24", + "104.26.221.0/24", + "104.26.222.0/24", + "104.26.223.0/24", + "104.26.224.0/24", + "104.26.225.0/24", + "104.26.226.0/24", + "104.26.227.0/24", + "104.26.228.0/24", + "104.26.229.0/24", + "104.26.230.0/24", + "104.26.231.0/24", + "104.26.232.0/24", + "104.26.233.0/24", + "104.26.234.0/24", + "104.26.235.0/24", + "104.26.236.0/24", + "104.26.237.0/24", + "104.26.238.0/24", + "104.26.239.0/24", + "104.26.240.0/24", + "104.26.241.0/24", + "104.26.242.0/24", + "104.26.243.0/24", + "104.26.244.0/24", + "104.26.245.0/24", + "104.26.246.0/24", + "104.26.247.0/24", + "104.26.248.0/24", + "104.26.249.0/24", + "104.26.250.0/24", + "104.26.251.0/24", + "104.26.252.0/24", + "104.26.253.0/24", + "104.26.254.0/24", + "104.26.255.0/24", + "104.27.0.0/24", + "104.27.1.0/24", + "104.27.2.0/24", + "104.27.3.0/24", + "104.27.4.0/24", + "104.27.5.0/24", + "104.27.6.0/24", + "104.27.7.0/24", + "104.27.8.0/24", + "104.27.9.0/24", + "104.27.10.0/24", + "104.27.11.0/24", + "104.27.12.0/24", + "104.27.13.0/24", + "104.27.14.0/24", + "104.27.15.0/24", + "104.27.16.0/24", + "104.27.17.0/24", + "104.27.18.0/24", + "104.27.19.0/24", + "104.27.20.0/24", + "104.27.21.0/24", + "104.27.22.0/24", + "104.27.23.0/24", + "104.27.24.0/24", + "104.27.25.0/24", + "104.27.26.0/24", + "104.27.27.0/24", + "104.27.28.0/24", + "104.27.29.0/24", + "104.27.30.0/24", + "104.27.31.0/24", + "104.27.32.0/24", + "104.27.33.0/24", + "104.27.34.0/24", + "104.27.35.0/24", + "104.27.36.0/24", + "104.27.37.0/24", + "104.27.38.0/24", + "104.27.39.0/24", + "104.27.40.0/24", + "104.27.41.0/24", + "104.27.42.0/24", + "104.27.43.0/24", + "104.27.44.0/24", + "104.27.45.0/24", + "104.27.46.0/24", + "104.27.47.0/24", + "104.27.48.0/24", + "104.27.49.0/24", + "104.27.50.0/24", + "104.27.51.0/24", + "104.27.52.0/24", + "104.27.53.0/24", + "104.27.54.0/24", + "104.27.55.0/24", + "104.27.56.0/24", + "104.27.57.0/24", + "104.27.58.0/24", + "104.27.59.0/24", + "104.27.60.0/24", + "104.27.61.0/24", + "104.27.62.0/24", + "104.27.63.0/24", + "104.27.64.0/24", + "104.27.65.0/24", + "104.27.66.0/24", + "104.27.67.0/24", + "104.27.68.0/24", + "104.27.69.0/24", + "104.27.70.0/24", + "104.27.71.0/24", + "104.27.72.0/24", + "104.27.73.0/24", + "104.27.74.0/24", + "104.27.75.0/24", + "104.27.76.0/24", + "104.27.77.0/24", + "104.27.78.0/24", + "104.27.79.0/24", + "104.27.80.0/24", + "104.27.81.0/24", + "104.27.82.0/24", + "104.27.83.0/24", + "104.27.84.0/24", + "104.27.85.0/24", + "104.27.86.0/24", + "104.27.87.0/24", + "104.27.88.0/24", + "104.27.89.0/24", + "104.27.90.0/24", + "104.27.91.0/24", + "104.27.92.0/24", + "104.27.93.0/24", + "104.27.94.0/24", + "104.27.95.0/24", + "104.27.96.0/24", + "104.27.97.0/24", + "104.27.98.0/24", + "104.27.99.0/24", + "104.27.100.0/24", + "104.27.101.0/24", + "104.27.102.0/24", + "104.27.103.0/24", + "104.27.104.0/24", + "104.27.105.0/24", + "104.27.106.0/24", + "104.27.107.0/24", + "104.27.108.0/24", + "104.27.109.0/24", + "104.27.110.0/24", + "104.27.111.0/24", + "104.27.112.0/24", + "104.27.113.0/24", + "104.27.114.0/24", + "104.27.115.0/24", + "104.27.116.0/24", + "104.27.117.0/24", + "104.27.118.0/24", + "104.27.119.0/24", + "104.27.120.0/24", + "104.27.121.0/24", + "104.27.122.0/24", + "104.27.123.0/24", + "104.27.124.0/24", + "104.27.125.0/24", + "104.27.126.0/24", + "104.27.127.0/24", + "104.27.128.0/24", + "104.27.129.0/24", + "104.27.130.0/24", + "104.27.131.0/24", + "104.27.132.0/24", + "104.27.133.0/24", + "104.27.134.0/24", + "104.27.135.0/24", + "104.27.136.0/24", + "104.27.137.0/24", + "104.27.138.0/24", + "104.27.139.0/24", + "104.27.140.0/24", + "104.27.141.0/24", + "104.27.142.0/24", + "104.27.143.0/24", + "104.27.144.0/24", + "104.27.145.0/24", + "104.27.146.0/24", + "104.27.147.0/24", + "104.27.148.0/24", + "104.27.149.0/24", + "104.27.150.0/24", + "104.27.151.0/24", + "104.27.152.0/24", + "104.27.153.0/24", + "104.27.154.0/24", + "104.27.155.0/24", + "104.27.156.0/24", + "104.27.157.0/24", + "104.27.158.0/24", + "104.27.159.0/24", + "104.27.160.0/24", + "104.27.161.0/24", + "104.27.162.0/24", + "104.27.163.0/24", + "104.27.164.0/24", + "104.27.165.0/24", + "104.27.166.0/24", + "104.27.167.0/24", + "104.27.168.0/24", + "104.27.169.0/24", + "104.27.170.0/24", + "104.27.171.0/24", + "104.27.172.0/24", + "104.27.173.0/24", + "104.27.174.0/24", + "104.27.175.0/24", + "104.27.176.0/24", + "104.27.177.0/24", + "104.27.178.0/24", + "104.27.179.0/24", + "104.27.180.0/24", + "104.27.181.0/24", + "104.27.182.0/24", + "104.27.183.0/24", + "104.27.184.0/24", + "104.27.185.0/24", + "104.27.186.0/24", + "104.27.187.0/24", + "104.27.188.0/24", + "104.27.189.0/24", + "104.27.190.0/24", + "104.27.191.0/24", + "104.27.192.0/24", + "104.27.193.0/24", + "104.27.194.0/24", + "104.27.195.0/24", + "104.27.196.0/24", + "104.27.197.0/24", + "104.27.198.0/24", + "104.27.199.0/24", + "104.27.200.0/24", + "104.27.201.0/24", + "104.27.202.0/24", + "104.27.203.0/24", + "104.27.204.0/24", + "104.27.205.0/24", + "104.27.206.0/24", + "104.27.207.0/24", + "104.27.208.0/24", + "104.27.209.0/24", + "104.27.210.0/24", + "104.27.211.0/24", + "104.27.212.0/24", + "104.27.213.0/24", + "104.27.214.0/24", + "104.27.215.0/24", + "104.27.216.0/24", + "104.27.217.0/24", + "104.27.218.0/24", + "104.27.219.0/24", + "104.27.220.0/24", + "104.27.221.0/24", + "104.27.222.0/24", + "104.27.223.0/24", + "104.27.224.0/24", + "104.27.225.0/24", + "104.27.226.0/24", + "104.27.227.0/24", + "104.27.228.0/24", + "104.27.229.0/24", + "104.27.230.0/24", + "104.27.231.0/24", + "104.27.232.0/24", + "104.27.233.0/24", + "104.27.234.0/24", + "104.27.235.0/24", + "104.27.236.0/24", + "104.27.237.0/24", + "104.27.238.0/24", + "104.27.239.0/24", + "104.27.240.0/24", + "104.27.241.0/24", + "104.27.242.0/24", + "104.27.243.0/24", + "104.27.244.0/24", + "104.27.245.0/24", + "104.27.246.0/24", + "104.27.247.0/24", + "104.27.248.0/24", + "104.27.249.0/24", + "104.27.250.0/24", + "104.27.251.0/24", + "104.27.252.0/24", + "104.27.253.0/24", + "104.27.254.0/24", + "104.27.255.0/24", + "104.28.0.0/24", + "104.28.1.0/24", + "104.28.2.0/24", + "104.28.3.0/24", + "104.28.4.0/24", + "104.28.5.0/24", + "104.28.6.0/24", + "104.28.7.0/24", + "104.28.8.0/24", + "104.28.9.0/24", + "104.28.10.0/24", + "104.28.11.0/24", + "104.28.12.0/24", + "104.28.13.0/24", + "104.28.14.0/24", + "104.28.15.0/24", + "104.28.16.0/24", + "104.28.17.0/24", + "104.28.18.0/24", + "104.28.19.0/24", + "104.28.20.0/24", + "104.28.21.0/24", + "104.28.22.0/24", + "104.28.23.0/24", + "104.28.24.0/24", + "104.28.25.0/24", + "104.28.26.0/24", + "104.28.27.0/24", + "104.28.28.0/24", + "104.28.29.0/24", + "104.28.30.0/24", + "104.28.31.0/24", + "104.28.32.0/24", + "104.28.33.0/24", + "104.28.34.0/24", + "104.28.35.0/24", + "104.28.36.0/24", + "104.28.37.0/24", + "104.28.38.0/24", + "104.28.39.0/24", + "104.28.40.0/24", + "104.28.41.0/24", + "104.28.42.0/24", + "104.28.43.0/24", + "104.28.44.0/24", + "104.28.45.0/24", + "104.28.46.0/24", + "104.28.47.0/24", + "104.28.48.0/24", + "104.28.49.0/24", + "104.28.50.0/24", + "104.28.51.0/24", + "104.28.52.0/24", + "104.28.53.0/24", + "104.28.54.0/24", + "104.28.55.0/24", + "104.28.56.0/24", + "104.28.57.0/24", + "104.28.58.0/24", + "104.28.59.0/24", + "104.28.60.0/24", + "104.28.61.0/24", + "104.28.62.0/24", + "104.28.63.0/24", + "104.28.64.0/24", + "104.28.65.0/24", + "104.28.66.0/24", + "104.28.67.0/24", + "104.28.68.0/24", + "104.28.69.0/24", + "104.28.70.0/24", + "104.28.71.0/24", + "104.28.72.0/24", + "104.28.73.0/24", + "104.28.74.0/24", + "104.28.75.0/24", + "104.28.76.0/24", + "104.28.77.0/24", + "104.28.78.0/24", + "104.28.79.0/24", + "104.28.80.0/24", + "104.28.81.0/24", + "104.28.82.0/24", + "104.28.83.0/24", + "104.28.84.0/24", + "104.28.85.0/24", + "104.28.86.0/24", + "104.28.87.0/24", + "104.28.88.0/24", + "104.28.89.0/24", + "104.28.90.0/24", + "104.28.91.0/24", + "104.28.92.0/24", + "104.28.93.0/24", + "104.28.94.0/24", + "104.28.95.0/24", + "104.28.96.0/24", + "104.28.97.0/24", + "104.28.98.0/24", + "104.28.99.0/24", + "104.28.100.0/24", + "104.28.101.0/24", + "104.28.102.0/24", + "104.28.103.0/24", + "104.28.104.0/24", + "104.28.105.0/24", + "104.28.106.0/24", + "104.28.107.0/24", + "104.28.108.0/24", + "104.28.109.0/24", + "104.28.110.0/24", + "104.28.111.0/24", + "104.28.112.0/24", + "104.28.113.0/24", + "104.28.114.0/24", + "104.28.115.0/24", + "104.28.116.0/24", + "104.28.117.0/24", + "104.28.118.0/24", + "104.28.119.0/24", + "104.28.120.0/24", + "104.28.121.0/24", + "104.28.122.0/24", + "104.28.123.0/24", + "104.28.124.0/24", + "104.28.125.0/24", + "104.28.126.0/24", + "104.28.127.0/24", + "104.28.128.0/24", + "104.28.129.0/24", + "104.28.130.0/24", + "104.28.131.0/24", + "104.28.132.0/24", + "104.28.133.0/24", + "104.28.134.0/24", + "104.28.135.0/24", + "104.28.136.0/24", + "104.28.137.0/24", + "104.28.138.0/24", + "104.28.139.0/24", + "104.28.140.0/24", + "104.28.141.0/24", + "104.28.142.0/24", + "104.28.143.0/24", + "104.28.144.0/24", + "104.28.145.0/24", + "104.28.146.0/24", + "104.28.147.0/24", + "104.28.148.0/24", + "104.28.149.0/24", + "104.28.150.0/24", + "104.28.151.0/24", + "104.28.152.0/24", + "104.28.153.0/24", + "104.28.154.0/24", + "104.28.155.0/24", + "104.28.156.0/24", + "104.28.157.0/24", + "104.28.158.0/24", + "104.28.159.0/24", + "104.28.160.0/24", + "104.28.161.0/24", + "104.28.162.0/24", + "104.28.163.0/24", + "104.28.164.0/24", + "104.28.165.0/24", + "104.28.166.0/24", + "104.28.167.0/24", + "104.28.168.0/24", + "104.28.169.0/24", + "104.28.170.0/24", + "104.28.171.0/24", + "104.28.172.0/24", + "104.28.173.0/24", + "104.28.174.0/24", + "104.28.175.0/24", + "104.28.176.0/24", + "104.28.177.0/24", + "104.28.178.0/24", + "104.28.179.0/24", + "104.28.180.0/24", + "104.28.181.0/24", + "104.28.182.0/24", + "104.28.183.0/24", + "104.28.184.0/24", + "104.28.185.0/24", + "104.28.186.0/24", + "104.28.187.0/24", + "104.28.188.0/24", + "104.28.189.0/24", + "104.28.190.0/24", + "104.28.191.0/24", + "104.28.192.0/24", + "104.28.193.0/24", + "104.28.194.0/24", + "104.28.195.0/24", + "104.28.196.0/24", + "104.28.197.0/24", + "104.28.198.0/24", + "104.28.199.0/24", + "104.28.200.0/24", + "104.28.201.0/24", + "104.28.202.0/24", + "104.28.203.0/24", + "104.28.204.0/24", + "104.28.205.0/24", + "104.28.206.0/24", + "104.28.207.0/24", + "104.28.208.0/24", + "104.28.209.0/24", + "104.28.210.0/24", + "104.28.211.0/24", + "104.28.212.0/24", + "104.28.213.0/24", + "104.28.214.0/24", + "104.28.215.0/24", + "104.28.216.0/24", + "104.28.217.0/24", + "104.28.218.0/24", + "104.28.219.0/24", + "104.28.220.0/24", + "104.28.221.0/24", + "104.28.222.0/24", + "104.28.223.0/24", + "104.28.224.0/24", + "104.28.225.0/24", + "104.28.226.0/24", + "104.28.227.0/24", + "104.28.228.0/24", + "104.28.229.0/24", + "104.28.230.0/24", + "104.28.231.0/24", + "104.28.232.0/24", + "104.28.233.0/24", + "104.28.234.0/24", + "104.28.235.0/24", + "104.28.236.0/24", + "104.28.237.0/24", + "104.28.238.0/24", + "104.28.239.0/24", + "104.28.240.0/24", + "104.28.241.0/24", + "104.28.242.0/24", + "104.28.243.0/24", + "104.28.244.0/24", + "104.28.245.0/24", + "104.28.246.0/24", + "104.28.247.0/24", + "104.28.248.0/24", + "104.28.249.0/24", + "104.28.250.0/24", + "104.28.251.0/24", + "104.28.252.0/24", + "104.28.253.0/24", + "104.28.254.0/24", + "104.28.255.0/24", + "104.29.0.0/24", + "104.29.1.0/24", + "104.29.2.0/24", + "104.29.3.0/24", + "104.29.4.0/24", + "104.29.5.0/24", + "104.29.6.0/24", + "104.29.7.0/24", + "104.29.8.0/24", + "104.29.9.0/24", + "104.29.10.0/24", + "104.29.11.0/24", + "104.29.12.0/24", + "104.29.13.0/24", + "104.29.14.0/24", + "104.29.15.0/24", + "104.29.16.0/24", + "104.29.17.0/24", + "104.29.18.0/24", + "104.29.19.0/24", + "104.29.20.0/24", + "104.29.21.0/24", + "104.29.22.0/24", + "104.29.23.0/24", + "104.29.24.0/24", + "104.29.25.0/24", + "104.29.26.0/24", + "104.29.27.0/24", + "104.29.28.0/24", + "104.29.29.0/24", + "104.29.30.0/24", + "104.29.31.0/24", + "104.29.32.0/24", + "104.29.33.0/24", + "104.29.34.0/24", + "104.29.35.0/24", + "104.29.36.0/24", + "104.29.37.0/24", + "104.29.38.0/24", + "104.29.39.0/24", + "104.29.40.0/24", + "104.29.41.0/24", + "104.29.42.0/24", + "104.29.43.0/24", + "104.29.44.0/24", + "104.29.45.0/24", + "104.29.46.0/24", + "104.29.47.0/24", + "104.29.48.0/24", + "104.29.49.0/24", + "104.29.50.0/24", + "104.29.51.0/24", + "104.29.52.0/24", + "104.29.53.0/24", + "104.29.54.0/24", + "104.29.55.0/24", + "104.29.56.0/24", + "104.29.57.0/24", + "104.29.58.0/24", + "104.29.59.0/24", + "104.29.60.0/24", + "104.29.61.0/24", + "104.29.62.0/24", + "104.29.63.0/24", + "104.29.64.0/24", + "104.29.65.0/24", + "104.29.66.0/24", + "104.29.67.0/24", + "104.29.68.0/24", + "104.29.69.0/24", + "104.29.70.0/24", + "104.29.71.0/24", + "104.29.72.0/24", + "104.29.73.0/24", + "104.29.74.0/24", + "104.29.75.0/24", + "104.29.76.0/24", + "104.29.77.0/24", + "104.29.78.0/24", + "104.29.79.0/24", + "104.29.80.0/24", + "104.29.81.0/24", + "104.29.82.0/24", + "104.29.83.0/24", + "104.29.84.0/24", + "104.29.85.0/24", + "104.29.86.0/24", + "104.29.87.0/24", + "104.29.88.0/24", + "104.29.89.0/24", + "104.29.90.0/24", + "104.29.91.0/24", + "104.29.92.0/24", + "104.29.93.0/24", + "104.29.94.0/24", + "104.29.95.0/24", + "104.29.96.0/24", + "104.29.97.0/24", + "104.29.98.0/24", + "104.29.99.0/24", + "104.29.100.0/24", + "104.29.101.0/24", + "104.29.102.0/24", + "104.29.103.0/24", + "104.29.104.0/24", + "104.29.105.0/24", + "104.29.106.0/24", + "104.29.107.0/24", + "104.29.108.0/24", + "104.29.109.0/24", + "104.29.110.0/24", + "104.29.111.0/24", + "104.29.112.0/24", + "104.29.113.0/24", + "104.29.114.0/24", + "104.29.115.0/24", + "104.29.116.0/24", + "104.29.117.0/24", + "104.29.118.0/24", + "104.29.119.0/24", + "104.29.120.0/24", + "104.29.121.0/24", + "104.29.122.0/24", + "104.29.123.0/24", + "104.29.124.0/24", + "104.29.125.0/24", + "104.29.126.0/24", + "104.29.127.0/24", + "104.29.128.0/24", + "104.29.129.0/24", + "104.29.130.0/24", + "104.29.131.0/24", + "104.29.132.0/24", + "104.29.133.0/24", + "104.29.134.0/24", + "104.29.135.0/24", + "104.29.136.0/24", + "104.29.137.0/24", + "104.29.138.0/24", + "104.29.139.0/24", + "104.29.140.0/24", + "104.29.141.0/24", + "104.29.142.0/24", + "104.29.143.0/24", + "104.29.144.0/24", + "104.29.145.0/24", + "104.29.146.0/24", + "104.29.147.0/24", + "104.29.148.0/24", + "104.29.149.0/24", + "104.29.150.0/24", + "104.29.151.0/24", + "104.29.152.0/24", + "104.29.153.0/24", + "104.29.154.0/24", + "104.29.155.0/24", + "104.29.156.0/24", + "104.29.157.0/24", + "104.29.158.0/24", + "104.29.159.0/24", + "104.29.160.0/24", + "104.29.161.0/24", + "104.29.162.0/24", + "104.29.163.0/24", + "104.29.164.0/24", + "104.29.165.0/24", + "104.29.166.0/24", + "104.29.167.0/24", + "104.29.168.0/24", + "104.29.169.0/24", + "104.29.170.0/24", + "104.29.171.0/24", + "104.29.172.0/24", + "104.29.173.0/24", + "104.29.174.0/24", + "104.29.175.0/24", + "104.29.176.0/24", + "104.29.177.0/24", + "104.29.178.0/24", + "104.29.179.0/24", + "104.29.180.0/24", + "104.29.181.0/24", + "104.29.182.0/24", + "104.29.183.0/24", + "104.29.184.0/24", + "104.29.185.0/24", + "104.29.186.0/24", + "104.29.187.0/24", + "104.29.188.0/24", + "104.29.189.0/24", + "104.29.190.0/24", + "104.29.191.0/24", + "104.29.192.0/24", + "104.29.193.0/24", + "104.29.194.0/24", + "104.29.195.0/24", + "104.29.196.0/24", + "104.29.197.0/24", + "104.29.198.0/24", + "104.29.199.0/24", + "104.29.200.0/24", + "104.29.201.0/24", + "104.29.202.0/24", + "104.29.203.0/24", + "104.29.204.0/24", + "104.29.205.0/24", + "104.29.206.0/24", + "104.29.207.0/24", + "104.29.208.0/24", + "104.29.209.0/24", + "104.29.210.0/24", + "104.29.211.0/24", + "104.29.212.0/24", + "104.29.213.0/24", + "104.29.214.0/24", + "104.29.215.0/24", + "104.29.216.0/24", + "104.29.217.0/24", + "104.29.218.0/24", + "104.29.219.0/24", + "104.29.220.0/24", + "104.29.221.0/24", + "104.29.222.0/24", + "104.29.223.0/24", + "104.29.224.0/24", + "104.29.225.0/24", + "104.29.226.0/24", + "104.29.227.0/24", + "104.29.228.0/24", + "104.29.229.0/24", + "104.29.230.0/24", + "104.29.231.0/24", + "104.29.232.0/24", + "104.29.233.0/24", + "104.29.234.0/24", + "104.29.235.0/24", + "104.29.236.0/24", + "104.29.237.0/24", + "104.29.238.0/24", + "104.29.239.0/24", + "104.29.240.0/24", + "104.29.241.0/24", + "104.29.242.0/24", + "104.29.243.0/24", + "104.29.244.0/24", + "104.29.245.0/24", + "104.29.246.0/24", + "104.29.247.0/24", + "104.29.248.0/24", + "104.29.249.0/24", + "104.29.250.0/24", + "104.29.251.0/24", + "104.29.252.0/24", + "104.29.253.0/24", + "104.29.254.0/24", + "104.29.255.0/24", + "104.30.0.0/24", + "104.30.1.0/24", + "104.30.2.0/24", + "104.30.3.0/24", + "104.30.4.0/24", + "104.30.5.0/24", + "104.30.6.0/24", + "104.30.7.0/24", + "104.30.8.0/24", + "104.30.9.0/24", + "104.30.10.0/24", + "104.30.11.0/24", + "104.30.12.0/24", + "104.30.13.0/24", + "104.30.14.0/24", + "104.30.15.0/24", + "104.30.16.0/24", + "104.30.17.0/24", + "104.30.18.0/24", + "104.30.19.0/24", + "104.30.20.0/24", + "104.30.21.0/24", + "104.30.22.0/24", + "104.30.23.0/24", + "104.30.24.0/24", + "104.30.25.0/24", + "104.30.26.0/24", + "104.30.27.0/24", + "104.30.28.0/24", + "104.30.29.0/24", + "104.30.30.0/24", + "104.30.31.0/24", + "104.30.32.0/24", + "104.30.33.0/24", + "104.30.34.0/24", + "104.30.35.0/24", + "104.30.36.0/24", + "104.30.37.0/24", + "104.30.38.0/24", + "104.30.39.0/24", + "104.30.40.0/24", + "104.30.41.0/24", + "104.30.42.0/24", + "104.30.43.0/24", + "104.30.44.0/24", + "104.30.45.0/24", + "104.30.46.0/24", + "104.30.47.0/24", + "104.30.48.0/24", + "104.30.49.0/24", + "104.30.50.0/24", + "104.30.51.0/24", + "104.30.52.0/24", + "104.30.53.0/24", + "104.30.54.0/24", + "104.30.55.0/24", + "104.30.56.0/24", + "104.30.57.0/24", + "104.30.58.0/24", + "104.30.59.0/24", + "104.30.60.0/24", + "104.30.61.0/24", + "104.30.62.0/24", + "104.30.63.0/24", + "104.30.64.0/24", + "104.30.65.0/24", + "104.30.66.0/24", + "104.30.67.0/24", + "104.30.68.0/24", + "104.30.69.0/24", + "104.30.70.0/24", + "104.30.71.0/24", + "104.30.72.0/24", + "104.30.73.0/24", + "104.30.74.0/24", + "104.30.75.0/24", + "104.30.76.0/24", + "104.30.77.0/24", + "104.30.78.0/24", + "104.30.79.0/24", + "104.30.80.0/24", + "104.30.81.0/24", + "104.30.82.0/24", + "104.30.83.0/24", + "104.30.84.0/24", + "104.30.85.0/24", + "104.30.86.0/24", + "104.30.87.0/24", + "104.30.88.0/24", + "104.30.89.0/24", + "104.30.90.0/24", + "104.30.91.0/24", + "104.30.92.0/24", + "104.30.93.0/24", + "104.30.94.0/24", + "104.30.95.0/24", + "104.30.96.0/24", + "104.30.97.0/24", + "104.30.98.0/24", + "104.30.99.0/24", + "104.30.100.0/24", + "104.30.101.0/24", + "104.30.102.0/24", + "104.30.103.0/24", + "104.30.104.0/24", + "104.30.105.0/24", + "104.30.106.0/24", + "104.30.107.0/24", + "104.30.108.0/24", + "104.30.109.0/24", + "104.30.110.0/24", + "104.30.111.0/24", + "104.30.112.0/24", + "104.30.113.0/24", + "104.30.114.0/24", + "104.30.115.0/24", + "104.30.116.0/24", + "104.30.117.0/24", + "104.30.118.0/24", + "104.30.119.0/24", + "104.30.120.0/24", + "104.30.121.0/24", + "104.30.122.0/24", + "104.30.123.0/24", + "104.30.124.0/24", + "104.30.125.0/24", + "104.30.126.0/24", + "104.30.127.0/24", + "104.30.128.0/24", + "104.30.129.0/24", + "104.30.130.0/24", + "104.30.131.0/24", + "104.30.132.0/24", + "104.30.133.0/24", + "104.30.134.0/24", + "104.30.135.0/24", + "104.30.136.0/24", + "104.30.137.0/24", + "104.30.138.0/24", + "104.30.139.0/24", + "104.30.140.0/24", + "104.30.141.0/24", + "104.30.142.0/24", + "104.30.143.0/24", + "104.30.144.0/24", + "104.30.145.0/24", + "104.30.146.0/24", + "104.30.147.0/24", + "104.30.148.0/24", + "104.30.149.0/24", + "104.30.150.0/24", + "104.30.151.0/24", + "104.30.152.0/24", + "104.30.153.0/24", + "104.30.154.0/24", + "104.30.155.0/24", + "104.30.156.0/24", + "104.30.157.0/24", + "104.30.158.0/24", + "104.30.159.0/24", + "104.30.160.0/24", + "104.30.161.0/24", + "104.30.162.0/24", + "104.30.163.0/24", + "104.30.164.0/24", + "104.30.165.0/24", + "104.30.166.0/24", + "104.30.167.0/24", + "104.30.168.0/24", + "104.30.169.0/24", + "104.30.170.0/24", + "104.30.171.0/24", + "104.30.172.0/24", + "104.30.173.0/24", + "104.30.174.0/24", + "104.30.175.0/24", + "104.30.176.0/24", + "104.30.177.0/24", + "104.30.178.0/24", + "104.30.179.0/24", + "104.30.180.0/24", + "104.30.181.0/24", + "104.30.182.0/24", + "104.30.183.0/24", + "104.30.184.0/24", + "104.30.185.0/24", + "104.30.186.0/24", + "104.30.187.0/24", + "104.30.188.0/24", + "104.30.189.0/24", + "104.30.190.0/24", + "104.30.191.0/24", + "104.30.192.0/24", + "104.30.193.0/24", + "104.30.194.0/24", + "104.30.195.0/24", + "104.30.196.0/24", + "104.30.197.0/24", + "104.30.198.0/24", + "104.30.199.0/24", + "104.30.200.0/24", + "104.30.201.0/24", + "104.30.202.0/24", + "104.30.203.0/24", + "104.30.204.0/24", + "104.30.205.0/24", + "104.30.206.0/24", + "104.30.207.0/24", + "104.30.208.0/24", + "104.30.209.0/24", + "104.30.210.0/24", + "104.30.211.0/24", + "104.30.212.0/24", + "104.30.213.0/24", + "104.30.214.0/24", + "104.30.215.0/24", + "104.30.216.0/24", + "104.30.217.0/24", + "104.30.218.0/24", + "104.30.219.0/24", + "104.30.220.0/24", + "104.30.221.0/24", + "104.30.222.0/24", + "104.30.223.0/24", + "104.30.224.0/24", + "104.30.225.0/24", + "104.30.226.0/24", + "104.30.227.0/24", + "104.30.228.0/24", + "104.30.229.0/24", + "104.30.230.0/24", + "104.30.231.0/24", + "104.30.232.0/24", + "104.30.233.0/24", + "104.30.234.0/24", + "104.30.235.0/24", + "104.30.236.0/24", + "104.30.237.0/24", + "104.30.238.0/24", + "104.30.239.0/24", + "104.30.240.0/24", + "104.30.241.0/24", + "104.30.242.0/24", + "104.30.243.0/24", + "104.30.244.0/24", + "104.30.245.0/24", + "104.30.246.0/24", + "104.30.247.0/24", + "104.30.248.0/24", + "104.30.249.0/24", + "104.30.250.0/24", + "104.30.251.0/24", + "104.30.252.0/24", + "104.30.253.0/24", + "104.30.254.0/24", + "104.30.255.0/24", + "104.31.0.0/24", + "104.31.1.0/24", + "104.31.2.0/24", + "104.31.3.0/24", + "104.31.4.0/24", + "104.31.5.0/24", + "104.31.6.0/24", + "104.31.7.0/24", + "104.31.8.0/24", + "104.31.9.0/24", + "104.31.10.0/24", + "104.31.11.0/24", + "104.31.12.0/24", + "104.31.13.0/24", + "104.31.14.0/24", + "104.31.15.0/24", + "104.31.16.0/24", + "104.31.17.0/24", + "104.31.18.0/24", + "104.31.19.0/24", + "104.31.20.0/24", + "104.31.21.0/24", + "104.31.22.0/24", + "104.31.23.0/24", + "104.31.24.0/24", + "104.31.25.0/24", + "104.31.26.0/24", + "104.31.27.0/24", + "104.31.28.0/24", + "104.31.29.0/24", + "104.31.30.0/24", + "104.31.31.0/24", + "104.31.32.0/24", + "104.31.33.0/24", + "104.31.34.0/24", + "104.31.35.0/24", + "104.31.36.0/24", + "104.31.37.0/24", + "104.31.38.0/24", + "104.31.39.0/24", + "104.31.40.0/24", + "104.31.41.0/24", + "104.31.42.0/24", + "104.31.43.0/24", + "104.31.44.0/24", + "104.31.45.0/24", + "104.31.46.0/24", + "104.31.47.0/24", + "104.31.48.0/24", + "104.31.49.0/24", + "104.31.50.0/24", + "104.31.51.0/24", + "104.31.52.0/24", + "104.31.53.0/24", + "104.31.54.0/24", + "104.31.55.0/24", + "104.31.56.0/24", + "104.31.57.0/24", + "104.31.58.0/24", + "104.31.59.0/24", + "104.31.60.0/24", + "104.31.61.0/24", + "104.31.62.0/24", + "104.31.63.0/24", + "104.31.64.0/24", + "104.31.65.0/24", + "104.31.66.0/24", + "104.31.67.0/24", + "104.31.68.0/24", + "104.31.69.0/24", + "104.31.70.0/24", + "104.31.71.0/24", + "104.31.72.0/24", + "104.31.73.0/24", + "104.31.74.0/24", + "104.31.75.0/24", + "104.31.76.0/24", + "104.31.77.0/24", + "104.31.78.0/24", + "104.31.79.0/24", + "104.31.80.0/24", + "104.31.81.0/24", + "104.31.82.0/24", + "104.31.83.0/24", + "104.31.84.0/24", + "104.31.85.0/24", + "104.31.86.0/24", + "104.31.87.0/24", + "104.31.88.0/24", + "104.31.89.0/24", + "104.31.90.0/24", + "104.31.91.0/24", + "104.31.92.0/24", + "104.31.93.0/24", + "104.31.94.0/24", + "104.31.95.0/24", + "104.31.96.0/24", + "104.31.97.0/24", + "104.31.98.0/24", + "104.31.99.0/24", + "104.31.100.0/24", + "104.31.101.0/24", + "104.31.102.0/24", + "104.31.103.0/24", + "104.31.104.0/24", + "104.31.105.0/24", + "104.31.106.0/24", + "104.31.107.0/24", + "104.31.108.0/24", + "104.31.109.0/24", + "104.31.110.0/24", + "104.31.111.0/24", + "104.31.112.0/24", + "104.31.113.0/24", + "104.31.114.0/24", + "104.31.115.0/24", + "104.31.116.0/24", + "104.31.117.0/24", + "104.31.118.0/24", + "104.31.119.0/24", + "104.31.120.0/24", + "104.31.121.0/24", + "104.31.122.0/24", + "104.31.123.0/24", + "104.31.124.0/24", + "104.31.125.0/24", + "104.31.126.0/24", + "104.31.127.0/24", + "104.31.128.0/24", + "104.31.129.0/24", + "104.31.130.0/24", + "104.31.131.0/24", + "104.31.132.0/24", + "104.31.133.0/24", + "104.31.134.0/24", + "104.31.135.0/24", + "104.31.136.0/24", + "104.31.137.0/24", + "104.31.138.0/24", + "104.31.139.0/24", + "104.31.140.0/24", + "104.31.141.0/24", + "104.31.142.0/24", + "104.31.143.0/24", + "104.31.144.0/24", + "104.31.145.0/24", + "104.31.146.0/24", + "104.31.147.0/24", + "104.31.148.0/24", + "104.31.149.0/24", + "104.31.150.0/24", + "104.31.151.0/24", + "104.31.152.0/24", + "104.31.153.0/24", + "104.31.154.0/24", + "104.31.155.0/24", + "104.31.156.0/24", + "104.31.157.0/24", + "104.31.158.0/24", + "104.31.159.0/24", + "104.31.160.0/24", + "104.31.161.0/24", + "104.31.162.0/24", + "104.31.163.0/24", + "104.31.164.0/24", + "104.31.165.0/24", + "104.31.166.0/24", + "104.31.167.0/24", + "104.31.168.0/24", + "104.31.169.0/24", + "104.31.170.0/24", + "104.31.171.0/24", + "104.31.172.0/24", + "104.31.173.0/24", + "104.31.174.0/24", + "104.31.175.0/24", + "104.31.176.0/24", + "104.31.177.0/24", + "104.31.178.0/24", + "104.31.179.0/24", + "104.31.180.0/24", + "104.31.181.0/24", + "104.31.182.0/24", + "104.31.183.0/24", + "104.31.184.0/24", + "104.31.185.0/24", + "104.31.186.0/24", + "104.31.187.0/24", + "104.31.188.0/24", + "104.31.189.0/24", + "104.31.190.0/24", + "104.31.191.0/24", + "104.31.192.0/24", + "104.31.193.0/24", + "104.31.194.0/24", + "104.31.195.0/24", + "104.31.196.0/24", + "104.31.197.0/24", + "104.31.198.0/24", + "104.31.199.0/24", + "104.31.200.0/24", + "104.31.201.0/24", + "104.31.202.0/24", + "104.31.203.0/24", + "104.31.204.0/24", + "104.31.205.0/24", + "104.31.206.0/24", + "104.31.207.0/24", + "104.31.208.0/24", + "104.31.209.0/24", + "104.31.210.0/24", + "104.31.211.0/24", + "104.31.212.0/24", + "104.31.213.0/24", + "104.31.214.0/24", + "104.31.215.0/24", + "104.31.216.0/24", + "104.31.217.0/24", + "104.31.218.0/24", + "104.31.219.0/24", + "104.31.220.0/24", + "104.31.221.0/24", + "104.31.222.0/24", + "104.31.223.0/24", + "104.31.224.0/24", + "104.31.225.0/24", + "104.31.226.0/24", + "104.31.227.0/24", + "104.31.228.0/24", + "104.31.229.0/24", + "104.31.230.0/24", + "104.31.231.0/24", + "104.31.232.0/24", + "104.31.233.0/24", + "104.31.234.0/24", + "104.31.235.0/24", + "104.31.236.0/24", + "104.31.237.0/24", + "104.31.238.0/24", + "104.31.239.0/24", + "104.31.240.0/24", + "104.31.241.0/24", + "104.31.242.0/24", + "104.31.243.0/24", + "104.31.244.0/24", + "104.31.245.0/24", + "104.31.246.0/24", + "104.31.247.0/24", + "104.31.248.0/24", + "104.31.249.0/24", + "104.31.250.0/24", + "104.31.251.0/24", + "104.31.252.0/24", + "104.31.253.0/24", + "104.31.254.0/24", + "104.31.255.0/24", + "104.18.10.128/24", + "108.162.192.0/24", + "108.162.193.0/24", + "108.162.194.0/24", + "108.162.195.0/24", + "108.162.196.0/24", + "108.162.197.0/24", + "108.162.198.0/24", + "108.162.199.0/24", + "108.162.200.0/24", + "108.162.201.0/24", + "108.162.202.0/24", + "108.162.203.0/24", + "108.162.204.0/24", + "108.162.205.0/24", + "108.162.206.0/24", + "108.162.207.0/24", + "108.162.210.0/24", + "108.162.211.0/24", + "108.162.212.0/24", + "108.162.213.0/24", + "108.162.216.0/24", + "108.162.217.0/24", + "108.162.218.0/24", + "108.162.226.0/24", + "108.162.227.0/24", + "108.162.235.0/24", + "108.162.236.0/24", + "108.162.237.0/24", + "108.162.238.0/24", + "108.162.239.0/24", + "108.162.240.0/24", + "108.162.241.0/24", + "108.162.242.0/24", + "108.162.243.0/24", + "108.162.244.0/24", + "108.162.245.0/24", + "108.162.246.0/24", + "108.162.247.0/24", + "108.162.248.0/24", + "108.162.249.0/24", + "108.162.250.0/24", + "108.162.252.0/24", + "108.162.253.0/24", + "141.101.65.0/24", + "141.101.66.0/24", + "141.101.67.0/24", + "141.101.68.0/24", + "141.101.69.0/24", + "141.101.70.0/24", + "141.101.71.0/24", + "141.101.72.0/24", + "141.101.73.0/24", + "141.101.74.0/24", + "141.101.75.0/24", + "141.101.76.0/24", + "141.101.77.0/24", + "141.101.82.0/24", + "141.101.83.0/24", + "141.101.84.0/24", + "141.101.85.0/24", + "141.101.86.0/24", + "141.101.87.0/24", + "141.101.90.0/24", + "141.101.92.0/24", + "141.101.93.0/24", + "141.101.94.0/24", + "141.101.95.0/24", + "141.101.96.0/24", + "141.101.97.0/24", + "141.101.98.0/24", + "141.101.99.0/24", + "141.101.100.0/24", + "141.101.108.0/24", + "141.101.109.0/24", + "141.101.110.0/24", + "141.101.112.0/24", + "141.101.113.0/24", + "141.101.114.0/24", + "141.101.115.0/24", + "141.101.116.0/24", + "141.101.117.0/24", + "141.101.118.0/24", + "141.101.119.0/24", + "141.101.120.0/24", + "141.101.121.0/24", + "141.101.122.0/24", + "141.101.123.0/24", + "141.101.124.0/24", + "141.101.125.0/24", + "141.101.126.0/24", + "141.101.127.0/24", + "162.158.0.0/24", + "162.158.1.0/24", + "162.158.2.0/24", + "162.158.3.0/24", + "162.158.4.0/24", + "162.158.5.0/24", + "162.158.8.0/24", + "162.158.9.0/24", + "162.158.10.0/24", + "162.158.11.0/24", + "162.158.12.0/24", + "162.158.13.0/24", + "162.158.14.0/24", + "162.158.15.0/24", + "162.158.16.0/24", + "162.158.17.0/24", + "162.158.18.0/24", + "162.158.19.0/24", + "162.158.20.0/24", + "162.158.21.0/24", + "162.158.22.0/24", + "162.158.23.0/24", + "162.158.24.0/24", + "162.158.25.0/24", + "162.158.26.0/24", + "162.158.27.0/24", + "162.158.28.0/24", + "162.158.29.0/24", + "162.158.30.0/24", + "162.158.31.0/24", + "162.158.32.0/24", + "162.158.33.0/24", + "162.158.34.0/24", + "162.158.35.0/24", + "162.158.36.0/24", + "162.158.37.0/24", + "162.158.38.0/24", + "162.158.39.0/24", + "162.158.40.0/24", + "162.158.41.0/24", + "162.158.42.0/24", + "162.158.43.0/24", + "162.158.44.0/24", + "162.158.45.0/24", + "162.158.46.0/24", + "162.158.47.0/24", + "162.158.48.0/24", + "162.158.51.0/24", + "162.158.52.0/24", + "162.158.53.0/24", + "162.158.54.0/24", + "162.158.55.0/24", + "162.158.56.0/24", + "162.158.57.0/24", + "162.158.58.0/24", + "162.158.59.0/24", + "162.158.60.0/24", + "162.158.61.0/24", + "162.158.62.0/24", + "162.158.63.0/24", + "162.158.72.0/24", + "162.158.73.0/24", + "162.158.74.0/24", + "162.158.75.0/24", + "162.158.76.0/24", + "162.158.77.0/24", + "162.158.78.0/24", + "162.158.79.0/24", + "162.158.80.0/24", + "162.158.81.0/24", + "162.158.82.0/24", + "162.158.84.0/24", + "162.158.85.0/24", + "162.158.86.0/24", + "162.158.87.0/24", + "162.158.88.0/24", + "162.158.89.0/24", + "162.158.90.0/24", + "162.158.91.0/24", + "162.158.92.0/24", + "162.158.93.0/24", + "162.158.94.0/24", + "162.158.95.0/24", + "162.158.96.0/24", + "162.158.97.0/24", + "162.158.98.0/24", + "162.158.99.0/24", + "162.158.100.0/24", + "162.158.101.0/24", + "162.158.102.0/24", + "162.158.103.0/24", + "162.158.104.0/24", + "162.158.105.0/24", + "162.158.106.0/24", + "162.158.107.0/24", + "162.158.108.0/24", + "162.158.109.0/24", + "162.158.110.0/24", + "162.158.111.0/24", + "162.158.112.0/24", + "162.158.113.0/24", + "162.158.114.0/24", + "162.158.116.0/24", + "162.158.117.0/24", + "162.158.118.0/24", + "162.158.119.0/24", + "162.158.124.0/24", + "162.158.125.0/24", + "162.158.126.0/24", + "162.158.127.0/24", + "162.158.128.0/24", + "162.158.129.0/24", + "162.158.130.0/24", + "162.158.131.0/24", + "162.158.132.0/24", + "162.158.133.0/24", + "162.158.134.0/24", + "162.158.135.0/24", + "162.158.136.0/24", + "162.158.137.0/24", + "162.158.138.0/24", + "162.158.139.0/24", + "162.158.140.0/24", + "162.158.141.0/24", + "162.158.142.0/24", + "162.158.143.0/24", + "162.158.144.0/24", + "162.158.145.0/24", + "162.158.146.0/24", + "162.158.147.0/24", + "162.158.148.0/24", + "162.158.149.0/24", + "162.158.150.0/24", + "162.158.151.0/24", + "162.158.152.0/24", + "162.158.153.0/24", + "162.158.154.0/24", + "162.158.155.0/24", + "162.158.156.0/24", + "162.158.157.0/24", + "162.158.158.0/24", + "162.158.159.0/24", + "162.158.160.0/24", + "162.158.161.0/24", + "162.158.162.0/24", + "162.158.163.0/24", + "162.158.164.0/24", + "162.158.165.0/24", + "162.158.166.0/24", + "162.158.167.0/24", + "162.158.168.0/24", + "162.158.169.0/24", + "162.158.170.0/24", + "162.158.171.0/24", + "162.158.172.0/24", + "162.158.173.0/24", + "162.158.174.0/24", + "162.158.175.0/24", + "162.158.176.0/24", + "162.158.178.0/24", + "162.158.179.0/24", + "162.158.180.0/24", + "162.158.181.0/24", + "162.158.182.0/24", + "162.158.183.0/24", + "162.158.184.0/24", + "162.158.185.0/24", + "162.158.186.0/24", + "162.158.187.0/24", + "162.158.188.0/24", + "162.158.189.0/24", + "162.158.190.0/24", + "162.158.191.0/24", + "162.158.192.0/24", + "162.158.193.0/24", + "162.158.194.0/24", + "162.158.195.0/24", + "162.158.196.0/24", + "162.158.198.0/24", + "162.158.199.0/24", + "162.158.200.0/24", + "162.158.201.0/24", + "162.158.202.0/24", + "162.158.203.0/24", + "162.158.204.0/24", + "162.158.205.0/24", + "162.158.206.0/24", + "162.158.207.0/24", + "162.158.208.0/24", + "162.158.209.0/24", + "162.158.210.0/24", + "162.158.211.0/24", + "162.158.212.0/24", + "162.158.214.0/24", + "162.158.215.0/24", + "162.158.216.0/24", + "162.158.217.0/24", + "162.158.218.0/24", + "162.158.219.0/24", + "162.158.220.0/24", + "162.158.221.0/24", + "162.158.222.0/24", + "162.158.223.0/24", + "162.158.224.0/24", + "162.158.225.0/24", + "162.158.226.0/24", + "162.158.227.0/24", + "162.158.228.0/24", + "162.158.232.0/24", + "162.158.233.0/24", + "162.158.234.0/24", + "162.158.235.0/24", + "162.158.236.0/24", + "162.158.237.0/24", + "162.158.238.0/24", + "162.158.239.0/24", + "162.158.240.0/24", + "162.158.241.0/24", + "162.158.242.0/24", + "162.158.243.0/24", + "162.158.244.0/24", + "162.158.245.0/24", + "162.158.248.0/24", + "162.158.249.0/24", + "162.158.250.0/24", + "162.158.251.0/24", + "162.158.253.0/24", + "162.158.254.0/24", + "162.158.255.0/24", + "162.159.0.0/24", + "162.159.1.0/24", + "162.159.2.0/24", + "162.159.3.0/24", + "162.159.4.0/24", + "162.159.5.0/24", + "162.159.6.0/24", + "162.159.7.0/24", + "162.159.8.0/24", + "162.159.9.0/24", + "162.159.10.0/24", + "162.159.11.0/24", + "162.159.12.0/24", + "162.159.13.0/24", + "162.159.14.0/24", + "162.159.15.0/24", + "162.159.16.0/24", + "162.159.17.0/24", + "162.159.18.0/24", + "162.159.19.0/24", + "162.159.20.0/24", + "162.159.21.0/24", + "162.159.22.0/24", + "162.159.23.0/24", + "162.159.24.0/24", + "162.159.25.0/24", + "162.159.26.0/24", + "162.159.27.0/24", + "162.159.28.0/24", + "162.159.29.0/24", + "162.159.30.0/24", + "162.159.31.0/24", + "162.159.32.0/24", + "162.159.33.0/24", + "162.159.34.0/24", + "162.159.35.0/24", + "162.159.36.0/24", + "162.159.37.0/24", + "162.159.38.0/24", + "162.159.39.0/24", + "162.159.40.0/24", + "162.159.41.0/24", + "162.159.42.0/24", + "162.159.43.0/24", + "162.159.44.0/24", + "162.159.45.0/24", + "162.159.46.0/24", + "162.159.47.0/24", + "162.159.48.0/24", + "162.159.49.0/24", + "162.159.50.0/24", + "162.159.51.0/24", + "162.159.52.0/24", + "162.159.53.0/24", + "162.159.54.0/24", + "162.159.55.0/24", + "162.159.56.0/24", + "162.159.57.0/24", + "162.159.58.0/24", + "162.159.59.0/24", + "162.159.60.0/24", + "162.159.61.0/24", + "162.159.62.0/24", + "162.159.63.0/24", + "162.159.64.0/24", + "162.159.65.0/24", + "162.159.66.0/24", + "162.159.67.0/24", + "162.159.68.0/24", + "162.159.69.0/24", + "162.159.70.0/24", + "162.159.71.0/24", + "162.159.72.0/24", + "162.159.73.0/24", + "162.159.74.0/24", + "162.159.75.0/24", + "162.159.76.0/24", + "162.159.77.0/24", + "162.159.78.0/24", + "162.159.79.0/24", + "162.159.128.0/24", + "162.159.129.0/24", + "162.159.130.0/24", + "162.159.131.0/24", + "162.159.132.0/24", + "162.159.133.0/24", + "162.159.134.0/24", + "162.159.135.0/24", + "162.159.136.0/24", + "162.159.137.0/24", + "162.159.138.0/24", + "162.159.139.0/24", + "162.159.140.0/24", + "162.159.141.0/24", + "162.159.142.0/24", + "162.159.143.0/24", + "162.159.144.0/24", + "162.159.145.0/24", + "162.159.146.0/24", + "162.159.147.0/24", + "162.159.148.0/24", + "162.159.149.0/24", + "162.159.150.0/24", + "162.159.151.0/24", + "162.159.152.0/24", + "162.159.153.0/24", + "162.159.154.0/24", + "162.159.155.0/24", + "162.159.156.0/24", + "162.159.157.0/24", + "162.159.158.0/24", + "162.159.159.0/24", + "162.159.160.0/24", + "162.159.161.0/24", + "162.159.162.0/24", + "162.159.163.0/24", + "162.159.164.0/24", + "162.159.165.0/24", + "162.159.166.0/24", + "162.159.167.0/24", + "162.159.168.0/24", + "162.159.169.0/24", + "162.159.170.0/24", + "162.159.171.0/24", + "162.159.172.0/24", + "162.159.173.0/24", + "162.159.174.0/24", + "162.159.175.0/24", + "162.159.176.0/24", + "162.159.177.0/24", + "162.159.178.0/24", + "162.159.179.0/24", + "162.159.180.0/24", + "162.159.181.0/24", + "162.159.182.0/24", + "162.159.183.0/24", + "162.159.184.0/24", + "162.159.185.0/24", + "162.159.186.0/24", + "162.159.187.0/24", + "162.159.188.0/24", + "162.159.189.0/24", + "162.159.190.0/24", + "162.159.191.0/24", + "162.159.192.0/24", + "162.159.193.0/24", + "162.159.194.0/24", + "162.159.195.0/24", + "162.159.196.0/24", + "162.159.197.0/24", + "162.159.198.0/24", + "162.159.199.0/24", + "162.159.200.0/24", + "162.159.201.0/24", + "162.159.202.0/24", + "162.159.203.0/24", + "162.159.204.0/24", + "162.159.205.0/24", + "162.159.206.0/24", + "162.159.207.0/24", + "162.159.208.0/24", + "162.159.209.0/24", + "162.159.210.0/24", + "162.159.211.0/24", + "162.159.212.0/24", + "162.159.213.0/24", + "162.159.214.0/24", + "162.159.215.0/24", + "162.159.216.0/24", + "162.159.217.0/24", + "162.159.218.0/24", + "162.159.219.0/24", + "162.159.220.0/24", + "162.159.221.0/24", + "162.159.222.0/24", + "162.159.223.0/24", + "162.159.224.0/24", + "162.159.225.0/24", + "162.159.226.0/24", + "162.159.227.0/24", + "162.159.228.0/24", + "162.159.229.0/24", + "162.159.230.0/24", + "162.159.231.0/24", + "162.159.232.0/24", + "162.159.233.0/24", + "162.159.234.0/24", + "162.159.235.0/24", + "162.159.236.0/24", + "162.159.237.0/24", + "162.159.238.0/24", + "162.159.239.0/24", + "162.159.240.0/24", + "162.159.241.0/24", + "162.159.242.0/24", + "162.159.243.0/24", + "162.159.244.0/24", + "162.159.245.0/24", + "162.159.246.0/24", + "162.159.247.0/24", + "162.159.248.0/24", + "162.159.249.0/24", + "162.159.250.0/24", + "162.159.251.0/24", + "162.159.252.0/24", + "162.159.253.0/24", + "162.159.254.0/24", + "162.159.255.0/24", + "162.251.82.0/24", + "172.64.0.0/24", + "172.64.1.0/24", + "172.64.2.0/24", + "172.64.3.0/24", + "172.64.4.0/24", + "172.64.5.0/24", + "172.64.6.0/24", + "172.64.7.0/24", + "172.64.8.0/24", + "172.64.9.0/24", + "172.64.10.0/24", + "172.64.11.0/24", + "172.64.12.0/24", + "172.64.13.0/24", + "172.64.14.0/24", + "172.64.15.0/24", + "172.64.16.0/24", + "172.64.17.0/24", + "172.64.18.0/24", + "172.64.19.0/24", + "172.64.20.0/24", + "172.64.21.0/24", + "172.64.22.0/24", + "172.64.23.0/24", + "172.64.24.0/24", + "172.64.25.0/24", + "172.64.26.0/24", + "172.64.27.0/24", + "172.64.28.0/24", + "172.64.29.0/24", + "172.64.30.0/24", + "172.64.31.0/24", + "172.64.32.0/24", + "172.64.33.0/24", + "172.64.34.0/24", + "172.64.35.0/24", + "172.64.36.0/24", + "172.64.37.0/24", + "172.64.38.0/24", + "172.64.39.0/24", + "172.64.40.0/24", + "172.64.41.0/24", + "172.64.42.0/24", + "172.64.43.0/24", + "172.64.44.0/24", + "172.64.45.0/24", + "172.64.46.0/24", + "172.64.47.0/24", + "172.64.48.0/24", + "172.64.49.0/24", + "172.64.50.0/24", + "172.64.51.0/24", + "172.64.52.0/24", + "172.64.53.0/24", + "172.64.54.0/24", + "172.64.55.0/24", + "172.64.56.0/24", + "172.64.57.0/24", + "172.64.58.0/24", + "172.64.59.0/24", + "172.64.60.0/24", + "172.64.61.0/24", + "172.64.62.0/24", + "172.64.63.0/24", + "172.64.64.0/24", + "172.64.65.0/24", + "172.64.66.0/24", + "172.64.67.0/24", + "172.64.68.0/24", + "172.64.69.0/24", + "172.64.70.0/24", + "172.64.71.0/24", + "172.64.72.0/24", + "172.64.73.0/24", + "172.64.74.0/24", + "172.64.75.0/24", + "172.64.76.0/24", + "172.64.77.0/24", + "172.64.78.0/24", + "172.64.79.0/24", + "172.64.80.0/24", + "172.64.81.0/24", + "172.64.82.0/24", + "172.64.83.0/24", + "172.64.84.0/24", + "172.64.85.0/24", + "172.64.86.0/24", + "172.64.87.0/24", + "172.64.88.0/24", + "172.64.89.0/24", + "172.64.90.0/24", + "172.64.91.0/24", + "172.64.92.0/24", + "172.64.93.0/24", + "172.64.94.0/24", + "172.64.95.0/24", + "172.64.96.0/24", + "172.64.97.0/24", + "172.64.98.0/24", + "172.64.99.0/24", + "172.64.100.0/24", + "172.64.101.0/24", + "172.64.102.0/24", + "172.64.103.0/24", + "172.64.104.0/24", + "172.64.105.0/24", + "172.64.106.0/24", + "172.64.107.0/24", + "172.64.108.0/24", + "172.64.109.0/24", + "172.64.110.0/24", + "172.64.111.0/24", + "172.64.112.0/24", + "172.64.113.0/24", + "172.64.114.0/24", + "172.64.115.0/24", + "172.64.116.0/24", + "172.64.117.0/24", + "172.64.118.0/24", + "172.64.119.0/24", + "172.64.120.0/24", + "172.64.121.0/24", + "172.64.122.0/24", + "172.64.123.0/24", + "172.64.124.0/24", + "172.64.125.0/24", + "172.64.126.0/24", + "172.64.127.0/24", + "172.64.128.0/24", + "172.64.129.0/24", + "172.64.130.0/24", + "172.64.131.0/24", + "172.64.132.0/24", + "172.64.133.0/24", + "172.64.134.0/24", + "172.64.135.0/24", + "172.64.136.0/24", + "172.64.137.0/24", + "172.64.138.0/24", + "172.64.139.0/24", + "172.64.140.0/24", + "172.64.141.0/24", + "172.64.142.0/24", + "172.64.143.0/24", + "172.64.144.0/24", + "172.64.145.0/24", + "172.64.146.0/24", + "172.64.147.0/24", + "172.64.148.0/24", + "172.64.149.0/24", + "172.64.150.0/24", + "172.64.151.0/24", + "172.64.152.0/24", + "172.64.153.0/24", + "172.64.154.0/24", + "172.64.155.0/24", + "172.64.156.0/24", + "172.64.157.0/24", + "172.64.158.0/24", + "172.64.159.0/24", + "172.64.160.0/24", + "172.64.161.0/24", + "172.64.162.0/24", + "172.64.163.0/24", + "172.64.164.0/24", + "172.64.165.0/24", + "172.64.166.0/24", + "172.64.167.0/24", + "172.64.168.0/24", + "172.64.169.0/24", + "172.64.170.0/24", + "172.64.171.0/24", + "172.64.172.0/24", + "172.64.173.0/24", + "172.64.174.0/24", + "172.64.175.0/24", + "172.64.176.0/24", + "172.64.177.0/24", + "172.64.178.0/24", + "172.64.179.0/24", + "172.64.180.0/24", + "172.64.181.0/24", + "172.64.182.0/24", + "172.64.183.0/24", + "172.64.184.0/24", + "172.64.185.0/24", + "172.64.186.0/24", + "172.64.187.0/24", + "172.64.188.0/24", + "172.64.189.0/24", + "172.64.190.0/24", + "172.64.191.0/24", + "172.64.192.0/24", + "172.64.193.0/24", + "172.64.194.0/24", + "172.64.195.0/24", + "172.64.196.0/24", + "172.64.197.0/24", + "172.64.198.0/24", + "172.64.199.0/24", + "172.64.200.0/24", + "172.64.201.0/24", + "172.64.202.0/24", + "172.64.203.0/24", + "172.64.204.0/24", + "172.64.205.0/24", + "172.64.206.0/24", + "172.64.207.0/24", + "172.64.208.0/24", + "172.64.209.0/24", + "172.64.210.0/24", + "172.64.211.0/24", + "172.64.212.0/24", + "172.64.213.0/24", + "172.64.214.0/24", + "172.64.215.0/24", + "172.64.216.0/24", + "172.64.217.0/24", + "172.64.218.0/24", + "172.64.219.0/24", + "172.64.220.0/24", + "172.64.221.0/24", + "172.64.222.0/24", + "172.64.223.0/24", + "172.64.224.0/24", + "172.64.225.0/24", + "172.64.226.0/24", + "172.64.227.0/24", + "172.64.228.0/24", + "172.64.229.0/24", + "172.64.230.0/24", + "172.64.231.0/24", + "172.64.232.0/24", + "172.64.233.0/24", + "172.64.234.0/24", + "172.64.235.0/24", + "172.64.236.0/24", + "172.64.237.0/24", + "172.64.238.0/24", + "172.64.239.0/24", + "172.64.240.0/24", + "172.64.241.0/24", + "172.64.242.0/24", + "172.64.243.0/24", + "172.64.244.0/24", + "172.64.245.0/24", + "172.64.246.0/24", + "172.64.247.0/24", + "172.64.248.0/24", + "172.64.249.0/24", + "172.64.250.0/24", + "172.64.251.0/24", + "172.64.252.0/24", + "172.64.253.0/24", + "172.64.254.0/24", + "172.64.255.0/24", + "172.65.0.0/24", + "172.65.1.0/24", + "172.65.2.0/24", + "172.65.3.0/24", + "172.65.4.0/24", + "172.65.5.0/24", + "172.65.6.0/24", + "172.65.7.0/24", + "172.65.8.0/24", + "172.65.9.0/24", + "172.65.10.0/24", + "172.65.11.0/24", + "172.65.12.0/24", + "172.65.13.0/24", + "172.65.14.0/24", + "172.65.15.0/24", + "172.65.16.0/24", + "172.65.17.0/24", + "172.65.18.0/24", + "172.65.19.0/24", + "172.65.20.0/24", + "172.65.21.0/24", + "172.65.22.0/24", + "172.65.23.0/24", + "172.65.24.0/24", + "172.65.25.0/24", + "172.65.26.0/24", + "172.65.27.0/24", + "172.65.28.0/24", + "172.65.29.0/24", + "172.65.30.0/24", + "172.65.31.0/24", + "172.65.32.0/24", + "172.65.33.0/24", + "172.65.34.0/24", + "172.65.35.0/24", + "172.65.36.0/24", + "172.65.37.0/24", + "172.65.38.0/24", + "172.65.39.0/24", + "172.65.40.0/24", + "172.65.41.0/24", + "172.65.42.0/24", + "172.65.43.0/24", + "172.65.44.0/24", + "172.65.45.0/24", + "172.65.46.0/24", + "172.65.47.0/24", + "172.65.48.0/24", + "172.65.49.0/24", + "172.65.50.0/24", + "172.65.51.0/24", + "172.65.52.0/24", + "172.65.53.0/24", + "172.65.54.0/24", + "172.65.55.0/24", + "172.65.56.0/24", + "172.65.57.0/24", + "172.65.58.0/24", + "172.65.59.0/24", + "172.65.60.0/24", + "172.65.61.0/24", + "172.65.62.0/24", + "172.65.63.0/24", + "172.65.64.0/24", + "172.65.65.0/24", + "172.65.66.0/24", + "172.65.67.0/24", + "172.65.68.0/24", + "172.65.69.0/24", + "172.65.70.0/24", + "172.65.71.0/24", + "172.65.72.0/24", + "172.65.73.0/24", + "172.65.74.0/24", + "172.65.75.0/24", + "172.65.76.0/24", + "172.65.77.0/24", + "172.65.78.0/24", + "172.65.79.0/24", + "172.65.80.0/24", + "172.65.81.0/24", + "172.65.82.0/24", + "172.65.83.0/24", + "172.65.84.0/24", + "172.65.85.0/24", + "172.65.86.0/24", + "172.65.87.0/24", + "172.65.88.0/24", + "172.65.89.0/24", + "172.65.90.0/24", + "172.65.91.0/24", + "172.65.92.0/24", + "172.65.93.0/24", + "172.65.94.0/24", + "172.65.95.0/24", + "172.65.96.0/24", + "172.65.97.0/24", + "172.65.98.0/24", + "172.65.99.0/24", + "172.65.100.0/24", + "172.65.101.0/24", + "172.65.102.0/24", + "172.65.103.0/24", + "172.65.104.0/24", + "172.65.105.0/24", + "172.65.106.0/24", + "172.65.107.0/24", + "172.65.108.0/24", + "172.65.109.0/24", + "172.65.110.0/24", + "172.65.111.0/24", + "172.65.112.0/24", + "172.65.113.0/24", + "172.65.114.0/24", + "172.65.115.0/24", + "172.65.116.0/24", + "172.65.117.0/24", + "172.65.118.0/24", + "172.65.119.0/24", + "172.65.120.0/24", + "172.65.121.0/24", + "172.65.122.0/24", + "172.65.123.0/24", + "172.65.124.0/24", + "172.65.125.0/24", + "172.65.126.0/24", + "172.65.127.0/24", + "172.65.128.0/24", + "172.65.129.0/24", + "172.65.130.0/24", + "172.65.131.0/24", + "172.65.132.0/24", + "172.65.133.0/24", + "172.65.134.0/24", + "172.65.135.0/24", + "172.65.136.0/24", + "172.65.137.0/24", + "172.65.138.0/24", + "172.65.139.0/24", + "172.65.140.0/24", + "172.65.141.0/24", + "172.65.142.0/24", + "172.65.143.0/24", + "172.65.144.0/24", + "172.65.145.0/24", + "172.65.146.0/24", + "172.65.147.0/24", + "172.65.148.0/24", + "172.65.149.0/24", + "172.65.150.0/24", + "172.65.151.0/24", + "172.65.152.0/24", + "172.65.153.0/24", + "172.65.154.0/24", + "172.65.155.0/24", + "172.65.156.0/24", + "172.65.157.0/24", + "172.65.158.0/24", + "172.65.159.0/24", + "172.65.160.0/24", + "172.65.161.0/24", + "172.65.162.0/24", + "172.65.163.0/24", + "172.65.164.0/24", + "172.65.165.0/24", + "172.65.166.0/24", + "172.65.167.0/24", + "172.65.168.0/24", + "172.65.169.0/24", + "172.65.170.0/24", + "172.65.171.0/24", + "172.65.172.0/24", + "172.65.173.0/24", + "172.65.174.0/24", + "172.65.175.0/24", + "172.65.176.0/24", + "172.65.177.0/24", + "172.65.178.0/24", + "172.65.179.0/24", + "172.65.180.0/24", + "172.65.181.0/24", + "172.65.182.0/24", + "172.65.183.0/24", + "172.65.184.0/24", + "172.65.185.0/24", + "172.65.186.0/24", + "172.65.187.0/24", + "172.65.188.0/24", + "172.65.189.0/24", + "172.65.190.0/24", + "172.65.191.0/24", + "172.65.192.0/24", + "172.65.193.0/24", + "172.65.194.0/24", + "172.65.195.0/24", + "172.65.196.0/24", + "172.65.197.0/24", + "172.65.198.0/24", + "172.65.199.0/24", + "172.65.200.0/24", + "172.65.201.0/24", + "172.65.202.0/24", + "172.65.203.0/24", + "172.65.204.0/24", + "172.65.205.0/24", + "172.65.206.0/24", + "172.65.207.0/24", + "172.65.208.0/24", + "172.65.209.0/24", + "172.65.210.0/24", + "172.65.211.0/24", + "172.65.212.0/24", + "172.65.213.0/24", + "172.65.214.0/24", + "172.65.215.0/24", + "172.65.216.0/24", + "172.65.217.0/24", + "172.65.218.0/24", + "172.65.219.0/24", + "172.65.220.0/24", + "172.65.221.0/24", + "172.65.222.0/24", + "172.65.223.0/24", + "172.65.224.0/24", + "172.65.225.0/24", + "172.65.226.0/24", + "172.65.227.0/24", + "172.65.228.0/24", + "172.65.229.0/24", + "172.65.230.0/24", + "172.65.231.0/24", + "172.65.232.0/24", + "172.65.233.0/24", + "172.65.234.0/24", + "172.65.235.0/24", + "172.65.236.0/24", + "172.65.237.0/24", + "172.65.238.0/24", + "172.65.239.0/24", + "172.65.240.0/24", + "172.65.241.0/24", + "172.65.242.0/24", + "172.65.243.0/24", + "172.65.244.0/24", + "172.65.245.0/24", + "172.65.246.0/24", + "172.65.247.0/24", + "172.65.248.0/24", + "172.65.249.0/24", + "172.65.250.0/24", + "172.65.251.0/24", + "172.65.252.0/24", + "172.65.253.0/24", + "172.65.254.0/24", + "172.65.255.0/24", + "172.66.0.0/24", + "172.66.1.0/24", + "172.66.2.0/24", + "172.66.3.0/24", + "172.66.40.0/24", + "172.66.41.0/24", + "172.66.42.0/24", + "172.66.43.0/24", + "172.66.44.0/24", + "172.66.45.0/24", + "172.66.46.0/24", + "172.66.47.0/24", + "172.67.0.0/24", + "172.67.1.0/24", + "172.67.2.0/24", + "172.67.3.0/24", + "172.67.4.0/24", + "172.67.5.0/24", + "172.67.6.0/24", + "172.67.7.0/24", + "172.67.8.0/24", + "172.67.9.0/24", + "172.67.10.0/24", + "172.67.11.0/24", + "172.67.12.0/24", + "172.67.13.0/24", + "172.67.14.0/24", + "172.67.15.0/24", + "172.67.16.0/24", + "172.67.17.0/24", + "172.67.18.0/24", + "172.67.19.0/24", + "172.67.20.0/24", + "172.67.21.0/24", + "172.67.22.0/24", + "172.67.23.0/24", + "172.67.24.0/24", + "172.67.25.0/24", + "172.67.26.0/24", + "172.67.27.0/24", + "172.67.28.0/24", + "172.67.29.0/24", + "172.67.30.0/24", + "172.67.31.0/24", + "172.67.32.0/24", + "172.67.33.0/24", + "172.67.34.0/24", + "172.67.35.0/24", + "172.67.36.0/24", + "172.67.37.0/24", + "172.67.38.0/24", + "172.67.39.0/24", + "172.67.40.0/24", + "172.67.41.0/24", + "172.67.42.0/24", + "172.67.43.0/24", + "172.67.44.0/24", + "172.67.45.0/24", + "172.67.46.0/24", + "172.67.47.0/24", + "172.67.48.0/24", + "172.67.49.0/24", + "172.67.50.0/24", + "172.67.51.0/24", + "172.67.52.0/24", + "172.67.53.0/24", + "172.67.54.0/24", + "172.67.55.0/24", + "172.67.56.0/24", + "172.67.57.0/24", + "172.67.58.0/24", + "172.67.59.0/24", + "172.67.60.0/24", + "172.67.61.0/24", + "172.67.62.0/24", + "172.67.63.0/24", + "172.67.64.0/24", + "172.67.65.0/24", + "172.67.66.0/24", + "172.67.67.0/24", + "172.67.68.0/24", + "172.67.69.0/24", + "172.67.70.0/24", + "172.67.71.0/24", + "172.67.72.0/24", + "172.67.73.0/24", + "172.67.74.0/24", + "172.67.75.0/24", + "172.67.76.0/24", + "172.67.77.0/24", + "172.67.78.0/24", + "172.67.79.0/24", + "172.67.80.0/24", + "172.67.81.0/24", + "172.67.82.0/24", + "172.67.83.0/24", + "172.67.84.0/24", + "172.67.85.0/24", + "172.67.86.0/24", + "172.67.87.0/24", + "172.67.88.0/24", + "172.67.89.0/24", + "172.67.90.0/24", + "172.67.91.0/24", + "172.67.92.0/24", + "172.67.93.0/24", + "172.67.94.0/24", + "172.67.95.0/24", + "172.67.96.0/24", + "172.67.97.0/24", + "172.67.98.0/24", + "172.67.99.0/24", + "172.67.100.0/24", + "172.67.101.0/24", + "172.67.102.0/24", + "172.67.103.0/24", + "172.67.104.0/24", + "172.67.105.0/24", + "172.67.106.0/24", + "172.67.107.0/24", + "172.67.108.0/24", + "172.67.109.0/24", + "172.67.110.0/24", + "172.67.111.0/24", + "172.67.112.0/24", + "172.67.113.0/24", + "172.67.114.0/24", + "172.67.115.0/24", + "172.67.116.0/24", + "172.67.117.0/24", + "172.67.118.0/24", + "172.67.119.0/24", + "172.67.120.0/24", + "172.67.121.0/24", + "172.67.122.0/24", + "172.67.123.0/24", + "172.67.124.0/24", + "172.67.125.0/24", + "172.67.126.0/24", + "172.67.127.0/24", + "172.67.128.0/24", + "172.67.129.0/24", + "172.67.130.0/24", + "172.67.131.0/24", + "172.67.132.0/24", + "172.67.133.0/24", + "172.67.134.0/24", + "172.67.135.0/24", + "172.67.136.0/24", + "172.67.137.0/24", + "172.67.138.0/24", + "172.67.139.0/24", + "172.67.140.0/24", + "172.67.141.0/24", + "172.67.142.0/24", + "172.67.143.0/24", + "172.67.144.0/24", + "172.67.145.0/24", + "172.67.146.0/24", + "172.67.147.0/24", + "172.67.148.0/24", + "172.67.149.0/24", + "172.67.150.0/24", + "172.67.151.0/24", + "172.67.152.0/24", + "172.67.153.0/24", + "172.67.154.0/24", + "172.67.155.0/24", + "172.67.156.0/24", + "172.67.157.0/24", + "172.67.158.0/24", + "172.67.159.0/24", + "172.67.160.0/24", + "172.67.161.0/24", + "172.67.162.0/24", + "172.67.163.0/24", + "172.67.164.0/24", + "172.67.165.0/24", + "172.67.166.0/24", + "172.67.167.0/24", + "172.67.168.0/24", + "172.67.169.0/24", + "172.67.170.0/24", + "172.67.171.0/24", + "172.67.172.0/24", + "172.67.173.0/24", + "172.67.174.0/24", + "172.67.175.0/24", + "172.67.176.0/24", + "172.67.177.0/24", + "172.67.178.0/24", + "172.67.179.0/24", + "172.67.180.0/24", + "172.67.181.0/24", + "172.67.182.0/24", + "172.67.183.0/24", + "172.67.184.0/24", + "172.67.185.0/24", + "172.67.186.0/24", + "172.67.187.0/24", + "172.67.188.0/24", + "172.67.189.0/24", + "172.67.190.0/24", + "172.67.191.0/24", + "172.67.192.0/24", + "172.67.193.0/24", + "172.67.194.0/24", + "172.67.195.0/24", + "172.67.196.0/24", + "172.67.197.0/24", + "172.67.198.0/24", + "172.67.199.0/24", + "172.67.200.0/24", + "172.67.201.0/24", + "172.67.202.0/24", + "172.67.203.0/24", + "172.67.204.0/24", + "172.67.205.0/24", + "172.67.206.0/24", + "172.67.207.0/24", + "172.67.208.0/24", + "172.67.209.0/24", + "172.67.210.0/24", + "172.67.211.0/24", + "172.67.212.0/24", + "172.67.213.0/24", + "172.67.214.0/24", + "172.67.215.0/24", + "172.67.216.0/24", + "172.67.217.0/24", + "172.67.218.0/24", + "172.67.219.0/24", + "172.67.220.0/24", + "172.67.221.0/24", + "172.67.222.0/24", + "172.67.223.0/24", + "172.67.224.0/24", + "172.67.225.0/24", + "172.67.226.0/24", + "172.67.227.0/24", + "172.67.228.0/24", + "172.67.229.0/24", + "172.67.230.0/24", + "172.67.231.0/24", + "172.67.232.0/24", + "172.67.233.0/24", + "172.67.234.0/24", + "172.67.235.0/24", + "172.67.236.0/24", + "172.67.237.0/24", + "172.67.238.0/24", + "172.67.239.0/24", + "172.67.240.0/24", + "172.67.241.0/24", + "172.67.242.0/24", + "172.67.243.0/24", + "172.67.244.0/24", + "172.67.245.0/24", + "172.67.246.0/24", + "172.67.247.0/24", + "172.67.248.0/24", + "172.67.249.0/24", + "172.67.250.0/24", + "172.67.251.0/24", + "172.67.252.0/24", + "172.67.253.0/24", + "172.67.254.0/24", + "172.67.255.0/24", + "172.68.0.0/24", + "172.68.1.0/24", + "172.68.2.0/24", + "172.68.3.0/24", + "172.68.4.0/24", + "172.68.5.0/24", + "172.68.6.0/24", + "172.68.7.0/24", + "172.68.8.0/24", + "172.68.9.0/24", + "172.68.10.0/24", + "172.68.11.0/24", + "172.68.12.0/24", + "172.68.13.0/24", + "172.68.14.0/24", + "172.68.15.0/24", + "172.68.16.0/24", + "172.68.17.0/24", + "172.68.18.0/24", + "172.68.19.0/24", + "172.68.20.0/24", + "172.68.21.0/24", + "172.68.22.0/24", + "172.68.23.0/24", + "172.68.24.0/24", + "172.68.25.0/24", + "172.68.26.0/24", + "172.68.27.0/24", + "172.68.28.0/24", + "172.68.29.0/24", + "172.68.30.0/24", + "172.68.31.0/24", + "172.68.32.0/24", + "172.68.33.0/24", + "172.68.34.0/24", + "172.68.35.0/24", + "172.68.36.0/24", + "172.68.37.0/24", + "172.68.38.0/24", + "172.68.39.0/24", + "172.68.40.0/24", + "172.68.41.0/24", + "172.68.42.0/24", + "172.68.43.0/24", + "172.68.45.0/24", + "172.68.46.0/24", + "172.68.47.0/24", + "172.68.48.0/24", + "172.68.49.0/24", + "172.68.50.0/24", + "172.68.51.0/24", + "172.68.52.0/24", + "172.68.53.0/24", + "172.68.54.0/24", + "172.68.55.0/24", + "172.68.56.0/24", + "172.68.57.0/24", + "172.68.58.0/24", + "172.68.59.0/24", + "172.68.60.0/24", + "172.68.61.0/24", + "172.68.62.0/24", + "172.68.63.0/24", + "172.68.64.0/24", + "172.68.65.0/24", + "172.68.66.0/24", + "172.68.67.0/24", + "172.68.68.0/24", + "172.68.69.0/24", + "172.68.70.0/24", + "172.68.71.0/24", + "172.68.72.0/24", + "172.68.73.0/24", + "172.68.74.0/24", + "172.68.75.0/24", + "172.68.76.0/24", + "172.68.77.0/24", + "172.68.78.0/24", + "172.68.79.0/24", + "172.68.80.0/24", + "172.68.81.0/24", + "172.68.83.0/24", + "172.68.84.0/24", + "172.68.85.0/24", + "172.68.86.0/24", + "172.68.87.0/24", + "172.68.88.0/24", + "172.68.89.0/24", + "172.68.90.0/24", + "172.68.91.0/24", + "172.68.92.0/24", + "172.68.93.0/24", + "172.68.94.0/24", + "172.68.95.0/24", + "172.68.96.0/24", + "172.68.97.0/24", + "172.68.98.0/24", + "172.68.99.0/24", + "172.68.100.0/24", + "172.68.101.0/24", + "172.68.102.0/24", + "172.68.103.0/24", + "172.68.104.0/24", + "172.68.105.0/24", + "172.68.106.0/24", + "172.68.107.0/24", + "172.68.108.0/24", + "172.68.109.0/24", + "172.68.110.0/24", + "172.68.111.0/24", + "172.68.112.0/24", + "172.68.113.0/24", + "172.68.114.0/24", + "172.68.115.0/24", + "172.68.116.0/24", + "172.68.117.0/24", + "172.68.118.0/24", + "172.68.119.0/24", + "172.68.120.0/24", + "172.68.121.0/24", + "172.68.123.0/24", + "172.68.124.0/24", + "172.68.125.0/24", + "172.68.126.0/24", + "172.68.127.0/24", + "172.68.128.0/24", + "172.68.129.0/24", + "172.68.130.0/24", + "172.68.131.0/24", + "172.68.132.0/24", + "172.68.133.0/24", + "172.68.134.0/24", + "172.68.135.0/24", + "172.68.136.0/24", + "172.68.137.0/24", + "172.68.138.0/24", + "172.68.139.0/24", + "172.68.140.0/24", + "172.68.141.0/24", + "172.68.142.0/24", + "172.68.143.0/24", + "172.68.144.0/24", + "172.68.145.0/24", + "172.68.146.0/24", + "172.68.147.0/24", + "172.68.148.0/24", + "172.68.149.0/24", + "172.68.150.0/24", + "172.68.151.0/24", + "172.68.152.0/24", + "172.68.153.0/24", + "172.68.154.0/24", + "172.68.155.0/24", + "172.68.161.0/24", + "172.68.162.0/24", + "172.68.163.0/24", + "172.68.164.0/24", + "172.68.165.0/24", + "172.68.166.0/24", + "172.68.167.0/24", + "172.68.168.0/24", + "172.68.169.0/24", + "172.68.170.0/24", + "172.68.171.0/24", + "172.68.172.0/24", + "172.68.173.0/24", + "172.68.174.0/24", + "172.68.175.0/24", + "172.68.176.0/24", + "172.68.177.0/24", + "172.68.179.0/24", + "172.68.180.0/24", + "172.68.181.0/24", + "172.68.182.0/24", + "172.68.183.0/24", + "172.68.184.0/24", + "172.68.185.0/24", + "172.68.186.0/24", + "172.68.187.0/24", + "172.68.188.0/24", + "172.68.189.0/24", + "172.68.190.0/24", + "172.68.191.0/24", + "172.68.196.0/24", + "172.68.197.0/24", + "172.68.198.0/24", + "172.68.199.0/24", + "172.68.200.0/24", + "172.68.201.0/24", + "172.68.202.0/24", + "172.68.203.0/24", + "172.68.204.0/24", + "172.68.205.0/24", + "172.68.206.0/24", + "172.68.207.0/24", + "172.68.208.0/24", + "172.68.209.0/24", + "172.68.210.0/24", + "172.68.211.0/24", + "172.68.212.0/24", + "172.68.213.0/24", + "172.68.214.0/24", + "172.68.215.0/24", + "172.68.217.0/24", + "172.68.218.0/24", + "172.68.219.0/24", + "172.68.220.0/24", + "172.68.221.0/24", + "172.68.222.0/24", + "172.68.223.0/24", + "172.68.224.0/24", + "172.68.225.0/24", + "172.68.226.0/24", + "172.68.227.0/24", + "172.68.228.0/24", + "172.68.229.0/24", + "172.68.230.0/24", + "172.68.231.0/24", + "172.68.232.0/24", + "172.68.233.0/24", + "172.68.234.0/24", + "172.68.235.0/24", + "172.68.236.0/24", + "172.68.237.0/24", + "172.68.238.0/24", + "172.68.239.0/24", + "172.68.240.0/24", + "172.68.241.0/24", + "172.68.242.0/24", + "172.68.243.0/24", + "172.68.244.0/24", + "172.68.245.0/24", + "172.68.246.0/24", + "172.68.247.0/24", + "172.68.248.0/24", + "172.68.249.0/24", + "172.68.250.0/24", + "172.68.251.0/24", + "172.68.252.0/24", + "172.68.253.0/24", + "172.68.255.0/24", + "172.69.0.0/24", + "172.69.1.0/24", + "172.69.2.0/24", + "172.69.3.0/24", + "172.69.4.0/24", + "172.69.5.0/24", + "172.69.6.0/24", + "172.69.7.0/24", + "172.69.8.0/24", + "172.69.9.0/24", + "172.69.10.0/24", + "172.69.11.0/24", + "172.69.12.0/24", + "172.69.13.0/24", + "172.69.14.0/24", + "172.69.15.0/24", + "172.69.16.0/24", + "172.69.18.0/24", + "172.69.19.0/24", + "172.69.20.0/24", + "172.69.21.0/24", + "172.69.22.0/24", + "172.69.23.0/24", + "172.69.32.0/24", + "172.69.33.0/24", + "172.69.34.0/24", + "172.69.35.0/24", + "172.69.36.0/24", + "172.69.37.0/24", + "172.69.38.0/24", + "172.69.39.0/24", + "172.69.40.0/24", + "172.69.41.0/24", + "172.69.42.0/24", + "172.69.43.0/24", + "172.69.44.0/24", + "172.69.45.0/24", + "172.69.46.0/24", + "172.69.47.0/24", + "172.69.48.0/24", + "172.69.52.0/24", + "172.69.53.0/24", + "172.69.54.0/24", + "172.69.55.0/24", + "172.69.60.0/24", + "172.69.61.0/24", + "172.69.62.0/24", + "172.69.63.0/24", + "172.69.64.0/24", + "172.69.65.0/24", + "172.69.66.0/24", + "172.69.67.0/24", + "172.69.68.0/24", + "172.69.69.0/24", + "172.69.70.0/24", + "172.69.71.0/24", + "172.69.72.0/24", + "172.69.73.0/24", + "172.69.74.0/24", + "172.69.75.0/24", + "172.69.76.0/24", + "172.69.77.0/24", + "172.69.78.0/24", + "172.69.79.0/24", + "172.69.80.0/24", + "172.69.81.0/24", + "172.69.82.0/24", + "172.69.83.0/24", + "172.69.84.0/24", + "172.69.85.0/24", + "172.69.86.0/24", + "172.69.87.0/24", + "172.69.88.0/24", + "172.69.89.0/24", + "172.69.90.0/24", + "172.69.91.0/24", + "172.69.92.0/24", + "172.69.93.0/24", + "172.69.94.0/24", + "172.69.95.0/24", + "172.69.96.0/24", + "172.69.97.0/24", + "172.69.100.0/24", + "172.69.101.0/24", + "172.69.102.0/24", + "172.69.103.0/24", + "172.69.105.0/24", + "172.69.106.0/24", + "172.69.107.0/24", + "172.69.108.0/24", + "172.69.109.0/24", + "172.69.110.0/24", + "172.69.111.0/24", + "172.69.112.0/24", + "172.69.113.0/24", + "172.69.114.0/24", + "172.69.115.0/24", + "172.69.116.0/24", + "172.69.117.0/24", + "172.69.118.0/24", + "172.69.119.0/24", + "172.69.124.0/24", + "172.69.125.0/24", + "172.69.126.0/24", + "172.69.127.0/24", + "172.69.128.0/24", + "172.69.129.0/24", + "172.69.130.0/24", + "172.69.131.0/24", + "172.69.132.0/24", + "172.69.133.0/24", + "172.69.134.0/24", + "172.69.135.0/24", + "172.69.136.0/24", + "172.69.137.0/24", + "172.69.138.0/24", + "172.69.139.0/24", + "172.69.140.0/24", + "172.69.141.0/24", + "172.69.142.0/24", + "172.69.143.0/24", + "172.69.144.0/24", + "172.69.145.0/24", + "172.69.146.0/24", + "172.69.147.0/24", + "172.69.148.0/24", + "172.69.149.0/24", + "172.69.150.0/24", + "172.69.151.0/24", + "172.69.156.0/24", + "172.69.157.0/24", + "172.69.158.0/24", + "172.69.159.0/24", + "172.69.160.0/24", + "172.69.161.0/24", + "172.69.162.0/24", + "172.69.163.0/24", + "172.69.164.0/24", + "172.69.165.0/24", + "172.69.166.0/24", + "172.69.167.0/24", + "172.69.168.0/24", + "172.69.169.0/24", + "172.69.170.0/24", + "172.69.171.0/24", + "172.69.172.0/24", + "172.69.173.0/24", + "172.69.174.0/24", + "172.69.175.0/24", + "172.69.180.0/24", + "172.69.181.0/24", + "172.69.182.0/24", + "172.69.183.0/24", + "172.69.184.0/24", + "172.69.185.0/24", + "172.69.186.0/24", + "172.69.187.0/24", + "172.69.188.0/24", + "172.69.189.0/24", + "172.69.190.0/24", + "172.69.191.0/24", + "172.69.192.0/24", + "172.69.193.0/24", + "172.69.194.0/24", + "172.69.195.0/24", + "172.69.196.0/24", + "172.69.197.0/24", + "172.69.198.0/24", + "172.69.199.0/24", + "172.69.200.0/24", + "172.69.201.0/24", + "172.69.202.0/24", + "172.69.203.0/24", + "172.69.204.0/24", + "172.69.205.0/24", + "172.69.206.0/24", + "172.69.207.0/24", + "172.69.208.0/24", + "172.69.210.0/24", + "172.69.211.0/24", + "172.69.212.0/24", + "172.69.216.0/24", + "172.69.217.0/24", + "172.69.218.0/24", + "172.69.219.0/24", + "172.69.220.0/24", + "172.69.221.0/24", + "172.69.224.0/24", + "172.69.225.0/24", + "172.69.226.0/24", + "172.69.227.0/24", + "172.69.228.0/24", + "172.69.229.0/24", + "172.69.230.0/24", + "172.69.231.0/24", + "172.69.232.0/24", + "172.69.233.0/24", + "172.69.234.0/24", + "172.69.235.0/24", + "172.69.236.0/24", + "172.69.237.0/24", + "172.69.238.0/24", + "172.69.239.0/24", + "172.69.241.0/24", + "172.69.242.0/24", + "172.69.244.0/24", + "172.69.245.0/24", + "172.69.246.0/24", + "172.69.247.0/24", + "172.69.248.0/24", + "172.69.250.0/24", + "172.69.251.0/24", + "172.69.252.0/24", + "172.69.253.0/24", + "172.69.254.0/24", + "172.69.255.0/24", + "172.70.32.0/24", + "172.70.33.0/24", + "172.70.34.0/24", + "172.70.35.0/24", + "172.70.36.0/24", + "172.70.37.0/24", + "172.70.38.0/24", + "172.70.39.0/24", + "172.70.40.0/24", + "172.70.41.0/24", + "172.70.42.0/24", + "172.70.43.0/24", + "172.70.44.0/24", + "172.70.45.0/24", + "172.70.46.0/24", + "172.70.47.0/24", + "172.70.48.0/24", + "172.70.49.0/24", + "172.70.51.0/24", + "172.70.52.0/24", + "172.70.53.0/24", + "172.70.54.0/24", + "172.70.55.0/24", + "172.70.56.0/24", + "172.70.57.0/24", + "172.70.58.0/24", + "172.70.59.0/24", + "172.70.60.0/24", + "172.70.61.0/24", + "172.70.62.0/24", + "172.70.63.0/24", + "172.70.80.0/24", + "172.70.81.0/24", + "172.70.82.0/24", + "172.70.83.0/24", + "172.70.84.0/24", + "172.70.85.0/24", + "172.70.86.0/24", + "172.70.87.0/24", + "172.70.88.0/24", + "172.70.89.0/24", + "172.70.90.0/24", + "172.70.91.0/24", + "172.70.92.0/24", + "172.70.93.0/24", + "172.70.94.0/24", + "172.70.95.0/24", + "172.70.96.0/24", + "172.70.97.0/24", + "172.70.98.0/24", + "172.70.99.0/24", + "172.70.100.0/24", + "172.70.101.0/24", + "172.70.102.0/24", + "172.70.103.0/24", + "172.70.104.0/24", + "172.70.105.0/24", + "172.70.106.0/24", + "172.70.107.0/24", + "172.70.108.0/24", + "172.70.109.0/24", + "172.70.110.0/24", + "172.70.111.0/24", + "172.70.112.0/24", + "172.70.113.0/24", + "172.70.114.0/24", + "172.70.115.0/24", + "172.70.116.0/24", + "172.70.117.0/24", + "172.70.120.0/24", + "172.70.121.0/24", + "172.70.122.0/24", + "172.70.123.0/24", + "172.70.124.0/24", + "172.70.125.0/24", + "172.70.126.0/24", + "172.70.127.0/24", + "172.70.128.0/24", + "172.70.129.0/24", + "172.70.130.0/24", + "172.70.131.0/24", + "172.70.132.0/24", + "172.70.133.0/24", + "172.70.134.0/24", + "172.70.135.0/24", + "172.70.136.0/24", + "172.70.138.0/24", + "172.70.139.0/24", + "172.70.140.0/24", + "172.70.141.0/24", + "172.70.142.0/24", + "172.70.143.0/24", + "172.70.144.0/24", + "172.70.145.0/24", + "172.70.146.0/24", + "172.70.147.0/24", + "172.70.148.0/24", + "172.70.149.0/24", + "172.70.150.0/24", + "172.70.152.0/24", + "172.70.153.0/24", + "172.70.154.0/24", + "172.70.155.0/24", + "172.70.156.0/24", + "172.70.157.0/24", + "172.70.158.0/24", + "172.70.160.0/24", + "172.70.161.0/24", + "172.70.162.0/24", + "172.70.163.0/24", + "172.70.172.0/24", + "172.70.173.0/24", + "172.70.174.0/24", + "172.70.175.0/24", + "172.70.176.0/24", + "172.70.177.0/24", + "172.70.178.0/24", + "172.70.179.0/24", + "172.70.180.0/24", + "172.70.181.0/24", + "172.70.182.0/24", + "172.70.183.0/24", + "172.70.186.0/24", + "172.70.187.0/24", + "172.70.188.0/24", + "172.70.189.0/24", + "172.70.190.0/24", + "172.70.191.0/24", + "172.70.192.0/24", + "172.70.193.0/24", + "172.70.194.0/24", + "172.70.195.0/24", + "172.70.196.0/24", + "172.70.197.0/24", + "172.70.198.0/24", + "172.70.199.0/24", + "172.70.200.0/24", + "172.70.202.0/24", + "172.70.203.0/24", + "172.70.204.0/24", + "172.70.205.0/24", + "172.70.206.0/24", + "172.70.207.0/24", + "172.70.208.0/24", + "172.70.209.0/24", + "172.70.210.0/24", + "172.70.211.0/24", + "172.70.212.0/24", + "172.70.213.0/24", + "172.70.214.0/24", + "172.70.215.0/24", + "172.70.216.0/24", + "172.70.217.0/24", + "172.70.218.0/24", + "172.70.219.0/24", + "172.70.220.0/24", + "172.70.221.0/24", + "172.70.222.0/24", + "172.70.223.0/24", + "172.70.224.0/24", + "172.70.225.0/24", + "172.70.226.0/24", + "172.70.227.0/24", + "172.70.228.0/24", + "172.70.229.0/24", + "172.70.230.0/24", + "172.70.231.0/24", + "172.70.232.0/24", + "172.70.233.0/24", + "172.70.234.0/24", + "172.70.235.0/24", + "172.70.236.0/24", + "172.70.237.0/24", + "172.70.238.0/24", + "172.70.239.0/24", + "172.70.240.0/24", + "172.70.241.0/24", + "172.70.242.0/24", + "172.70.243.0/24", + "172.70.244.0/24", + "172.70.245.0/24", + "172.70.246.0/24", + "172.70.247.0/24", + "172.70.248.0/24", + "172.70.249.0/24", + "172.70.250.0/24", + "172.70.251.0/24", + "172.70.252.0/24", + "172.70.253.0/24", + "172.70.254.0/24", + "172.70.255.0/24", + "172.71.0.0/24", + "172.71.2.0/24", + "172.71.3.0/24", + "172.71.4.0/24", + "172.71.5.0/24", + "172.71.6.0/24", + "172.71.7.0/24", + "172.71.8.0/24", + "172.71.9.0/24", + "172.71.10.0/24", + "172.71.11.0/24", + "172.71.12.0/24", + "172.71.13.0/24", + "172.71.14.0/24", + "172.71.15.0/24", + "172.71.16.0/24", + "172.71.17.0/24", + "172.71.20.0/24", + "172.71.21.0/24", + "172.71.22.0/24", + "172.71.23.0/24", + "172.71.24.0/24", + "172.71.25.0/24", + "172.71.26.0/24", + "172.71.27.0/24", + "172.71.28.0/24", + "172.71.29.0/24", + "172.71.30.0/24", + "172.71.31.0/24", + "172.71.80.0/24", + "172.71.81.0/24", + "172.71.82.0/24", + "172.71.83.0/24", + "172.71.84.0/24", + "172.71.85.0/24", + "172.71.86.0/24", + "172.71.87.0/24", + "172.71.88.0/24", + "172.71.89.0/24", + "172.71.90.0/24", + "172.71.92.0/24", + "172.71.93.0/24", + "172.71.94.0/24", + "172.71.95.0/24", + "172.71.96.0/24", + "172.71.97.0/24", + "172.71.98.0/24", + "172.71.99.0/24", + "172.71.100.0/24", + "172.71.101.0/24", + "172.71.102.0/24", + "172.71.103.0/24", + "172.71.108.0/24", + "172.71.109.0/24", + "172.71.110.0/24", + "172.71.111.0/24", + "172.71.112.0/24", + "172.71.113.0/24", + "172.71.114.0/24", + "172.71.115.0/24", + "172.71.116.0/24", + "172.71.117.0/24", + "172.71.118.0/24", + "172.71.119.0/24", + "172.71.120.0/24", + "172.71.121.0/24", + "172.71.122.0/24", + "172.71.123.0/24", + "172.71.124.0/24", + "172.71.125.0/24", + "172.71.126.0/24", + "172.71.127.0/24", + "172.71.128.0/24", + "172.71.129.0/24", + "172.71.130.0/24", + "172.71.131.0/24", + "172.71.132.0/24", + "172.71.133.0/24", + "172.71.134.0/24", + "172.71.135.0/24", + "172.71.137.0/24", + "172.71.138.0/24", + "172.71.139.0/24", + "172.71.140.0/24", + "172.71.141.0/24", + "172.71.142.0/24", + "172.71.143.0/24", + "172.71.144.0/24", + "172.71.145.0/24", + "172.71.146.0/24", + "172.71.147.0/24", + "172.71.148.0/24", + "172.71.149.0/24", + "172.71.150.0/24", + "172.71.151.0/24", + "172.71.152.0/24", + "172.71.153.0/24", + "172.71.154.0/24", + "172.71.155.0/24", + "172.71.156.0/24", + "172.71.157.0/24", + "172.71.158.0/24", + "172.71.159.0/24", + "172.71.160.0/24", + "172.71.161.0/24", + "172.71.162.0/24", + "172.71.163.0/24", + "172.71.164.0/24", + "172.71.165.0/24", + "172.71.166.0/24", + "172.71.167.0/24", + "172.71.168.0/24", + "172.71.169.0/24", + "172.71.170.0/24", + "172.71.171.0/24", + "172.71.172.0/24", + "172.71.173.0/24", + "172.71.174.0/24", + "172.71.175.0/24", + "172.71.176.0/24", + "172.71.177.0/24", + "172.71.178.0/24", + "172.71.179.0/24", + "172.71.180.0/24", + "172.71.181.0/24", + "172.71.182.0/24", + "172.71.183.0/24", + "172.71.184.0/24", + "172.71.185.0/24", + "172.71.186.0/24", + "172.71.187.0/24", + "172.71.188.0/24", + "172.71.189.0/24", + "172.71.190.0/24", + "172.71.191.0/24", + "172.71.192.0/24", + "172.71.193.0/24", + "172.71.194.0/24", + "172.71.195.0/24", + "172.71.196.0/24", + "172.71.197.0/24", + "172.71.198.0/24", + "172.71.199.0/24", + "172.71.200.0/24", + "172.71.201.0/24", + "172.71.202.0/24", + "172.71.203.0/24", + "172.71.204.0/24", + "172.71.205.0/24", + "172.71.206.0/24", + "172.71.207.0/24", + "172.71.208.0/24", + "172.71.209.0/24", + "172.71.210.0/24", + "172.71.211.0/24", + "172.71.212.0/24", + "172.71.213.0/24", + "172.71.214.0/24", + "172.71.215.0/24", + "172.71.216.0/24", + "172.71.217.0/24", + "172.71.218.0/24", + "172.71.219.0/24", + "172.71.220.0/24", + "172.71.221.0/24", + "172.71.222.0/24", + "172.71.223.0/24", + "172.71.224.0/24", + "172.71.225.0/24", + "172.71.226.0/24", + "172.71.227.0/24", + "172.71.228.0/24", + "172.71.229.0/24", + "172.71.230.0/24", + "172.71.231.0/24", + "172.71.232.0/24", + "172.71.233.0/24", + "172.71.234.0/24", + "172.71.235.0/24", + "172.71.236.0/24", + "172.71.237.0/24", + "172.71.238.0/24", + "172.71.239.0/24", + "172.71.240.0/24", + "172.71.241.0/24", + "172.71.242.0/24", + "172.71.243.0/24", + "172.71.244.0/24", + "172.71.245.0/24", + "172.71.246.0/24", + "172.71.247.0/24", + "172.71.248.0/24", + "172.71.249.0/24", + "172.71.250.0/24", + "172.71.251.0/24", + "172.71.252.0/24", + "172.71.253.0/24", + "172.71.254.0/24", + "172.71.255.0/24", + "173.245.49.0/24", + "173.245.54.0/24", + "173.245.58.0/24", + "173.245.59.0/24", + "173.245.63.0/24", + "185.146.172.0/24", + "185.146.173.0/24", + "188.114.96.0/24", + "188.114.97.0/24", + "188.114.98.0/24", + "188.114.99.0/24", + "188.114.100.0/24", + "188.114.102.0/24", + "188.114.103.0/24", + "188.114.106.0/24", + "188.114.107.0/24", + "188.114.108.0/24", + "188.114.111.0/24", + "190.93.240.0/24", + "190.93.241.0/24", + "190.93.242.0/24", + "190.93.243.0/24", + "190.93.244.0/24", + "190.93.245.0/24", + "190.93.246.0/24", + "190.93.247.0/24", + "190.93.248.0/24", + "190.93.249.0/24", + "190.93.250.0/24", + "190.93.251.0/24", + "190.93.252.0/24", + "190.93.253.0/24", + "190.93.254.0/24", + "190.93.255.0/24", + "195.242.122.0/24", + "195.242.123.0/24", + "197.234.240.0/24", + "197.234.241.0/24", + "197.234.242.0/24", + "197.234.243.0/24", + "198.41.129.0/24", + "198.41.192.0/24", + "198.41.193.0/24", + "198.41.194.0/24", + "198.41.195.0/24", + "198.41.196.0/24", + "198.41.197.0/24", + "198.41.198.0/24", + "198.41.199.0/24", + "198.41.200.0/24", + "198.41.201.0/24", + "198.41.202.0/24", + "198.41.203.0/24", + "198.41.204.0/24", + "198.41.205.0/24", + "198.41.206.0/24", + "198.41.207.0/24", + "198.41.208.0/24", + "198.41.209.0/24", + "198.41.211.0/24", + "198.41.212.0/24", + "198.41.214.0/24", + "198.41.215.0/24", + "198.41.216.0/24", + "198.41.217.0/24", + "198.41.218.0/24", + "198.41.219.0/24", + "198.41.220.0/24", + "198.41.221.0/24", + "198.41.222.0/24", + "198.41.223.0/24", + "198.41.224.0/24", + "198.41.225.0/24", + "198.41.226.0/24", + "198.41.227.0/24", + "198.41.228.0/24", + "198.41.229.0/24", + "198.41.230.0/24", + "198.41.231.0/24", + "198.41.232.0/24", + "198.41.233.0/24", + "198.41.236.0/24", + "198.41.237.0/24", + "198.41.238.0/24", + "198.41.239.0/24", + "198.41.240.0/24", + "198.41.241.0/24", + "198.41.242.0/24", + "198.217.251.0/24", + "199.27.128.0/24", + "199.27.129.0/24", + "199.27.130.0/24", + "199.27.131.0/24", + "199.27.132.0/24", + "199.27.134.0/24", + "199.27.135.0/24" + ]; + + /** @type { {ipNumber: number, ipMask: number}[]} */ +const cidrNumberList= [] +for (const cidr of cidrList) { + // 8.9.231.0/24 + const [rangeAddress, rangePrefix] = cidr.split('/'); + const prefix = parseInt(rangePrefix, 10); // 24 + const ipMask = -1 << (32 - prefix); // -256 + // const ipMask = ~(2 ** (32 - prefix) - 1); + + const ipNumber = convertIp2Num(rangeAddress); + cidrNumberList.push( + { + ipNumber, // 8.9.231.0 --> 134866688 + ipMask // -256 + } + ) +} + +/** + * Checks if an IPv4 address is within a CIDR range. + * + * @param {string} address The IPv4 address to check. + * @param {string} cidr The CIDR range to check against. + * @returns {boolean} `true` if the address is within the CIDR range, `false` otherwise. + */ +function isIPv4InRange(address, cidr) { + // Parse the address and CIDR range + const addressParts = address.split('.').map(part => parseInt(part, 10)); + const [rangeAddress, rangePrefix] = cidr.split('/'); + const rangeParts = rangeAddress.split('.').map(part => parseInt(part, 10)); + const prefix = parseInt(rangePrefix, 10); + + // Convert the address and range to binary format + const addressBinary = addressParts.reduce((acc, part) => acc + part.toString(2).padStart(8, '0'), ''); + const rangeBinary = rangeParts.reduce((acc, part) => acc + part.toString(2).padStart(8, '0'), ''); + + // Compare the bits up to the prefix length + for (let i = 0; i < prefix; i++) { + if (addressBinary[i] !== rangeBinary[i]) { + return false; + } + } + + return true; +} + +/** +* Checks if an IPv6 address is within a CIDR range. +* +* @param {string} address The IPv6 address to check. +* @param {string} cidr The CIDR range to check against. +* @returns {boolean} `true` if the address is within the CIDR range, `false` otherwise. +*/ +function isIPv6InRange(address, cidr) { + // Parse the address and CIDR range + const addressParts = address.split(':').map(part => parseInt(part, 16)); + const [rangeAddress, rangePrefix] = cidr.split('/'); + const rangeParts = rangeAddress.split(':').map(part => parseInt(part, 16)); + const prefix = parseInt(rangePrefix, 10); + + // Convert the address and range to binary format + const addressBinary = addressParts.reduce((acc, part) => acc + part.toString(2).padStart(16, '0'), ''); + const rangeBinary = rangeParts.reduce((acc, part) => acc + part.toString(2).padStart(16, '0'), ''); + + // Compare the bits up to the prefix length + for (let i = 0; i < prefix; i++) { + if (addressBinary[i] !== rangeBinary[i]) { + return false; + } + } + + return true; +} diff --git a/test/cidr.js b/test/cidr.js new file mode 100644 index 0000000..950038f --- /dev/null +++ b/test/cidr.js @@ -0,0 +1,6548 @@ +const cidrList = [ + "1.0.0.0/24", + "1.1.1.0/24", + "8.6.144.0/24", + "8.6.145.0/24", + "8.6.146.0/24", + "8.9.231.0/24", + "8.10.148.0/24", + "8.14.199.0/24", + "8.14.201.0/24", + "8.14.202.0/24", + "8.14.203.0/24", + "8.14.204.0/24", + "8.17.205.0/24", + "8.17.206.0/24", + "8.18.50.0/24", + "8.18.113.0/24", + "8.18.194.0/24", + "8.18.195.0/24", + "8.18.196.0/24", + "8.19.8.0/24", + "8.20.100.0/24", + "8.20.101.0/24", + "8.20.103.0/24", + "8.20.122.0/24", + "8.20.123.0/24", + "8.20.124.0/24", + "8.20.125.0/24", + "8.20.126.0/24", + "8.20.253.0/24", + "8.21.8.0/24", + "8.21.9.0/24", + "8.21.10.0/24", + "8.21.13.0/24", + "8.21.110.0/24", + "8.21.111.0/24", + "8.21.239.0/24", + "8.23.139.0/24", + "8.23.240.0/24", + "8.24.87.0/24", + "8.24.242.0/24", + "8.24.243.0/24", + "8.24.244.0/24", + "8.25.96.0/24", + "8.25.97.0/24", + "8.25.249.0/24", + "8.26.180.0/24", + "8.26.182.0/24", + "8.27.64.0/24", + "8.27.66.0/24", + "8.27.67.0/24", + "8.27.68.0/24", + "8.27.69.0/24", + "8.27.79.0/24", + "8.28.20.0/24", + "8.28.82.0/24", + "8.28.126.0/24", + "8.28.213.0/24", + "8.29.105.0/24", + "8.29.230.0/24", + "8.29.231.0/24", + "8.30.234.0/24", + "8.31.2.0/24", + "8.31.160.0/24", + "8.31.161.0/24", + "8.34.69.0/24", + "8.34.70.0/24", + "8.34.71.0/24", + "8.34.200.0/24", + "8.34.201.0/24", + "8.34.202.0/24", + "8.35.57.0/24", + "8.35.58.0/24", + "8.35.59.0/24", + "8.35.149.0/24", + "8.35.211.0/24", + "8.36.216.0/24", + "8.36.217.0/24", + "8.36.218.0/24", + "8.36.219.0/24", + "8.36.220.0/24", + "8.37.41.0/24", + "8.37.43.0/24", + "8.38.147.0/24", + "8.38.148.0/24", + "8.38.149.0/24", + "8.38.172.0/24", + "8.39.6.0/24", + "8.39.18.0/24", + "8.39.125.0/24", + "8.39.126.0/24", + "8.39.201.0/24", + "8.39.202.0/24", + "8.39.203.0/24", + "8.39.204.0/24", + "8.39.205.0/24", + "8.39.206.0/24", + "8.39.207.0/24", + "8.39.212.0/24", + "8.39.213.0/24", + "8.39.214.0/24", + "8.39.215.0/24", + "8.40.26.0/24", + "8.40.27.0/24", + "8.40.28.0/24", + "8.40.29.0/24", + "8.40.30.0/24", + "8.40.31.0/24", + "8.40.107.0/24", + "8.40.111.0/24", + "8.40.140.0/24", + "8.41.5.0/24", + "8.41.6.0/24", + "8.41.7.0/24", + "8.41.36.0/24", + "8.41.37.0/24", + "8.42.51.0/24", + "8.42.52.0/24", + "8.42.54.0/24", + "8.42.55.0/24", + "8.42.161.0/24", + "8.42.164.0/24", + "8.42.172.0/24", + "8.42.245.0/24", + "8.43.121.0/24", + "8.43.122.0/24", + "8.43.123.0/24", + "8.43.224.0/24", + "8.43.225.0/24", + "8.43.226.0/24", + "8.44.0.0/24", + "8.44.1.0/24", + "8.44.2.0/24", + "8.44.3.0/24", + "8.44.6.0/24", + "8.44.58.0/24", + "8.44.60.0/24", + "8.44.61.0/24", + "8.44.62.0/24", + "8.44.63.0/24", + "8.45.41.0/24", + "8.45.43.0/24", + "8.45.44.0/24", + "8.45.45.0/24", + "8.45.46.0/24", + "8.45.47.0/24", + "8.45.97.0/24", + "8.45.101.0/24", + "8.45.102.0/24", + "8.45.108.0/24", + "8.45.111.0/24", + "8.45.144.0/24", + "8.45.145.0/24", + "8.45.146.0/24", + "8.45.147.0/24", + "8.46.113.0/24", + "8.46.114.0/24", + "8.46.115.0/24", + "8.46.117.0/24", + "8.46.118.0/24", + "8.46.119.0/24", + "8.47.9.0/24", + "8.47.12.0/24", + "8.47.13.0/24", + "8.47.14.0/24", + "8.47.15.0/24", + "8.47.69.0/24", + "8.47.71.0/24", + "8.48.130.0/24", + "8.48.132.0/24", + "8.48.133.0/24", + "8.48.134.0/24", + "23.227.37.0/24", + "23.227.38.0/24", + "23.227.39.0/24", + "23.227.60.0/24", + "64.68.192.0/24", + "65.110.63.0/24", + "66.235.200.0/24", + "68.67.65.0/24", + "91.234.214.0/24", + "103.21.244.0/24", + "103.22.200.0/24", + "103.22.201.0/24", + "103.22.202.0/24", + "103.22.203.0/24", + "103.81.228.0/24", + "104.16.0.0/24", + "104.16.1.0/24", + "104.16.2.0/24", + "104.16.3.0/24", + "104.16.4.0/24", + "104.16.5.0/24", + "104.16.6.0/24", + "104.16.7.0/24", + "104.16.8.0/24", + "104.16.9.0/24", + "104.16.10.0/24", + "104.16.11.0/24", + "104.16.12.0/24", + "104.16.13.0/24", + "104.16.14.0/24", + "104.16.15.0/24", + "104.16.16.0/24", + "104.16.17.0/24", + "104.16.18.0/24", + "104.16.19.0/24", + "104.16.20.0/24", + "104.16.21.0/24", + "104.16.22.0/24", + "104.16.23.0/24", + "104.16.24.0/24", + "104.16.25.0/24", + "104.16.26.0/24", + "104.16.27.0/24", + "104.16.28.0/24", + "104.16.29.0/24", + "104.16.30.0/24", + "104.16.31.0/24", + "104.16.32.0/24", + "104.16.33.0/24", + "104.16.34.0/24", + "104.16.35.0/24", + "104.16.36.0/24", + "104.16.37.0/24", + "104.16.38.0/24", + "104.16.39.0/24", + "104.16.40.0/24", + "104.16.41.0/24", + "104.16.42.0/24", + "104.16.43.0/24", + "104.16.44.0/24", + "104.16.45.0/24", + "104.16.46.0/24", + "104.16.47.0/24", + "104.16.48.0/24", + "104.16.49.0/24", + "104.16.50.0/24", + "104.16.51.0/24", + "104.16.52.0/24", + "104.16.53.0/24", + "104.16.54.0/24", + "104.16.55.0/24", + "104.16.56.0/24", + "104.16.57.0/24", + "104.16.58.0/24", + "104.16.59.0/24", + "104.16.60.0/24", + "104.16.61.0/24", + "104.16.62.0/24", + "104.16.63.0/24", + "104.16.64.0/24", + "104.16.65.0/24", + "104.16.66.0/24", + "104.16.67.0/24", + "104.16.68.0/24", + "104.16.69.0/24", + "104.16.70.0/24", + "104.16.71.0/24", + "104.16.72.0/24", + "104.16.73.0/24", + "104.16.74.0/24", + "104.16.75.0/24", + "104.16.76.0/24", + "104.16.77.0/24", + "104.16.78.0/24", + "104.16.79.0/24", + "104.16.80.0/24", + "104.16.81.0/24", + "104.16.82.0/24", + "104.16.83.0/24", + "104.16.84.0/24", + "104.16.85.0/24", + "104.16.86.0/24", + "104.16.87.0/24", + "104.16.88.0/24", + "104.16.89.0/24", + "104.16.90.0/24", + "104.16.91.0/24", + "104.16.92.0/24", + "104.16.93.0/24", + "104.16.94.0/24", + "104.16.95.0/24", + "104.16.96.0/24", + "104.16.97.0/24", + "104.16.98.0/24", + "104.16.99.0/24", + "104.16.100.0/24", + "104.16.101.0/24", + "104.16.102.0/24", + "104.16.103.0/24", + "104.16.104.0/24", + "104.16.105.0/24", + "104.16.106.0/24", + "104.16.107.0/24", + "104.16.108.0/24", + "104.16.109.0/24", + "104.16.110.0/24", + "104.16.111.0/24", + "104.16.112.0/24", + "104.16.113.0/24", + "104.16.114.0/24", + "104.16.115.0/24", + "104.16.116.0/24", + "104.16.117.0/24", + "104.16.118.0/24", + "104.16.119.0/24", + "104.16.120.0/24", + "104.16.121.0/24", + "104.16.122.0/24", + "104.16.123.0/24", + "104.16.124.0/24", + "104.16.125.0/24", + "104.16.126.0/24", + "104.16.127.0/24", + "104.16.128.0/24", + "104.16.129.0/24", + "104.16.130.0/24", + "104.16.131.0/24", + "104.16.132.0/24", + "104.16.133.0/24", + "104.16.134.0/24", + "104.16.135.0/24", + "104.16.136.0/24", + "104.16.137.0/24", + "104.16.138.0/24", + "104.16.139.0/24", + "104.16.140.0/24", + "104.16.141.0/24", + "104.16.142.0/24", + "104.16.143.0/24", + "104.16.144.0/24", + "104.16.145.0/24", + "104.16.146.0/24", + "104.16.147.0/24", + "104.16.148.0/24", + "104.16.149.0/24", + "104.16.150.0/24", + "104.16.151.0/24", + "104.16.152.0/24", + "104.16.153.0/24", + "104.16.154.0/24", + "104.16.155.0/24", + "104.16.156.0/24", + "104.16.157.0/24", + "104.16.158.0/24", + "104.16.159.0/24", + "104.16.160.0/24", + "104.16.161.0/24", + "104.16.162.0/24", + "104.16.163.0/24", + "104.16.164.0/24", + "104.16.165.0/24", + "104.16.166.0/24", + "104.16.167.0/24", + "104.16.168.0/24", + "104.16.169.0/24", + "104.16.170.0/24", + "104.16.171.0/24", + "104.16.172.0/24", + "104.16.173.0/24", + "104.16.174.0/24", + "104.16.175.0/24", + "104.16.176.0/24", + "104.16.177.0/24", + "104.16.178.0/24", + "104.16.179.0/24", + "104.16.180.0/24", + "104.16.181.0/24", + "104.16.182.0/24", + "104.16.183.0/24", + "104.16.184.0/24", + "104.16.185.0/24", + "104.16.186.0/24", + "104.16.187.0/24", + "104.16.188.0/24", + "104.16.189.0/24", + "104.16.190.0/24", + "104.16.191.0/24", + "104.16.192.0/24", + "104.16.193.0/24", + "104.16.194.0/24", + "104.16.195.0/24", + "104.16.196.0/24", + "104.16.197.0/24", + "104.16.198.0/24", + "104.16.199.0/24", + "104.16.200.0/24", + "104.16.201.0/24", + "104.16.202.0/24", + "104.16.203.0/24", + "104.16.204.0/24", + "104.16.205.0/24", + "104.16.206.0/24", + "104.16.207.0/24", + "104.16.208.0/24", + "104.16.209.0/24", + "104.16.210.0/24", + "104.16.211.0/24", + "104.16.212.0/24", + "104.16.213.0/24", + "104.16.214.0/24", + "104.16.215.0/24", + "104.16.216.0/24", + "104.16.217.0/24", + "104.16.218.0/24", + "104.16.219.0/24", + "104.16.220.0/24", + "104.16.221.0/24", + "104.16.222.0/24", + "104.16.223.0/24", + "104.16.224.0/24", + "104.16.225.0/24", + "104.16.226.0/24", + "104.16.227.0/24", + "104.16.228.0/24", + "104.16.229.0/24", + "104.16.230.0/24", + "104.16.231.0/24", + "104.16.232.0/24", + "104.16.233.0/24", + "104.16.234.0/24", + "104.16.235.0/24", + "104.16.236.0/24", + "104.16.237.0/24", + "104.16.238.0/24", + "104.16.239.0/24", + "104.16.240.0/24", + "104.16.241.0/24", + "104.16.242.0/24", + "104.16.243.0/24", + "104.16.244.0/24", + "104.16.245.0/24", + "104.16.246.0/24", + "104.16.247.0/24", + "104.16.248.0/24", + "104.16.249.0/24", + "104.16.250.0/24", + "104.16.251.0/24", + "104.16.252.0/24", + "104.16.253.0/24", + "104.16.254.0/24", + "104.16.255.0/24", + "104.17.0.0/24", + "104.17.1.0/24", + "104.17.2.0/24", + "104.17.3.0/24", + "104.17.4.0/24", + "104.17.5.0/24", + "104.17.6.0/24", + "104.17.7.0/24", + "104.17.8.0/24", + "104.17.9.0/24", + "104.17.10.0/24", + "104.17.11.0/24", + "104.17.12.0/24", + "104.17.13.0/24", + "104.17.14.0/24", + "104.17.15.0/24", + "104.17.16.0/24", + "104.17.17.0/24", + "104.17.18.0/24", + "104.17.19.0/24", + "104.17.20.0/24", + "104.17.21.0/24", + "104.17.22.0/24", + "104.17.23.0/24", + "104.17.24.0/24", + "104.17.25.0/24", + "104.17.26.0/24", + "104.17.27.0/24", + "104.17.28.0/24", + "104.17.29.0/24", + "104.17.30.0/24", + "104.17.31.0/24", + "104.17.32.0/24", + "104.17.33.0/24", + "104.17.34.0/24", + "104.17.35.0/24", + "104.17.36.0/24", + "104.17.37.0/24", + "104.17.38.0/24", + "104.17.39.0/24", + "104.17.40.0/24", + "104.17.41.0/24", + "104.17.42.0/24", + "104.17.43.0/24", + "104.17.44.0/24", + "104.17.45.0/24", + "104.17.46.0/24", + "104.17.47.0/24", + "104.17.48.0/24", + "104.17.49.0/24", + "104.17.50.0/24", + "104.17.51.0/24", + "104.17.52.0/24", + "104.17.53.0/24", + "104.17.54.0/24", + "104.17.55.0/24", + "104.17.56.0/24", + "104.17.57.0/24", + "104.17.58.0/24", + "104.17.59.0/24", + "104.17.60.0/24", + "104.17.61.0/24", + "104.17.62.0/24", + "104.17.63.0/24", + "104.17.64.0/24", + "104.17.65.0/24", + "104.17.66.0/24", + "104.17.67.0/24", + "104.17.68.0/24", + "104.17.69.0/24", + "104.17.70.0/24", + "104.17.71.0/24", + "104.17.72.0/24", + "104.17.73.0/24", + "104.17.74.0/24", + "104.17.75.0/24", + "104.17.76.0/24", + "104.17.77.0/24", + "104.17.78.0/24", + "104.17.79.0/24", + "104.17.80.0/24", + "104.17.81.0/24", + "104.17.82.0/24", + "104.17.83.0/24", + "104.17.84.0/24", + "104.17.85.0/24", + "104.17.86.0/24", + "104.17.87.0/24", + "104.17.88.0/24", + "104.17.89.0/24", + "104.17.90.0/24", + "104.17.91.0/24", + "104.17.92.0/24", + "104.17.93.0/24", + "104.17.94.0/24", + "104.17.95.0/24", + "104.17.96.0/24", + "104.17.97.0/24", + "104.17.98.0/24", + "104.17.99.0/24", + "104.17.100.0/24", + "104.17.101.0/24", + "104.17.102.0/24", + "104.17.103.0/24", + "104.17.104.0/24", + "104.17.105.0/24", + "104.17.106.0/24", + "104.17.107.0/24", + "104.17.108.0/24", + "104.17.109.0/24", + "104.17.110.0/24", + "104.17.111.0/24", + "104.17.112.0/24", + "104.17.113.0/24", + "104.17.114.0/24", + "104.17.115.0/24", + "104.17.116.0/24", + "104.17.117.0/24", + "104.17.118.0/24", + "104.17.119.0/24", + "104.17.120.0/24", + "104.17.121.0/24", + "104.17.122.0/24", + "104.17.123.0/24", + "104.17.124.0/24", + "104.17.125.0/24", + "104.17.126.0/24", + "104.17.127.0/24", + "104.17.128.0/24", + "104.17.129.0/24", + "104.17.130.0/24", + "104.17.131.0/24", + "104.17.132.0/24", + "104.17.133.0/24", + "104.17.134.0/24", + "104.17.135.0/24", + "104.17.136.0/24", + "104.17.137.0/24", + "104.17.138.0/24", + "104.17.139.0/24", + "104.17.140.0/24", + "104.17.141.0/24", + "104.17.142.0/24", + "104.17.143.0/24", + "104.17.144.0/24", + "104.17.145.0/24", + "104.17.146.0/24", + "104.17.147.0/24", + "104.17.148.0/24", + "104.17.149.0/24", + "104.17.150.0/24", + "104.17.151.0/24", + "104.17.152.0/24", + "104.17.153.0/24", + "104.17.154.0/24", + "104.17.155.0/24", + "104.17.156.0/24", + "104.17.157.0/24", + "104.17.158.0/24", + "104.17.159.0/24", + "104.17.160.0/24", + "104.17.161.0/24", + "104.17.162.0/24", + "104.17.163.0/24", + "104.17.164.0/24", + "104.17.165.0/24", + "104.17.166.0/24", + "104.17.167.0/24", + "104.17.168.0/24", + "104.17.169.0/24", + "104.17.170.0/24", + "104.17.171.0/24", + "104.17.172.0/24", + "104.17.173.0/24", + "104.17.174.0/24", + "104.17.175.0/24", + "104.17.176.0/24", + "104.17.177.0/24", + "104.17.178.0/24", + "104.17.179.0/24", + "104.17.180.0/24", + "104.17.181.0/24", + "104.17.182.0/24", + "104.17.183.0/24", + "104.17.184.0/24", + "104.17.185.0/24", + "104.17.186.0/24", + "104.17.187.0/24", + "104.17.188.0/24", + "104.17.189.0/24", + "104.17.190.0/24", + "104.17.191.0/24", + "104.17.192.0/24", + "104.17.193.0/24", + "104.17.194.0/24", + "104.17.195.0/24", + "104.17.196.0/24", + "104.17.197.0/24", + "104.17.198.0/24", + "104.17.199.0/24", + "104.17.200.0/24", + "104.17.201.0/24", + "104.17.202.0/24", + "104.17.203.0/24", + "104.17.204.0/24", + "104.17.205.0/24", + "104.17.206.0/24", + "104.17.207.0/24", + "104.17.208.0/24", + "104.17.209.0/24", + "104.17.210.0/24", + "104.17.211.0/24", + "104.17.212.0/24", + "104.17.213.0/24", + "104.17.214.0/24", + "104.17.215.0/24", + "104.17.216.0/24", + "104.17.217.0/24", + "104.17.218.0/24", + "104.17.219.0/24", + "104.17.220.0/24", + "104.17.221.0/24", + "104.17.222.0/24", + "104.17.223.0/24", + "104.17.224.0/24", + "104.17.225.0/24", + "104.17.226.0/24", + "104.17.227.0/24", + "104.17.228.0/24", + "104.17.229.0/24", + "104.17.230.0/24", + "104.17.231.0/24", + "104.17.232.0/24", + "104.17.233.0/24", + "104.17.234.0/24", + "104.17.235.0/24", + "104.17.236.0/24", + "104.17.237.0/24", + "104.17.238.0/24", + "104.17.239.0/24", + "104.17.240.0/24", + "104.17.241.0/24", + "104.17.242.0/24", + "104.17.243.0/24", + "104.17.244.0/24", + "104.17.245.0/24", + "104.17.246.0/24", + "104.17.247.0/24", + "104.17.248.0/24", + "104.17.249.0/24", + "104.17.250.0/24", + "104.17.251.0/24", + "104.17.252.0/24", + "104.17.253.0/24", + "104.17.254.0/24", + "104.17.255.0/24", + "104.18.0.0/24", + "104.18.1.0/24", + "104.18.2.0/24", + "104.18.3.0/24", + "104.18.4.0/24", + "104.18.5.0/24", + "104.18.6.0/24", + "104.18.7.0/24", + "104.18.8.0/24", + "104.18.9.0/24", + "104.18.10.0/24", + "104.18.11.0/24", + "104.18.12.0/24", + "104.18.13.0/24", + "104.18.14.0/24", + "104.18.15.0/24", + "104.18.16.0/24", + "104.18.17.0/24", + "104.18.18.0/24", + "104.18.19.0/24", + "104.18.20.0/24", + "104.18.21.0/24", + "104.18.22.0/24", + "104.18.23.0/24", + "104.18.24.0/24", + "104.18.25.0/24", + "104.18.26.0/24", + "104.18.27.0/24", + "104.18.28.0/24", + "104.18.29.0/24", + "104.18.30.0/24", + "104.18.31.0/24", + "104.18.32.0/24", + "104.18.33.0/24", + "104.18.34.0/24", + "104.18.35.0/24", + "104.18.36.0/24", + "104.18.37.0/24", + "104.18.38.0/24", + "104.18.39.0/24", + "104.18.40.0/24", + "104.18.41.0/24", + "104.18.42.0/24", + "104.18.43.0/24", + "104.18.44.0/24", + "104.18.45.0/24", + "104.18.46.0/24", + "104.18.47.0/24", + "104.18.48.0/24", + "104.18.49.0/24", + "104.18.50.0/24", + "104.18.51.0/24", + "104.18.52.0/24", + "104.18.53.0/24", + "104.18.54.0/24", + "104.18.55.0/24", + "104.18.56.0/24", + "104.18.57.0/24", + "104.18.58.0/24", + "104.18.59.0/24", + "104.18.60.0/24", + "104.18.61.0/24", + "104.18.62.0/24", + "104.18.63.0/24", + "104.18.64.0/24", + "104.18.65.0/24", + "104.18.66.0/24", + "104.18.67.0/24", + "104.18.68.0/24", + "104.18.69.0/24", + "104.18.70.0/24", + "104.18.71.0/24", + "104.18.72.0/24", + "104.18.73.0/24", + "104.18.74.0/24", + "104.18.75.0/24", + "104.18.76.0/24", + "104.18.77.0/24", + "104.18.78.0/24", + "104.18.79.0/24", + "104.18.80.0/24", + "104.18.81.0/24", + "104.18.82.0/24", + "104.18.83.0/24", + "104.18.84.0/24", + "104.18.85.0/24", + "104.18.86.0/24", + "104.18.87.0/24", + "104.18.88.0/24", + "104.18.89.0/24", + "104.18.90.0/24", + "104.18.91.0/24", + "104.18.92.0/24", + "104.18.93.0/24", + "104.18.94.0/24", + "104.18.95.0/24", + "104.18.96.0/24", + "104.18.97.0/24", + "104.18.98.0/24", + "104.18.99.0/24", + "104.18.100.0/24", + "104.18.101.0/24", + "104.18.102.0/24", + "104.18.103.0/24", + "104.18.104.0/24", + "104.18.105.0/24", + "104.18.106.0/24", + "104.18.107.0/24", + "104.18.108.0/24", + "104.18.109.0/24", + "104.18.110.0/24", + "104.18.111.0/24", + "104.18.112.0/24", + "104.18.113.0/24", + "104.18.114.0/24", + "104.18.115.0/24", + "104.18.116.0/24", + "104.18.117.0/24", + "104.18.118.0/24", + "104.18.119.0/24", + "104.18.120.0/24", + "104.18.121.0/24", + "104.18.122.0/24", + "104.18.123.0/24", + "104.18.124.0/24", + "104.18.125.0/24", + "104.18.126.0/24", + "104.18.127.0/24", + "104.18.128.0/24", + "104.18.129.0/24", + "104.18.130.0/24", + "104.18.131.0/24", + "104.18.132.0/24", + "104.18.133.0/24", + "104.18.134.0/24", + "104.18.135.0/24", + "104.18.136.0/24", + "104.18.137.0/24", + "104.18.138.0/24", + "104.18.139.0/24", + "104.18.140.0/24", + "104.18.141.0/24", + "104.18.142.0/24", + "104.18.143.0/24", + "104.18.144.0/24", + "104.18.145.0/24", + "104.18.146.0/24", + "104.18.147.0/24", + "104.18.148.0/24", + "104.18.149.0/24", + "104.18.150.0/24", + "104.18.151.0/24", + "104.18.152.0/24", + "104.18.153.0/24", + "104.18.154.0/24", + "104.18.155.0/24", + "104.18.156.0/24", + "104.18.157.0/24", + "104.18.158.0/24", + "104.18.159.0/24", + "104.18.160.0/24", + "104.18.161.0/24", + "104.18.162.0/24", + "104.18.163.0/24", + "104.18.164.0/24", + "104.18.165.0/24", + "104.18.166.0/24", + "104.18.167.0/24", + "104.18.168.0/24", + "104.18.169.0/24", + "104.18.170.0/24", + "104.18.171.0/24", + "104.18.172.0/24", + "104.18.173.0/24", + "104.18.174.0/24", + "104.18.175.0/24", + "104.18.176.0/24", + "104.18.177.0/24", + "104.18.178.0/24", + "104.18.179.0/24", + "104.18.180.0/24", + "104.18.181.0/24", + "104.18.182.0/24", + "104.18.183.0/24", + "104.18.184.0/24", + "104.18.185.0/24", + "104.18.186.0/24", + "104.18.187.0/24", + "104.18.188.0/24", + "104.18.189.0/24", + "104.18.190.0/24", + "104.18.191.0/24", + "104.18.192.0/24", + "104.18.193.0/24", + "104.18.194.0/24", + "104.18.195.0/24", + "104.18.196.0/24", + "104.18.197.0/24", + "104.18.198.0/24", + "104.18.199.0/24", + "104.18.200.0/24", + "104.18.201.0/24", + "104.18.202.0/24", + "104.18.203.0/24", + "104.18.204.0/24", + "104.18.205.0/24", + "104.18.206.0/24", + "104.18.207.0/24", + "104.18.208.0/24", + "104.18.209.0/24", + "104.18.210.0/24", + "104.18.211.0/24", + "104.18.212.0/24", + "104.18.213.0/24", + "104.18.214.0/24", + "104.18.215.0/24", + "104.18.216.0/24", + "104.18.217.0/24", + "104.18.218.0/24", + "104.18.219.0/24", + "104.18.220.0/24", + "104.18.221.0/24", + "104.18.222.0/24", + "104.18.223.0/24", + "104.18.224.0/24", + "104.18.225.0/24", + "104.18.226.0/24", + "104.18.227.0/24", + "104.18.228.0/24", + "104.18.229.0/24", + "104.18.230.0/24", + "104.18.231.0/24", + "104.18.232.0/24", + "104.18.233.0/24", + "104.18.234.0/24", + "104.18.235.0/24", + "104.18.236.0/24", + "104.18.237.0/24", + "104.18.238.0/24", + "104.18.239.0/24", + "104.18.240.0/24", + "104.18.241.0/24", + "104.18.242.0/24", + "104.18.243.0/24", + "104.18.244.0/24", + "104.18.245.0/24", + "104.18.246.0/24", + "104.18.247.0/24", + "104.18.248.0/24", + "104.18.249.0/24", + "104.18.250.0/24", + "104.18.251.0/24", + "104.18.252.0/24", + "104.18.253.0/24", + "104.18.254.0/24", + "104.18.255.0/24", + "104.19.0.0/24", + "104.19.1.0/24", + "104.19.2.0/24", + "104.19.3.0/24", + "104.19.4.0/24", + "104.19.5.0/24", + "104.19.6.0/24", + "104.19.7.0/24", + "104.19.8.0/24", + "104.19.9.0/24", + "104.19.10.0/24", + "104.19.11.0/24", + "104.19.12.0/24", + "104.19.13.0/24", + "104.19.14.0/24", + "104.19.15.0/24", + "104.19.16.0/24", + "104.19.17.0/24", + "104.19.18.0/24", + "104.19.19.0/24", + "104.19.20.0/24", + "104.19.21.0/24", + "104.19.22.0/24", + "104.19.23.0/24", + "104.19.24.0/24", + "104.19.25.0/24", + "104.19.26.0/24", + "104.19.27.0/24", + "104.19.28.0/24", + "104.19.29.0/24", + "104.19.30.0/24", + "104.19.31.0/24", + "104.19.32.0/24", + "104.19.33.0/24", + "104.19.34.0/24", + "104.19.35.0/24", + "104.19.36.0/24", + "104.19.37.0/24", + "104.19.38.0/24", + "104.19.39.0/24", + "104.19.40.0/24", + "104.19.41.0/24", + "104.19.42.0/24", + "104.19.43.0/24", + "104.19.44.0/24", + "104.19.45.0/24", + "104.19.46.0/24", + "104.19.47.0/24", + "104.19.48.0/24", + "104.19.49.0/24", + "104.19.50.0/24", + "104.19.51.0/24", + "104.19.52.0/24", + "104.19.53.0/24", + "104.19.54.0/24", + "104.19.55.0/24", + "104.19.56.0/24", + "104.19.57.0/24", + "104.19.58.0/24", + "104.19.59.0/24", + "104.19.60.0/24", + "104.19.61.0/24", + "104.19.62.0/24", + "104.19.63.0/24", + "104.19.64.0/24", + "104.19.65.0/24", + "104.19.66.0/24", + "104.19.67.0/24", + "104.19.68.0/24", + "104.19.69.0/24", + "104.19.70.0/24", + "104.19.71.0/24", + "104.19.72.0/24", + "104.19.73.0/24", + "104.19.74.0/24", + "104.19.75.0/24", + "104.19.76.0/24", + "104.19.77.0/24", + "104.19.78.0/24", + "104.19.79.0/24", + "104.19.80.0/24", + "104.19.81.0/24", + "104.19.82.0/24", + "104.19.83.0/24", + "104.19.84.0/24", + "104.19.85.0/24", + "104.19.86.0/24", + "104.19.87.0/24", + "104.19.88.0/24", + "104.19.89.0/24", + "104.19.90.0/24", + "104.19.91.0/24", + "104.19.92.0/24", + "104.19.93.0/24", + "104.19.94.0/24", + "104.19.95.0/24", + "104.19.96.0/24", + "104.19.97.0/24", + "104.19.98.0/24", + "104.19.99.0/24", + "104.19.100.0/24", + "104.19.101.0/24", + "104.19.102.0/24", + "104.19.103.0/24", + "104.19.104.0/24", + "104.19.105.0/24", + "104.19.106.0/24", + "104.19.107.0/24", + "104.19.108.0/24", + "104.19.109.0/24", + "104.19.110.0/24", + "104.19.111.0/24", + "104.19.112.0/24", + "104.19.113.0/24", + "104.19.114.0/24", + "104.19.115.0/24", + "104.19.116.0/24", + "104.19.117.0/24", + "104.19.118.0/24", + "104.19.119.0/24", + "104.19.120.0/24", + "104.19.121.0/24", + "104.19.122.0/24", + "104.19.123.0/24", + "104.19.124.0/24", + "104.19.125.0/24", + "104.19.126.0/24", + "104.19.127.0/24", + "104.19.128.0/24", + "104.19.129.0/24", + "104.19.130.0/24", + "104.19.131.0/24", + "104.19.132.0/24", + "104.19.133.0/24", + "104.19.134.0/24", + "104.19.135.0/24", + "104.19.136.0/24", + "104.19.137.0/24", + "104.19.138.0/24", + "104.19.139.0/24", + "104.19.140.0/24", + "104.19.141.0/24", + "104.19.142.0/24", + "104.19.143.0/24", + "104.19.144.0/24", + "104.19.145.0/24", + "104.19.146.0/24", + "104.19.147.0/24", + "104.19.148.0/24", + "104.19.149.0/24", + "104.19.150.0/24", + "104.19.151.0/24", + "104.19.152.0/24", + "104.19.153.0/24", + "104.19.154.0/24", + "104.19.155.0/24", + "104.19.156.0/24", + "104.19.157.0/24", + "104.19.158.0/24", + "104.19.159.0/24", + "104.19.160.0/24", + "104.19.161.0/24", + "104.19.162.0/24", + "104.19.163.0/24", + "104.19.164.0/24", + "104.19.165.0/24", + "104.19.166.0/24", + "104.19.167.0/24", + "104.19.168.0/24", + "104.19.169.0/24", + "104.19.170.0/24", + "104.19.171.0/24", + "104.19.172.0/24", + "104.19.173.0/24", + "104.19.174.0/24", + "104.19.175.0/24", + "104.19.176.0/24", + "104.19.177.0/24", + "104.19.178.0/24", + "104.19.179.0/24", + "104.19.180.0/24", + "104.19.181.0/24", + "104.19.182.0/24", + "104.19.183.0/24", + "104.19.184.0/24", + "104.19.185.0/24", + "104.19.186.0/24", + "104.19.187.0/24", + "104.19.188.0/24", + "104.19.189.0/24", + "104.19.190.0/24", + "104.19.191.0/24", + "104.19.192.0/24", + "104.19.193.0/24", + "104.19.194.0/24", + "104.19.195.0/24", + "104.19.196.0/24", + "104.19.197.0/24", + "104.19.198.0/24", + "104.19.199.0/24", + "104.19.200.0/24", + "104.19.201.0/24", + "104.19.202.0/24", + "104.19.203.0/24", + "104.19.204.0/24", + "104.19.205.0/24", + "104.19.206.0/24", + "104.19.207.0/24", + "104.19.208.0/24", + "104.19.209.0/24", + "104.19.210.0/24", + "104.19.211.0/24", + "104.19.212.0/24", + "104.19.213.0/24", + "104.19.214.0/24", + "104.19.215.0/24", + "104.19.216.0/24", + "104.19.217.0/24", + "104.19.218.0/24", + "104.19.219.0/24", + "104.19.220.0/24", + "104.19.221.0/24", + "104.19.222.0/24", + "104.19.223.0/24", + "104.19.224.0/24", + "104.19.225.0/24", + "104.19.226.0/24", + "104.19.227.0/24", + "104.19.228.0/24", + "104.19.229.0/24", + "104.19.230.0/24", + "104.19.231.0/24", + "104.19.232.0/24", + "104.19.233.0/24", + "104.19.234.0/24", + "104.19.235.0/24", + "104.19.236.0/24", + "104.19.237.0/24", + "104.19.238.0/24", + "104.19.239.0/24", + "104.19.240.0/24", + "104.19.241.0/24", + "104.19.242.0/24", + "104.19.243.0/24", + "104.19.244.0/24", + "104.19.245.0/24", + "104.19.246.0/24", + "104.19.247.0/24", + "104.19.248.0/24", + "104.19.249.0/24", + "104.19.250.0/24", + "104.19.251.0/24", + "104.19.252.0/24", + "104.19.253.0/24", + "104.19.254.0/24", + "104.19.255.0/24", + "104.20.0.0/24", + "104.20.1.0/24", + "104.20.2.0/24", + "104.20.3.0/24", + "104.20.4.0/24", + "104.20.5.0/24", + "104.20.6.0/24", + "104.20.7.0/24", + "104.20.8.0/24", + "104.20.9.0/24", + "104.20.10.0/24", + "104.20.11.0/24", + "104.20.12.0/24", + "104.20.13.0/24", + "104.20.14.0/24", + "104.20.15.0/24", + "104.20.16.0/24", + "104.20.17.0/24", + "104.20.18.0/24", + "104.20.19.0/24", + "104.20.20.0/24", + "104.20.21.0/24", + "104.20.22.0/24", + "104.20.23.0/24", + "104.20.24.0/24", + "104.20.25.0/24", + "104.20.26.0/24", + "104.20.27.0/24", + "104.20.28.0/24", + "104.20.29.0/24", + "104.20.30.0/24", + "104.20.31.0/24", + "104.20.32.0/24", + "104.20.33.0/24", + "104.20.34.0/24", + "104.20.35.0/24", + "104.20.36.0/24", + "104.20.37.0/24", + "104.20.38.0/24", + "104.20.39.0/24", + "104.20.40.0/24", + "104.20.41.0/24", + "104.20.42.0/24", + "104.20.43.0/24", + "104.20.44.0/24", + "104.20.45.0/24", + "104.20.46.0/24", + "104.20.47.0/24", + "104.20.48.0/24", + "104.20.49.0/24", + "104.20.50.0/24", + "104.20.51.0/24", + "104.20.52.0/24", + "104.20.53.0/24", + "104.20.54.0/24", + "104.20.55.0/24", + "104.20.56.0/24", + "104.20.57.0/24", + "104.20.58.0/24", + "104.20.59.0/24", + "104.20.60.0/24", + "104.20.61.0/24", + "104.20.62.0/24", + "104.20.63.0/24", + "104.20.64.0/24", + "104.20.65.0/24", + "104.20.66.0/24", + "104.20.67.0/24", + "104.20.68.0/24", + "104.20.69.0/24", + "104.20.70.0/24", + "104.20.71.0/24", + "104.20.72.0/24", + "104.20.73.0/24", + "104.20.74.0/24", + "104.20.75.0/24", + "104.20.76.0/24", + "104.20.77.0/24", + "104.20.78.0/24", + "104.20.79.0/24", + "104.20.80.0/24", + "104.20.81.0/24", + "104.20.82.0/24", + "104.20.83.0/24", + "104.20.84.0/24", + "104.20.85.0/24", + "104.20.86.0/24", + "104.20.87.0/24", + "104.20.88.0/24", + "104.20.89.0/24", + "104.20.90.0/24", + "104.20.91.0/24", + "104.20.92.0/24", + "104.20.93.0/24", + "104.20.94.0/24", + "104.20.95.0/24", + "104.20.96.0/24", + "104.20.97.0/24", + "104.20.98.0/24", + "104.20.99.0/24", + "104.20.100.0/24", + "104.20.101.0/24", + "104.20.102.0/24", + "104.20.103.0/24", + "104.20.104.0/24", + "104.20.105.0/24", + "104.20.106.0/24", + "104.20.107.0/24", + "104.20.108.0/24", + "104.20.109.0/24", + "104.20.110.0/24", + "104.20.111.0/24", + "104.20.112.0/24", + "104.20.113.0/24", + "104.20.114.0/24", + "104.20.115.0/24", + "104.20.116.0/24", + "104.20.117.0/24", + "104.20.118.0/24", + "104.20.119.0/24", + "104.20.120.0/24", + "104.20.121.0/24", + "104.20.122.0/24", + "104.20.123.0/24", + "104.20.124.0/24", + "104.20.125.0/24", + "104.20.126.0/24", + "104.20.127.0/24", + "104.20.128.0/24", + "104.20.129.0/24", + "104.20.130.0/24", + "104.20.131.0/24", + "104.20.132.0/24", + "104.20.133.0/24", + "104.20.134.0/24", + "104.20.135.0/24", + "104.20.136.0/24", + "104.20.137.0/24", + "104.20.138.0/24", + "104.20.139.0/24", + "104.20.140.0/24", + "104.20.141.0/24", + "104.20.142.0/24", + "104.20.143.0/24", + "104.20.144.0/24", + "104.20.145.0/24", + "104.20.146.0/24", + "104.20.147.0/24", + "104.20.148.0/24", + "104.20.149.0/24", + "104.20.150.0/24", + "104.20.151.0/24", + "104.20.152.0/24", + "104.20.153.0/24", + "104.20.154.0/24", + "104.20.155.0/24", + "104.20.156.0/24", + "104.20.157.0/24", + "104.20.158.0/24", + "104.20.159.0/24", + "104.20.160.0/24", + "104.20.161.0/24", + "104.20.162.0/24", + "104.20.163.0/24", + "104.20.164.0/24", + "104.20.165.0/24", + "104.20.166.0/24", + "104.20.167.0/24", + "104.20.168.0/24", + "104.20.169.0/24", + "104.20.170.0/24", + "104.20.171.0/24", + "104.20.172.0/24", + "104.20.173.0/24", + "104.20.174.0/24", + "104.20.175.0/24", + "104.20.176.0/24", + "104.20.177.0/24", + "104.20.178.0/24", + "104.20.179.0/24", + "104.20.180.0/24", + "104.20.181.0/24", + "104.20.182.0/24", + "104.20.183.0/24", + "104.20.184.0/24", + "104.20.185.0/24", + "104.20.186.0/24", + "104.20.187.0/24", + "104.20.188.0/24", + "104.20.189.0/24", + "104.20.190.0/24", + "104.20.191.0/24", + "104.20.192.0/24", + "104.20.193.0/24", + "104.20.194.0/24", + "104.20.195.0/24", + "104.20.196.0/24", + "104.20.197.0/24", + "104.20.198.0/24", + "104.20.199.0/24", + "104.20.200.0/24", + "104.20.201.0/24", + "104.20.202.0/24", + "104.20.203.0/24", + "104.20.204.0/24", + "104.20.205.0/24", + "104.20.206.0/24", + "104.20.207.0/24", + "104.20.208.0/24", + "104.20.209.0/24", + "104.20.210.0/24", + "104.20.211.0/24", + "104.20.212.0/24", + "104.20.213.0/24", + "104.20.214.0/24", + "104.20.215.0/24", + "104.20.216.0/24", + "104.20.217.0/24", + "104.20.218.0/24", + "104.20.219.0/24", + "104.20.220.0/24", + "104.20.221.0/24", + "104.20.222.0/24", + "104.20.223.0/24", + "104.20.224.0/24", + "104.20.225.0/24", + "104.20.226.0/24", + "104.20.227.0/24", + "104.20.228.0/24", + "104.20.229.0/24", + "104.20.230.0/24", + "104.20.231.0/24", + "104.20.232.0/24", + "104.20.233.0/24", + "104.20.234.0/24", + "104.20.235.0/24", + "104.20.236.0/24", + "104.20.237.0/24", + "104.20.238.0/24", + "104.20.239.0/24", + "104.20.240.0/24", + "104.20.241.0/24", + "104.20.242.0/24", + "104.20.243.0/24", + "104.20.244.0/24", + "104.20.245.0/24", + "104.20.246.0/24", + "104.20.247.0/24", + "104.20.248.0/24", + "104.20.249.0/24", + "104.20.250.0/24", + "104.20.251.0/24", + "104.20.252.0/24", + "104.20.253.0/24", + "104.20.254.0/24", + "104.20.255.0/24", + "104.21.0.0/24", + "104.21.1.0/24", + "104.21.2.0/24", + "104.21.3.0/24", + "104.21.4.0/24", + "104.21.5.0/24", + "104.21.6.0/24", + "104.21.7.0/24", + "104.21.8.0/24", + "104.21.9.0/24", + "104.21.10.0/24", + "104.21.11.0/24", + "104.21.12.0/24", + "104.21.13.0/24", + "104.21.14.0/24", + "104.21.15.0/24", + "104.21.16.0/24", + "104.21.17.0/24", + "104.21.18.0/24", + "104.21.19.0/24", + "104.21.20.0/24", + "104.21.21.0/24", + "104.21.22.0/24", + "104.21.23.0/24", + "104.21.24.0/24", + "104.21.25.0/24", + "104.21.26.0/24", + "104.21.27.0/24", + "104.21.28.0/24", + "104.21.29.0/24", + "104.21.30.0/24", + "104.21.31.0/24", + "104.21.32.0/24", + "104.21.33.0/24", + "104.21.34.0/24", + "104.21.35.0/24", + "104.21.36.0/24", + "104.21.37.0/24", + "104.21.38.0/24", + "104.21.39.0/24", + "104.21.40.0/24", + "104.21.41.0/24", + "104.21.42.0/24", + "104.21.43.0/24", + "104.21.44.0/24", + "104.21.45.0/24", + "104.21.46.0/24", + "104.21.47.0/24", + "104.21.48.0/24", + "104.21.49.0/24", + "104.21.50.0/24", + "104.21.51.0/24", + "104.21.52.0/24", + "104.21.53.0/24", + "104.21.54.0/24", + "104.21.55.0/24", + "104.21.56.0/24", + "104.21.57.0/24", + "104.21.58.0/24", + "104.21.59.0/24", + "104.21.60.0/24", + "104.21.61.0/24", + "104.21.62.0/24", + "104.21.63.0/24", + "104.21.64.0/24", + "104.21.65.0/24", + "104.21.66.0/24", + "104.21.67.0/24", + "104.21.68.0/24", + "104.21.69.0/24", + "104.21.70.0/24", + "104.21.71.0/24", + "104.21.72.0/24", + "104.21.73.0/24", + "104.21.74.0/24", + "104.21.75.0/24", + "104.21.76.0/24", + "104.21.77.0/24", + "104.21.78.0/24", + "104.21.79.0/24", + "104.21.80.0/24", + "104.21.81.0/24", + "104.21.82.0/24", + "104.21.83.0/24", + "104.21.84.0/24", + "104.21.85.0/24", + "104.21.86.0/24", + "104.21.87.0/24", + "104.21.88.0/24", + "104.21.89.0/24", + "104.21.90.0/24", + "104.21.91.0/24", + "104.21.92.0/24", + "104.21.93.0/24", + "104.21.94.0/24", + "104.21.95.0/24", + "104.21.96.0/24", + "104.21.97.0/24", + "104.21.98.0/24", + "104.21.99.0/24", + "104.21.100.0/24", + "104.21.101.0/24", + "104.21.102.0/24", + "104.21.103.0/24", + "104.21.104.0/24", + "104.21.105.0/24", + "104.21.106.0/24", + "104.21.107.0/24", + "104.21.108.0/24", + "104.21.109.0/24", + "104.21.110.0/24", + "104.21.111.0/24", + "104.21.112.0/24", + "104.21.113.0/24", + "104.21.114.0/24", + "104.21.115.0/24", + "104.21.116.0/24", + "104.21.117.0/24", + "104.21.118.0/24", + "104.21.119.0/24", + "104.21.120.0/24", + "104.21.121.0/24", + "104.21.122.0/24", + "104.21.123.0/24", + "104.21.124.0/24", + "104.21.125.0/24", + "104.21.126.0/24", + "104.21.127.0/24", + "104.21.128.0/24", + "104.21.129.0/24", + "104.21.130.0/24", + "104.21.131.0/24", + "104.21.132.0/24", + "104.21.133.0/24", + "104.21.134.0/24", + "104.21.135.0/24", + "104.21.136.0/24", + "104.21.137.0/24", + "104.21.138.0/24", + "104.21.139.0/24", + "104.21.140.0/24", + "104.21.141.0/24", + "104.21.142.0/24", + "104.21.143.0/24", + "104.21.144.0/24", + "104.21.145.0/24", + "104.21.146.0/24", + "104.21.147.0/24", + "104.21.148.0/24", + "104.21.149.0/24", + "104.21.150.0/24", + "104.21.151.0/24", + "104.21.152.0/24", + "104.21.153.0/24", + "104.21.154.0/24", + "104.21.155.0/24", + "104.21.156.0/24", + "104.21.157.0/24", + "104.21.158.0/24", + "104.21.159.0/24", + "104.21.160.0/24", + "104.21.161.0/24", + "104.21.162.0/24", + "104.21.163.0/24", + "104.21.164.0/24", + "104.21.165.0/24", + "104.21.166.0/24", + "104.21.167.0/24", + "104.21.168.0/24", + "104.21.169.0/24", + "104.21.170.0/24", + "104.21.171.0/24", + "104.21.172.0/24", + "104.21.173.0/24", + "104.21.174.0/24", + "104.21.175.0/24", + "104.21.176.0/24", + "104.21.177.0/24", + "104.21.178.0/24", + "104.21.179.0/24", + "104.21.180.0/24", + "104.21.181.0/24", + "104.21.182.0/24", + "104.21.183.0/24", + "104.21.184.0/24", + "104.21.185.0/24", + "104.21.186.0/24", + "104.21.187.0/24", + "104.21.188.0/24", + "104.21.189.0/24", + "104.21.190.0/24", + "104.21.191.0/24", + "104.21.192.0/24", + "104.21.193.0/24", + "104.21.194.0/24", + "104.21.195.0/24", + "104.21.196.0/24", + "104.21.197.0/24", + "104.21.198.0/24", + "104.21.199.0/24", + "104.21.200.0/24", + "104.21.201.0/24", + "104.21.202.0/24", + "104.21.203.0/24", + "104.21.204.0/24", + "104.21.205.0/24", + "104.21.206.0/24", + "104.21.207.0/24", + "104.21.208.0/24", + "104.21.209.0/24", + "104.21.210.0/24", + "104.21.211.0/24", + "104.21.212.0/24", + "104.21.213.0/24", + "104.21.214.0/24", + "104.21.215.0/24", + "104.21.216.0/24", + "104.21.217.0/24", + "104.21.218.0/24", + "104.21.219.0/24", + "104.21.220.0/24", + "104.21.221.0/24", + "104.21.222.0/24", + "104.21.223.0/24", + "104.21.224.0/24", + "104.21.225.0/24", + "104.21.226.0/24", + "104.21.227.0/24", + "104.21.228.0/24", + "104.21.229.0/24", + "104.21.230.0/24", + "104.21.231.0/24", + "104.21.232.0/24", + "104.21.233.0/24", + "104.21.234.0/24", + "104.21.235.0/24", + "104.21.236.0/24", + "104.21.237.0/24", + "104.21.238.0/24", + "104.21.239.0/24", + "104.21.240.0/24", + "104.21.241.0/24", + "104.21.242.0/24", + "104.21.243.0/24", + "104.21.244.0/24", + "104.21.245.0/24", + "104.21.246.0/24", + "104.21.247.0/24", + "104.21.248.0/24", + "104.21.249.0/24", + "104.21.250.0/24", + "104.21.251.0/24", + "104.21.252.0/24", + "104.21.253.0/24", + "104.21.254.0/24", + "104.21.255.0/24", + "104.22.0.0/24", + "104.22.1.0/24", + "104.22.2.0/24", + "104.22.3.0/24", + "104.22.4.0/24", + "104.22.5.0/24", + "104.22.6.0/24", + "104.22.7.0/24", + "104.22.8.0/24", + "104.22.9.0/24", + "104.22.10.0/24", + "104.22.11.0/24", + "104.22.12.0/24", + "104.22.13.0/24", + "104.22.14.0/24", + "104.22.15.0/24", + "104.22.16.0/24", + "104.22.17.0/24", + "104.22.18.0/24", + "104.22.19.0/24", + "104.22.20.0/24", + "104.22.21.0/24", + "104.22.22.0/24", + "104.22.23.0/24", + "104.22.24.0/24", + "104.22.25.0/24", + "104.22.26.0/24", + "104.22.27.0/24", + "104.22.28.0/24", + "104.22.29.0/24", + "104.22.30.0/24", + "104.22.31.0/24", + "104.22.32.0/24", + "104.22.33.0/24", + "104.22.34.0/24", + "104.22.35.0/24", + "104.22.36.0/24", + "104.22.37.0/24", + "104.22.38.0/24", + "104.22.39.0/24", + "104.22.40.0/24", + "104.22.41.0/24", + "104.22.42.0/24", + "104.22.43.0/24", + "104.22.44.0/24", + "104.22.45.0/24", + "104.22.46.0/24", + "104.22.47.0/24", + "104.22.48.0/24", + "104.22.49.0/24", + "104.22.50.0/24", + "104.22.51.0/24", + "104.22.52.0/24", + "104.22.53.0/24", + "104.22.54.0/24", + "104.22.55.0/24", + "104.22.56.0/24", + "104.22.57.0/24", + "104.22.58.0/24", + "104.22.59.0/24", + "104.22.60.0/24", + "104.22.61.0/24", + "104.22.62.0/24", + "104.22.63.0/24", + "104.22.64.0/24", + "104.22.65.0/24", + "104.22.66.0/24", + "104.22.67.0/24", + "104.22.68.0/24", + "104.22.69.0/24", + "104.22.70.0/24", + "104.22.71.0/24", + "104.22.72.0/24", + "104.22.73.0/24", + "104.22.74.0/24", + "104.22.75.0/24", + "104.22.76.0/24", + "104.22.77.0/24", + "104.22.78.0/24", + "104.22.79.0/24", + "104.22.80.0/24", + "104.22.81.0/24", + "104.22.82.0/24", + "104.22.83.0/24", + "104.22.84.0/24", + "104.22.85.0/24", + "104.22.86.0/24", + "104.22.87.0/24", + "104.22.88.0/24", + "104.22.89.0/24", + "104.22.90.0/24", + "104.22.91.0/24", + "104.22.92.0/24", + "104.22.93.0/24", + "104.22.94.0/24", + "104.22.95.0/24", + "104.22.96.0/24", + "104.22.97.0/24", + "104.22.98.0/24", + "104.22.99.0/24", + "104.22.100.0/24", + "104.22.101.0/24", + "104.22.102.0/24", + "104.22.103.0/24", + "104.22.104.0/24", + "104.22.105.0/24", + "104.22.106.0/24", + "104.22.107.0/24", + "104.22.108.0/24", + "104.22.109.0/24", + "104.22.110.0/24", + "104.22.111.0/24", + "104.22.112.0/24", + "104.22.113.0/24", + "104.22.114.0/24", + "104.22.115.0/24", + "104.22.116.0/24", + "104.22.117.0/24", + "104.22.118.0/24", + "104.22.119.0/24", + "104.22.120.0/24", + "104.22.121.0/24", + "104.22.122.0/24", + "104.22.123.0/24", + "104.22.124.0/24", + "104.22.125.0/24", + "104.22.126.0/24", + "104.22.127.0/24", + "104.22.128.0/24", + "104.22.129.0/24", + "104.22.130.0/24", + "104.22.131.0/24", + "104.22.132.0/24", + "104.22.133.0/24", + "104.22.134.0/24", + "104.22.135.0/24", + "104.22.136.0/24", + "104.22.137.0/24", + "104.22.138.0/24", + "104.22.139.0/24", + "104.22.140.0/24", + "104.22.141.0/24", + "104.22.142.0/24", + "104.22.143.0/24", + "104.22.144.0/24", + "104.22.145.0/24", + "104.22.146.0/24", + "104.22.147.0/24", + "104.22.148.0/24", + "104.22.149.0/24", + "104.22.150.0/24", + "104.22.151.0/24", + "104.22.152.0/24", + "104.22.153.0/24", + "104.22.154.0/24", + "104.22.155.0/24", + "104.22.156.0/24", + "104.22.157.0/24", + "104.22.158.0/24", + "104.22.159.0/24", + "104.22.160.0/24", + "104.22.161.0/24", + "104.22.162.0/24", + "104.22.163.0/24", + "104.22.164.0/24", + "104.22.165.0/24", + "104.22.166.0/24", + "104.22.167.0/24", + "104.22.168.0/24", + "104.22.169.0/24", + "104.22.170.0/24", + "104.22.171.0/24", + "104.22.172.0/24", + "104.22.173.0/24", + "104.22.174.0/24", + "104.22.175.0/24", + "104.22.176.0/24", + "104.22.177.0/24", + "104.22.178.0/24", + "104.22.179.0/24", + "104.22.180.0/24", + "104.22.181.0/24", + "104.22.182.0/24", + "104.22.183.0/24", + "104.22.184.0/24", + "104.22.185.0/24", + "104.22.186.0/24", + "104.22.187.0/24", + "104.22.188.0/24", + "104.22.189.0/24", + "104.22.190.0/24", + "104.22.191.0/24", + "104.22.192.0/24", + "104.22.193.0/24", + "104.22.194.0/24", + "104.22.195.0/24", + "104.22.196.0/24", + "104.22.197.0/24", + "104.22.198.0/24", + "104.22.199.0/24", + "104.22.200.0/24", + "104.22.201.0/24", + "104.22.202.0/24", + "104.22.203.0/24", + "104.22.204.0/24", + "104.22.205.0/24", + "104.22.206.0/24", + "104.22.207.0/24", + "104.22.208.0/24", + "104.22.209.0/24", + "104.22.210.0/24", + "104.22.211.0/24", + "104.22.212.0/24", + "104.22.213.0/24", + "104.22.214.0/24", + "104.22.215.0/24", + "104.22.216.0/24", + "104.22.217.0/24", + "104.22.218.0/24", + "104.22.219.0/24", + "104.22.220.0/24", + "104.22.221.0/24", + "104.22.222.0/24", + "104.22.223.0/24", + "104.22.224.0/24", + "104.22.225.0/24", + "104.22.226.0/24", + "104.22.227.0/24", + "104.22.228.0/24", + "104.22.229.0/24", + "104.22.230.0/24", + "104.22.231.0/24", + "104.22.232.0/24", + "104.22.233.0/24", + "104.22.234.0/24", + "104.22.235.0/24", + "104.22.236.0/24", + "104.22.237.0/24", + "104.22.238.0/24", + "104.22.239.0/24", + "104.22.240.0/24", + "104.22.241.0/24", + "104.22.242.0/24", + "104.22.243.0/24", + "104.22.244.0/24", + "104.22.245.0/24", + "104.22.246.0/24", + "104.22.247.0/24", + "104.22.248.0/24", + "104.22.249.0/24", + "104.22.250.0/24", + "104.22.251.0/24", + "104.22.252.0/24", + "104.22.253.0/24", + "104.22.254.0/24", + "104.22.255.0/24", + "104.23.0.0/24", + "104.23.1.0/24", + "104.23.2.0/24", + "104.23.3.0/24", + "104.23.4.0/24", + "104.23.5.0/24", + "104.23.6.0/24", + "104.23.7.0/24", + "104.23.8.0/24", + "104.23.9.0/24", + "104.23.10.0/24", + "104.23.11.0/24", + "104.23.12.0/24", + "104.23.13.0/24", + "104.23.14.0/24", + "104.23.15.0/24", + "104.23.16.0/24", + "104.23.17.0/24", + "104.23.18.0/24", + "104.23.19.0/24", + "104.23.20.0/24", + "104.23.21.0/24", + "104.23.22.0/24", + "104.23.23.0/24", + "104.23.24.0/24", + "104.23.25.0/24", + "104.23.26.0/24", + "104.23.27.0/24", + "104.23.28.0/24", + "104.23.29.0/24", + "104.23.30.0/24", + "104.23.31.0/24", + "104.23.32.0/24", + "104.23.33.0/24", + "104.23.34.0/24", + "104.23.35.0/24", + "104.23.36.0/24", + "104.23.37.0/24", + "104.23.38.0/24", + "104.23.39.0/24", + "104.23.40.0/24", + "104.23.41.0/24", + "104.23.42.0/24", + "104.23.43.0/24", + "104.23.44.0/24", + "104.23.45.0/24", + "104.23.46.0/24", + "104.23.47.0/24", + "104.23.48.0/24", + "104.23.49.0/24", + "104.23.50.0/24", + "104.23.51.0/24", + "104.23.52.0/24", + "104.23.53.0/24", + "104.23.54.0/24", + "104.23.55.0/24", + "104.23.56.0/24", + "104.23.57.0/24", + "104.23.58.0/24", + "104.23.59.0/24", + "104.23.60.0/24", + "104.23.61.0/24", + "104.23.62.0/24", + "104.23.63.0/24", + "104.23.64.0/24", + "104.23.65.0/24", + "104.23.66.0/24", + "104.23.67.0/24", + "104.23.68.0/24", + "104.23.69.0/24", + "104.23.70.0/24", + "104.23.71.0/24", + "104.23.72.0/24", + "104.23.73.0/24", + "104.23.74.0/24", + "104.23.75.0/24", + "104.23.76.0/24", + "104.23.77.0/24", + "104.23.78.0/24", + "104.23.79.0/24", + "104.23.80.0/24", + "104.23.81.0/24", + "104.23.82.0/24", + "104.23.83.0/24", + "104.23.84.0/24", + "104.23.85.0/24", + "104.23.86.0/24", + "104.23.87.0/24", + "104.23.88.0/24", + "104.23.89.0/24", + "104.23.90.0/24", + "104.23.91.0/24", + "104.23.92.0/24", + "104.23.93.0/24", + "104.23.94.0/24", + "104.23.95.0/24", + "104.23.96.0/24", + "104.23.97.0/24", + "104.23.98.0/24", + "104.23.99.0/24", + "104.23.100.0/24", + "104.23.101.0/24", + "104.23.102.0/24", + "104.23.103.0/24", + "104.23.104.0/24", + "104.23.105.0/24", + "104.23.106.0/24", + "104.23.107.0/24", + "104.23.108.0/24", + "104.23.109.0/24", + "104.23.110.0/24", + "104.23.111.0/24", + "104.23.112.0/24", + "104.23.113.0/24", + "104.23.114.0/24", + "104.23.115.0/24", + "104.23.116.0/24", + "104.23.117.0/24", + "104.23.118.0/24", + "104.23.119.0/24", + "104.23.120.0/24", + "104.23.121.0/24", + "104.23.122.0/24", + "104.23.123.0/24", + "104.23.124.0/24", + "104.23.125.0/24", + "104.23.126.0/24", + "104.23.127.0/24", + "104.23.128.0/24", + "104.23.129.0/24", + "104.23.130.0/24", + "104.23.131.0/24", + "104.23.132.0/24", + "104.23.133.0/24", + "104.23.134.0/24", + "104.23.135.0/24", + "104.23.136.0/24", + "104.23.137.0/24", + "104.23.138.0/24", + "104.23.139.0/24", + "104.23.140.0/24", + "104.23.141.0/24", + "104.23.142.0/24", + "104.23.143.0/24", + "104.23.144.0/24", + "104.23.145.0/24", + "104.23.146.0/24", + "104.23.147.0/24", + "104.23.148.0/24", + "104.23.149.0/24", + "104.23.150.0/24", + "104.23.151.0/24", + "104.23.152.0/24", + "104.23.153.0/24", + "104.23.154.0/24", + "104.23.155.0/24", + "104.23.156.0/24", + "104.23.157.0/24", + "104.23.158.0/24", + "104.23.159.0/24", + "104.23.160.0/24", + "104.23.161.0/24", + "104.23.162.0/24", + "104.23.163.0/24", + "104.23.164.0/24", + "104.23.165.0/24", + "104.23.166.0/24", + "104.23.167.0/24", + "104.23.168.0/24", + "104.23.169.0/24", + "104.23.170.0/24", + "104.23.171.0/24", + "104.23.172.0/24", + "104.23.173.0/24", + "104.23.174.0/24", + "104.23.175.0/24", + "104.23.176.0/24", + "104.23.177.0/24", + "104.23.178.0/24", + "104.23.179.0/24", + "104.23.180.0/24", + "104.23.181.0/24", + "104.23.182.0/24", + "104.23.183.0/24", + "104.23.184.0/24", + "104.23.185.0/24", + "104.23.186.0/24", + "104.23.187.0/24", + "104.23.188.0/24", + "104.23.189.0/24", + "104.23.190.0/24", + "104.23.191.0/24", + "104.23.192.0/24", + "104.23.193.0/24", + "104.23.194.0/24", + "104.23.195.0/24", + "104.23.196.0/24", + "104.23.197.0/24", + "104.23.198.0/24", + "104.23.199.0/24", + "104.23.200.0/24", + "104.23.201.0/24", + "104.23.202.0/24", + "104.23.203.0/24", + "104.23.204.0/24", + "104.23.205.0/24", + "104.23.206.0/24", + "104.23.207.0/24", + "104.23.208.0/24", + "104.23.209.0/24", + "104.23.210.0/24", + "104.23.211.0/24", + "104.23.212.0/24", + "104.23.213.0/24", + "104.23.214.0/24", + "104.23.215.0/24", + "104.23.216.0/24", + "104.23.217.0/24", + "104.23.218.0/24", + "104.23.219.0/24", + "104.23.220.0/24", + "104.23.221.0/24", + "104.23.222.0/24", + "104.23.223.0/24", + "104.23.224.0/24", + "104.23.225.0/24", + "104.23.226.0/24", + "104.23.227.0/24", + "104.23.228.0/24", + "104.23.229.0/24", + "104.23.230.0/24", + "104.23.231.0/24", + "104.23.232.0/24", + "104.23.233.0/24", + "104.23.234.0/24", + "104.23.235.0/24", + "104.23.236.0/24", + "104.23.237.0/24", + "104.23.238.0/24", + "104.23.239.0/24", + "104.23.240.0/24", + "104.23.241.0/24", + "104.23.242.0/24", + "104.23.243.0/24", + "104.23.244.0/24", + "104.23.245.0/24", + "104.23.246.0/24", + "104.23.247.0/24", + "104.23.248.0/24", + "104.23.249.0/24", + "104.23.250.0/24", + "104.23.251.0/24", + "104.23.252.0/24", + "104.23.253.0/24", + "104.23.254.0/24", + "104.23.255.0/24", + "104.24.0.0/24", + "104.24.1.0/24", + "104.24.2.0/24", + "104.24.3.0/24", + "104.24.4.0/24", + "104.24.5.0/24", + "104.24.6.0/24", + "104.24.7.0/24", + "104.24.8.0/24", + "104.24.9.0/24", + "104.24.10.0/24", + "104.24.11.0/24", + "104.24.12.0/24", + "104.24.13.0/24", + "104.24.14.0/24", + "104.24.15.0/24", + "104.24.16.0/24", + "104.24.17.0/24", + "104.24.18.0/24", + "104.24.19.0/24", + "104.24.20.0/24", + "104.24.21.0/24", + "104.24.22.0/24", + "104.24.23.0/24", + "104.24.24.0/24", + "104.24.25.0/24", + "104.24.26.0/24", + "104.24.27.0/24", + "104.24.28.0/24", + "104.24.29.0/24", + "104.24.30.0/24", + "104.24.31.0/24", + "104.24.32.0/24", + "104.24.33.0/24", + "104.24.34.0/24", + "104.24.35.0/24", + "104.24.36.0/24", + "104.24.37.0/24", + "104.24.38.0/24", + "104.24.39.0/24", + "104.24.40.0/24", + "104.24.41.0/24", + "104.24.42.0/24", + "104.24.43.0/24", + "104.24.44.0/24", + "104.24.45.0/24", + "104.24.46.0/24", + "104.24.47.0/24", + "104.24.48.0/24", + "104.24.49.0/24", + "104.24.50.0/24", + "104.24.51.0/24", + "104.24.52.0/24", + "104.24.53.0/24", + "104.24.54.0/24", + "104.24.55.0/24", + "104.24.56.0/24", + "104.24.57.0/24", + "104.24.58.0/24", + "104.24.59.0/24", + "104.24.60.0/24", + "104.24.61.0/24", + "104.24.62.0/24", + "104.24.63.0/24", + "104.24.64.0/24", + "104.24.65.0/24", + "104.24.66.0/24", + "104.24.67.0/24", + "104.24.68.0/24", + "104.24.69.0/24", + "104.24.70.0/24", + "104.24.71.0/24", + "104.24.72.0/24", + "104.24.73.0/24", + "104.24.74.0/24", + "104.24.75.0/24", + "104.24.76.0/24", + "104.24.77.0/24", + "104.24.78.0/24", + "104.24.79.0/24", + "104.24.80.0/24", + "104.24.81.0/24", + "104.24.82.0/24", + "104.24.83.0/24", + "104.24.84.0/24", + "104.24.85.0/24", + "104.24.86.0/24", + "104.24.87.0/24", + "104.24.88.0/24", + "104.24.89.0/24", + "104.24.90.0/24", + "104.24.91.0/24", + "104.24.92.0/24", + "104.24.93.0/24", + "104.24.94.0/24", + "104.24.95.0/24", + "104.24.96.0/24", + "104.24.97.0/24", + "104.24.98.0/24", + "104.24.99.0/24", + "104.24.100.0/24", + "104.24.101.0/24", + "104.24.102.0/24", + "104.24.103.0/24", + "104.24.104.0/24", + "104.24.105.0/24", + "104.24.106.0/24", + "104.24.107.0/24", + "104.24.108.0/24", + "104.24.109.0/24", + "104.24.110.0/24", + "104.24.111.0/24", + "104.24.112.0/24", + "104.24.113.0/24", + "104.24.114.0/24", + "104.24.115.0/24", + "104.24.116.0/24", + "104.24.117.0/24", + "104.24.118.0/24", + "104.24.119.0/24", + "104.24.120.0/24", + "104.24.121.0/24", + "104.24.122.0/24", + "104.24.123.0/24", + "104.24.124.0/24", + "104.24.125.0/24", + "104.24.126.0/24", + "104.24.127.0/24", + "104.24.128.0/24", + "104.24.129.0/24", + "104.24.130.0/24", + "104.24.131.0/24", + "104.24.132.0/24", + "104.24.133.0/24", + "104.24.134.0/24", + "104.24.135.0/24", + "104.24.136.0/24", + "104.24.137.0/24", + "104.24.138.0/24", + "104.24.139.0/24", + "104.24.140.0/24", + "104.24.141.0/24", + "104.24.142.0/24", + "104.24.143.0/24", + "104.24.144.0/24", + "104.24.145.0/24", + "104.24.146.0/24", + "104.24.147.0/24", + "104.24.148.0/24", + "104.24.149.0/24", + "104.24.150.0/24", + "104.24.151.0/24", + "104.24.152.0/24", + "104.24.153.0/24", + "104.24.154.0/24", + "104.24.155.0/24", + "104.24.156.0/24", + "104.24.157.0/24", + "104.24.158.0/24", + "104.24.159.0/24", + "104.24.160.0/24", + "104.24.161.0/24", + "104.24.162.0/24", + "104.24.163.0/24", + "104.24.164.0/24", + "104.24.165.0/24", + "104.24.166.0/24", + "104.24.167.0/24", + "104.24.168.0/24", + "104.24.169.0/24", + "104.24.170.0/24", + "104.24.171.0/24", + "104.24.172.0/24", + "104.24.173.0/24", + "104.24.174.0/24", + "104.24.175.0/24", + "104.24.176.0/24", + "104.24.177.0/24", + "104.24.178.0/24", + "104.24.179.0/24", + "104.24.180.0/24", + "104.24.181.0/24", + "104.24.182.0/24", + "104.24.183.0/24", + "104.24.184.0/24", + "104.24.185.0/24", + "104.24.186.0/24", + "104.24.187.0/24", + "104.24.188.0/24", + "104.24.189.0/24", + "104.24.190.0/24", + "104.24.191.0/24", + "104.24.192.0/24", + "104.24.193.0/24", + "104.24.194.0/24", + "104.24.195.0/24", + "104.24.196.0/24", + "104.24.197.0/24", + "104.24.198.0/24", + "104.24.199.0/24", + "104.24.200.0/24", + "104.24.201.0/24", + "104.24.202.0/24", + "104.24.203.0/24", + "104.24.204.0/24", + "104.24.205.0/24", + "104.24.206.0/24", + "104.24.207.0/24", + "104.24.208.0/24", + "104.24.209.0/24", + "104.24.210.0/24", + "104.24.211.0/24", + "104.24.212.0/24", + "104.24.213.0/24", + "104.24.214.0/24", + "104.24.215.0/24", + "104.24.216.0/24", + "104.24.217.0/24", + "104.24.218.0/24", + "104.24.219.0/24", + "104.24.220.0/24", + "104.24.221.0/24", + "104.24.222.0/24", + "104.24.223.0/24", + "104.24.224.0/24", + "104.24.225.0/24", + "104.24.226.0/24", + "104.24.227.0/24", + "104.24.228.0/24", + "104.24.229.0/24", + "104.24.230.0/24", + "104.24.231.0/24", + "104.24.232.0/24", + "104.24.233.0/24", + "104.24.234.0/24", + "104.24.235.0/24", + "104.24.236.0/24", + "104.24.237.0/24", + "104.24.238.0/24", + "104.24.239.0/24", + "104.24.240.0/24", + "104.24.241.0/24", + "104.24.242.0/24", + "104.24.243.0/24", + "104.24.244.0/24", + "104.24.245.0/24", + "104.24.246.0/24", + "104.24.247.0/24", + "104.24.248.0/24", + "104.24.249.0/24", + "104.24.250.0/24", + "104.24.251.0/24", + "104.24.252.0/24", + "104.24.253.0/24", + "104.24.254.0/24", + "104.24.255.0/24", + "104.25.0.0/24", + "104.25.1.0/24", + "104.25.2.0/24", + "104.25.3.0/24", + "104.25.4.0/24", + "104.25.5.0/24", + "104.25.6.0/24", + "104.25.7.0/24", + "104.25.8.0/24", + "104.25.9.0/24", + "104.25.10.0/24", + "104.25.11.0/24", + "104.25.12.0/24", + "104.25.13.0/24", + "104.25.14.0/24", + "104.25.15.0/24", + "104.25.16.0/24", + "104.25.17.0/24", + "104.25.18.0/24", + "104.25.19.0/24", + "104.25.20.0/24", + "104.25.21.0/24", + "104.25.22.0/24", + "104.25.23.0/24", + "104.25.24.0/24", + "104.25.25.0/24", + "104.25.26.0/24", + "104.25.27.0/24", + "104.25.28.0/24", + "104.25.29.0/24", + "104.25.30.0/24", + "104.25.31.0/24", + "104.25.32.0/24", + "104.25.33.0/24", + "104.25.34.0/24", + "104.25.35.0/24", + "104.25.36.0/24", + "104.25.37.0/24", + "104.25.38.0/24", + "104.25.39.0/24", + "104.25.40.0/24", + "104.25.41.0/24", + "104.25.42.0/24", + "104.25.43.0/24", + "104.25.44.0/24", + "104.25.45.0/24", + "104.25.46.0/24", + "104.25.47.0/24", + "104.25.48.0/24", + "104.25.49.0/24", + "104.25.50.0/24", + "104.25.51.0/24", + "104.25.52.0/24", + "104.25.53.0/24", + "104.25.54.0/24", + "104.25.55.0/24", + "104.25.56.0/24", + "104.25.57.0/24", + "104.25.58.0/24", + "104.25.59.0/24", + "104.25.60.0/24", + "104.25.61.0/24", + "104.25.62.0/24", + "104.25.63.0/24", + "104.25.64.0/24", + "104.25.65.0/24", + "104.25.66.0/24", + "104.25.67.0/24", + "104.25.68.0/24", + "104.25.69.0/24", + "104.25.70.0/24", + "104.25.71.0/24", + "104.25.72.0/24", + "104.25.73.0/24", + "104.25.74.0/24", + "104.25.75.0/24", + "104.25.76.0/24", + "104.25.77.0/24", + "104.25.78.0/24", + "104.25.79.0/24", + "104.25.80.0/24", + "104.25.81.0/24", + "104.25.82.0/24", + "104.25.83.0/24", + "104.25.84.0/24", + "104.25.85.0/24", + "104.25.86.0/24", + "104.25.87.0/24", + "104.25.88.0/24", + "104.25.89.0/24", + "104.25.90.0/24", + "104.25.91.0/24", + "104.25.92.0/24", + "104.25.93.0/24", + "104.25.94.0/24", + "104.25.95.0/24", + "104.25.96.0/24", + "104.25.97.0/24", + "104.25.98.0/24", + "104.25.99.0/24", + "104.25.100.0/24", + "104.25.101.0/24", + "104.25.102.0/24", + "104.25.103.0/24", + "104.25.104.0/24", + "104.25.105.0/24", + "104.25.106.0/24", + "104.25.107.0/24", + "104.25.108.0/24", + "104.25.109.0/24", + "104.25.110.0/24", + "104.25.111.0/24", + "104.25.112.0/24", + "104.25.113.0/24", + "104.25.114.0/24", + "104.25.115.0/24", + "104.25.116.0/24", + "104.25.117.0/24", + "104.25.118.0/24", + "104.25.119.0/24", + "104.25.120.0/24", + "104.25.121.0/24", + "104.25.122.0/24", + "104.25.123.0/24", + "104.25.124.0/24", + "104.25.125.0/24", + "104.25.126.0/24", + "104.25.127.0/24", + "104.25.128.0/24", + "104.25.129.0/24", + "104.25.130.0/24", + "104.25.131.0/24", + "104.25.132.0/24", + "104.25.133.0/24", + "104.25.134.0/24", + "104.25.135.0/24", + "104.25.136.0/24", + "104.25.137.0/24", + "104.25.138.0/24", + "104.25.139.0/24", + "104.25.140.0/24", + "104.25.141.0/24", + "104.25.142.0/24", + "104.25.143.0/24", + "104.25.144.0/24", + "104.25.145.0/24", + "104.25.146.0/24", + "104.25.147.0/24", + "104.25.148.0/24", + "104.25.149.0/24", + "104.25.150.0/24", + "104.25.151.0/24", + "104.25.152.0/24", + "104.25.153.0/24", + "104.25.154.0/24", + "104.25.155.0/24", + "104.25.156.0/24", + "104.25.157.0/24", + "104.25.158.0/24", + "104.25.159.0/24", + "104.25.160.0/24", + "104.25.161.0/24", + "104.25.162.0/24", + "104.25.163.0/24", + "104.25.164.0/24", + "104.25.165.0/24", + "104.25.166.0/24", + "104.25.167.0/24", + "104.25.168.0/24", + "104.25.169.0/24", + "104.25.170.0/24", + "104.25.171.0/24", + "104.25.172.0/24", + "104.25.173.0/24", + "104.25.174.0/24", + "104.25.175.0/24", + "104.25.176.0/24", + "104.25.177.0/24", + "104.25.178.0/24", + "104.25.179.0/24", + "104.25.180.0/24", + "104.25.181.0/24", + "104.25.182.0/24", + "104.25.183.0/24", + "104.25.184.0/24", + "104.25.185.0/24", + "104.25.186.0/24", + "104.25.187.0/24", + "104.25.188.0/24", + "104.25.189.0/24", + "104.25.190.0/24", + "104.25.191.0/24", + "104.25.192.0/24", + "104.25.193.0/24", + "104.25.194.0/24", + "104.25.195.0/24", + "104.25.196.0/24", + "104.25.197.0/24", + "104.25.198.0/24", + "104.25.199.0/24", + "104.25.200.0/24", + "104.25.201.0/24", + "104.25.202.0/24", + "104.25.203.0/24", + "104.25.204.0/24", + "104.25.205.0/24", + "104.25.206.0/24", + "104.25.207.0/24", + "104.25.208.0/24", + "104.25.209.0/24", + "104.25.210.0/24", + "104.25.211.0/24", + "104.25.212.0/24", + "104.25.213.0/24", + "104.25.214.0/24", + "104.25.215.0/24", + "104.25.216.0/24", + "104.25.217.0/24", + "104.25.218.0/24", + "104.25.219.0/24", + "104.25.220.0/24", + "104.25.221.0/24", + "104.25.222.0/24", + "104.25.223.0/24", + "104.25.224.0/24", + "104.25.225.0/24", + "104.25.226.0/24", + "104.25.227.0/24", + "104.25.228.0/24", + "104.25.229.0/24", + "104.25.230.0/24", + "104.25.231.0/24", + "104.25.232.0/24", + "104.25.233.0/24", + "104.25.234.0/24", + "104.25.235.0/24", + "104.25.236.0/24", + "104.25.237.0/24", + "104.25.238.0/24", + "104.25.239.0/24", + "104.25.240.0/24", + "104.25.241.0/24", + "104.25.242.0/24", + "104.25.243.0/24", + "104.25.244.0/24", + "104.25.245.0/24", + "104.25.246.0/24", + "104.25.247.0/24", + "104.25.248.0/24", + "104.25.249.0/24", + "104.25.250.0/24", + "104.25.251.0/24", + "104.25.252.0/24", + "104.25.253.0/24", + "104.25.254.0/24", + "104.25.255.0/24", + "104.26.0.0/24", + "104.26.1.0/24", + "104.26.2.0/24", + "104.26.3.0/24", + "104.26.4.0/24", + "104.26.5.0/24", + "104.26.6.0/24", + "104.26.7.0/24", + "104.26.8.0/24", + "104.26.9.0/24", + "104.26.10.0/24", + "104.26.11.0/24", + "104.26.12.0/24", + "104.26.13.0/24", + "104.26.14.0/24", + "104.26.15.0/24", + "104.26.16.0/24", + "104.26.17.0/24", + "104.26.18.0/24", + "104.26.19.0/24", + "104.26.20.0/24", + "104.26.21.0/24", + "104.26.22.0/24", + "104.26.23.0/24", + "104.26.24.0/24", + "104.26.25.0/24", + "104.26.26.0/24", + "104.26.27.0/24", + "104.26.28.0/24", + "104.26.29.0/24", + "104.26.30.0/24", + "104.26.31.0/24", + "104.26.32.0/24", + "104.26.33.0/24", + "104.26.34.0/24", + "104.26.35.0/24", + "104.26.36.0/24", + "104.26.37.0/24", + "104.26.38.0/24", + "104.26.39.0/24", + "104.26.40.0/24", + "104.26.41.0/24", + "104.26.42.0/24", + "104.26.43.0/24", + "104.26.44.0/24", + "104.26.45.0/24", + "104.26.46.0/24", + "104.26.47.0/24", + "104.26.48.0/24", + "104.26.49.0/24", + "104.26.50.0/24", + "104.26.51.0/24", + "104.26.52.0/24", + "104.26.53.0/24", + "104.26.54.0/24", + "104.26.55.0/24", + "104.26.56.0/24", + "104.26.57.0/24", + "104.26.58.0/24", + "104.26.59.0/24", + "104.26.60.0/24", + "104.26.61.0/24", + "104.26.62.0/24", + "104.26.63.0/24", + "104.26.64.0/24", + "104.26.65.0/24", + "104.26.66.0/24", + "104.26.67.0/24", + "104.26.68.0/24", + "104.26.69.0/24", + "104.26.70.0/24", + "104.26.71.0/24", + "104.26.72.0/24", + "104.26.73.0/24", + "104.26.74.0/24", + "104.26.75.0/24", + "104.26.76.0/24", + "104.26.77.0/24", + "104.26.78.0/24", + "104.26.79.0/24", + "104.26.80.0/24", + "104.26.81.0/24", + "104.26.82.0/24", + "104.26.83.0/24", + "104.26.84.0/24", + "104.26.85.0/24", + "104.26.86.0/24", + "104.26.87.0/24", + "104.26.88.0/24", + "104.26.89.0/24", + "104.26.90.0/24", + "104.26.91.0/24", + "104.26.92.0/24", + "104.26.93.0/24", + "104.26.94.0/24", + "104.26.95.0/24", + "104.26.96.0/24", + "104.26.97.0/24", + "104.26.98.0/24", + "104.26.99.0/24", + "104.26.100.0/24", + "104.26.101.0/24", + "104.26.102.0/24", + "104.26.103.0/24", + "104.26.104.0/24", + "104.26.105.0/24", + "104.26.106.0/24", + "104.26.107.0/24", + "104.26.108.0/24", + "104.26.109.0/24", + "104.26.110.0/24", + "104.26.111.0/24", + "104.26.112.0/24", + "104.26.113.0/24", + "104.26.114.0/24", + "104.26.115.0/24", + "104.26.116.0/24", + "104.26.117.0/24", + "104.26.118.0/24", + "104.26.119.0/24", + "104.26.120.0/24", + "104.26.121.0/24", + "104.26.122.0/24", + "104.26.123.0/24", + "104.26.124.0/24", + "104.26.125.0/24", + "104.26.126.0/24", + "104.26.127.0/24", + "104.26.128.0/24", + "104.26.129.0/24", + "104.26.130.0/24", + "104.26.131.0/24", + "104.26.132.0/24", + "104.26.133.0/24", + "104.26.134.0/24", + "104.26.135.0/24", + "104.26.136.0/24", + "104.26.137.0/24", + "104.26.138.0/24", + "104.26.139.0/24", + "104.26.140.0/24", + "104.26.141.0/24", + "104.26.142.0/24", + "104.26.143.0/24", + "104.26.144.0/24", + "104.26.145.0/24", + "104.26.146.0/24", + "104.26.147.0/24", + "104.26.148.0/24", + "104.26.149.0/24", + "104.26.150.0/24", + "104.26.151.0/24", + "104.26.152.0/24", + "104.26.153.0/24", + "104.26.154.0/24", + "104.26.155.0/24", + "104.26.156.0/24", + "104.26.157.0/24", + "104.26.158.0/24", + "104.26.159.0/24", + "104.26.160.0/24", + "104.26.161.0/24", + "104.26.162.0/24", + "104.26.163.0/24", + "104.26.164.0/24", + "104.26.165.0/24", + "104.26.166.0/24", + "104.26.167.0/24", + "104.26.168.0/24", + "104.26.169.0/24", + "104.26.170.0/24", + "104.26.171.0/24", + "104.26.172.0/24", + "104.26.173.0/24", + "104.26.174.0/24", + "104.26.175.0/24", + "104.26.176.0/24", + "104.26.177.0/24", + "104.26.178.0/24", + "104.26.179.0/24", + "104.26.180.0/24", + "104.26.181.0/24", + "104.26.182.0/24", + "104.26.183.0/24", + "104.26.184.0/24", + "104.26.185.0/24", + "104.26.186.0/24", + "104.26.187.0/24", + "104.26.188.0/24", + "104.26.189.0/24", + "104.26.190.0/24", + "104.26.191.0/24", + "104.26.192.0/24", + "104.26.193.0/24", + "104.26.194.0/24", + "104.26.195.0/24", + "104.26.196.0/24", + "104.26.197.0/24", + "104.26.198.0/24", + "104.26.199.0/24", + "104.26.200.0/24", + "104.26.201.0/24", + "104.26.202.0/24", + "104.26.203.0/24", + "104.26.204.0/24", + "104.26.205.0/24", + "104.26.206.0/24", + "104.26.207.0/24", + "104.26.208.0/24", + "104.26.209.0/24", + "104.26.210.0/24", + "104.26.211.0/24", + "104.26.212.0/24", + "104.26.213.0/24", + "104.26.214.0/24", + "104.26.215.0/24", + "104.26.216.0/24", + "104.26.217.0/24", + "104.26.218.0/24", + "104.26.219.0/24", + "104.26.220.0/24", + "104.26.221.0/24", + "104.26.222.0/24", + "104.26.223.0/24", + "104.26.224.0/24", + "104.26.225.0/24", + "104.26.226.0/24", + "104.26.227.0/24", + "104.26.228.0/24", + "104.26.229.0/24", + "104.26.230.0/24", + "104.26.231.0/24", + "104.26.232.0/24", + "104.26.233.0/24", + "104.26.234.0/24", + "104.26.235.0/24", + "104.26.236.0/24", + "104.26.237.0/24", + "104.26.238.0/24", + "104.26.239.0/24", + "104.26.240.0/24", + "104.26.241.0/24", + "104.26.242.0/24", + "104.26.243.0/24", + "104.26.244.0/24", + "104.26.245.0/24", + "104.26.246.0/24", + "104.26.247.0/24", + "104.26.248.0/24", + "104.26.249.0/24", + "104.26.250.0/24", + "104.26.251.0/24", + "104.26.252.0/24", + "104.26.253.0/24", + "104.26.254.0/24", + "104.26.255.0/24", + "104.27.0.0/24", + "104.27.1.0/24", + "104.27.2.0/24", + "104.27.3.0/24", + "104.27.4.0/24", + "104.27.5.0/24", + "104.27.6.0/24", + "104.27.7.0/24", + "104.27.8.0/24", + "104.27.9.0/24", + "104.27.10.0/24", + "104.27.11.0/24", + "104.27.12.0/24", + "104.27.13.0/24", + "104.27.14.0/24", + "104.27.15.0/24", + "104.27.16.0/24", + "104.27.17.0/24", + "104.27.18.0/24", + "104.27.19.0/24", + "104.27.20.0/24", + "104.27.21.0/24", + "104.27.22.0/24", + "104.27.23.0/24", + "104.27.24.0/24", + "104.27.25.0/24", + "104.27.26.0/24", + "104.27.27.0/24", + "104.27.28.0/24", + "104.27.29.0/24", + "104.27.30.0/24", + "104.27.31.0/24", + "104.27.32.0/24", + "104.27.33.0/24", + "104.27.34.0/24", + "104.27.35.0/24", + "104.27.36.0/24", + "104.27.37.0/24", + "104.27.38.0/24", + "104.27.39.0/24", + "104.27.40.0/24", + "104.27.41.0/24", + "104.27.42.0/24", + "104.27.43.0/24", + "104.27.44.0/24", + "104.27.45.0/24", + "104.27.46.0/24", + "104.27.47.0/24", + "104.27.48.0/24", + "104.27.49.0/24", + "104.27.50.0/24", + "104.27.51.0/24", + "104.27.52.0/24", + "104.27.53.0/24", + "104.27.54.0/24", + "104.27.55.0/24", + "104.27.56.0/24", + "104.27.57.0/24", + "104.27.58.0/24", + "104.27.59.0/24", + "104.27.60.0/24", + "104.27.61.0/24", + "104.27.62.0/24", + "104.27.63.0/24", + "104.27.64.0/24", + "104.27.65.0/24", + "104.27.66.0/24", + "104.27.67.0/24", + "104.27.68.0/24", + "104.27.69.0/24", + "104.27.70.0/24", + "104.27.71.0/24", + "104.27.72.0/24", + "104.27.73.0/24", + "104.27.74.0/24", + "104.27.75.0/24", + "104.27.76.0/24", + "104.27.77.0/24", + "104.27.78.0/24", + "104.27.79.0/24", + "104.27.80.0/24", + "104.27.81.0/24", + "104.27.82.0/24", + "104.27.83.0/24", + "104.27.84.0/24", + "104.27.85.0/24", + "104.27.86.0/24", + "104.27.87.0/24", + "104.27.88.0/24", + "104.27.89.0/24", + "104.27.90.0/24", + "104.27.91.0/24", + "104.27.92.0/24", + "104.27.93.0/24", + "104.27.94.0/24", + "104.27.95.0/24", + "104.27.96.0/24", + "104.27.97.0/24", + "104.27.98.0/24", + "104.27.99.0/24", + "104.27.100.0/24", + "104.27.101.0/24", + "104.27.102.0/24", + "104.27.103.0/24", + "104.27.104.0/24", + "104.27.105.0/24", + "104.27.106.0/24", + "104.27.107.0/24", + "104.27.108.0/24", + "104.27.109.0/24", + "104.27.110.0/24", + "104.27.111.0/24", + "104.27.112.0/24", + "104.27.113.0/24", + "104.27.114.0/24", + "104.27.115.0/24", + "104.27.116.0/24", + "104.27.117.0/24", + "104.27.118.0/24", + "104.27.119.0/24", + "104.27.120.0/24", + "104.27.121.0/24", + "104.27.122.0/24", + "104.27.123.0/24", + "104.27.124.0/24", + "104.27.125.0/24", + "104.27.126.0/24", + "104.27.127.0/24", + "104.27.128.0/24", + "104.27.129.0/24", + "104.27.130.0/24", + "104.27.131.0/24", + "104.27.132.0/24", + "104.27.133.0/24", + "104.27.134.0/24", + "104.27.135.0/24", + "104.27.136.0/24", + "104.27.137.0/24", + "104.27.138.0/24", + "104.27.139.0/24", + "104.27.140.0/24", + "104.27.141.0/24", + "104.27.142.0/24", + "104.27.143.0/24", + "104.27.144.0/24", + "104.27.145.0/24", + "104.27.146.0/24", + "104.27.147.0/24", + "104.27.148.0/24", + "104.27.149.0/24", + "104.27.150.0/24", + "104.27.151.0/24", + "104.27.152.0/24", + "104.27.153.0/24", + "104.27.154.0/24", + "104.27.155.0/24", + "104.27.156.0/24", + "104.27.157.0/24", + "104.27.158.0/24", + "104.27.159.0/24", + "104.27.160.0/24", + "104.27.161.0/24", + "104.27.162.0/24", + "104.27.163.0/24", + "104.27.164.0/24", + "104.27.165.0/24", + "104.27.166.0/24", + "104.27.167.0/24", + "104.27.168.0/24", + "104.27.169.0/24", + "104.27.170.0/24", + "104.27.171.0/24", + "104.27.172.0/24", + "104.27.173.0/24", + "104.27.174.0/24", + "104.27.175.0/24", + "104.27.176.0/24", + "104.27.177.0/24", + "104.27.178.0/24", + "104.27.179.0/24", + "104.27.180.0/24", + "104.27.181.0/24", + "104.27.182.0/24", + "104.27.183.0/24", + "104.27.184.0/24", + "104.27.185.0/24", + "104.27.186.0/24", + "104.27.187.0/24", + "104.27.188.0/24", + "104.27.189.0/24", + "104.27.190.0/24", + "104.27.191.0/24", + "104.27.192.0/24", + "104.27.193.0/24", + "104.27.194.0/24", + "104.27.195.0/24", + "104.27.196.0/24", + "104.27.197.0/24", + "104.27.198.0/24", + "104.27.199.0/24", + "104.27.200.0/24", + "104.27.201.0/24", + "104.27.202.0/24", + "104.27.203.0/24", + "104.27.204.0/24", + "104.27.205.0/24", + "104.27.206.0/24", + "104.27.207.0/24", + "104.27.208.0/24", + "104.27.209.0/24", + "104.27.210.0/24", + "104.27.211.0/24", + "104.27.212.0/24", + "104.27.213.0/24", + "104.27.214.0/24", + "104.27.215.0/24", + "104.27.216.0/24", + "104.27.217.0/24", + "104.27.218.0/24", + "104.27.219.0/24", + "104.27.220.0/24", + "104.27.221.0/24", + "104.27.222.0/24", + "104.27.223.0/24", + "104.27.224.0/24", + "104.27.225.0/24", + "104.27.226.0/24", + "104.27.227.0/24", + "104.27.228.0/24", + "104.27.229.0/24", + "104.27.230.0/24", + "104.27.231.0/24", + "104.27.232.0/24", + "104.27.233.0/24", + "104.27.234.0/24", + "104.27.235.0/24", + "104.27.236.0/24", + "104.27.237.0/24", + "104.27.238.0/24", + "104.27.239.0/24", + "104.27.240.0/24", + "104.27.241.0/24", + "104.27.242.0/24", + "104.27.243.0/24", + "104.27.244.0/24", + "104.27.245.0/24", + "104.27.246.0/24", + "104.27.247.0/24", + "104.27.248.0/24", + "104.27.249.0/24", + "104.27.250.0/24", + "104.27.251.0/24", + "104.27.252.0/24", + "104.27.253.0/24", + "104.27.254.0/24", + "104.27.255.0/24", + "104.28.0.0/24", + "104.28.1.0/24", + "104.28.2.0/24", + "104.28.3.0/24", + "104.28.4.0/24", + "104.28.5.0/24", + "104.28.6.0/24", + "104.28.7.0/24", + "104.28.8.0/24", + "104.28.9.0/24", + "104.28.10.0/24", + "104.28.11.0/24", + "104.28.12.0/24", + "104.28.13.0/24", + "104.28.14.0/24", + "104.28.15.0/24", + "104.28.16.0/24", + "104.28.17.0/24", + "104.28.18.0/24", + "104.28.19.0/24", + "104.28.20.0/24", + "104.28.21.0/24", + "104.28.22.0/24", + "104.28.23.0/24", + "104.28.24.0/24", + "104.28.25.0/24", + "104.28.26.0/24", + "104.28.27.0/24", + "104.28.28.0/24", + "104.28.29.0/24", + "104.28.30.0/24", + "104.28.31.0/24", + "104.28.32.0/24", + "104.28.33.0/24", + "104.28.34.0/24", + "104.28.35.0/24", + "104.28.36.0/24", + "104.28.37.0/24", + "104.28.38.0/24", + "104.28.39.0/24", + "104.28.40.0/24", + "104.28.41.0/24", + "104.28.42.0/24", + "104.28.43.0/24", + "104.28.44.0/24", + "104.28.45.0/24", + "104.28.46.0/24", + "104.28.47.0/24", + "104.28.48.0/24", + "104.28.49.0/24", + "104.28.50.0/24", + "104.28.51.0/24", + "104.28.52.0/24", + "104.28.53.0/24", + "104.28.54.0/24", + "104.28.55.0/24", + "104.28.56.0/24", + "104.28.57.0/24", + "104.28.58.0/24", + "104.28.59.0/24", + "104.28.60.0/24", + "104.28.61.0/24", + "104.28.62.0/24", + "104.28.63.0/24", + "104.28.64.0/24", + "104.28.65.0/24", + "104.28.66.0/24", + "104.28.67.0/24", + "104.28.68.0/24", + "104.28.69.0/24", + "104.28.70.0/24", + "104.28.71.0/24", + "104.28.72.0/24", + "104.28.73.0/24", + "104.28.74.0/24", + "104.28.75.0/24", + "104.28.76.0/24", + "104.28.77.0/24", + "104.28.78.0/24", + "104.28.79.0/24", + "104.28.80.0/24", + "104.28.81.0/24", + "104.28.82.0/24", + "104.28.83.0/24", + "104.28.84.0/24", + "104.28.85.0/24", + "104.28.86.0/24", + "104.28.87.0/24", + "104.28.88.0/24", + "104.28.89.0/24", + "104.28.90.0/24", + "104.28.91.0/24", + "104.28.92.0/24", + "104.28.93.0/24", + "104.28.94.0/24", + "104.28.95.0/24", + "104.28.96.0/24", + "104.28.97.0/24", + "104.28.98.0/24", + "104.28.99.0/24", + "104.28.100.0/24", + "104.28.101.0/24", + "104.28.102.0/24", + "104.28.103.0/24", + "104.28.104.0/24", + "104.28.105.0/24", + "104.28.106.0/24", + "104.28.107.0/24", + "104.28.108.0/24", + "104.28.109.0/24", + "104.28.110.0/24", + "104.28.111.0/24", + "104.28.112.0/24", + "104.28.113.0/24", + "104.28.114.0/24", + "104.28.115.0/24", + "104.28.116.0/24", + "104.28.117.0/24", + "104.28.118.0/24", + "104.28.119.0/24", + "104.28.120.0/24", + "104.28.121.0/24", + "104.28.122.0/24", + "104.28.123.0/24", + "104.28.124.0/24", + "104.28.125.0/24", + "104.28.126.0/24", + "104.28.127.0/24", + "104.28.128.0/24", + "104.28.129.0/24", + "104.28.130.0/24", + "104.28.131.0/24", + "104.28.132.0/24", + "104.28.133.0/24", + "104.28.134.0/24", + "104.28.135.0/24", + "104.28.136.0/24", + "104.28.137.0/24", + "104.28.138.0/24", + "104.28.139.0/24", + "104.28.140.0/24", + "104.28.141.0/24", + "104.28.142.0/24", + "104.28.143.0/24", + "104.28.144.0/24", + "104.28.145.0/24", + "104.28.146.0/24", + "104.28.147.0/24", + "104.28.148.0/24", + "104.28.149.0/24", + "104.28.150.0/24", + "104.28.151.0/24", + "104.28.152.0/24", + "104.28.153.0/24", + "104.28.154.0/24", + "104.28.155.0/24", + "104.28.156.0/24", + "104.28.157.0/24", + "104.28.158.0/24", + "104.28.159.0/24", + "104.28.160.0/24", + "104.28.161.0/24", + "104.28.162.0/24", + "104.28.163.0/24", + "104.28.164.0/24", + "104.28.165.0/24", + "104.28.166.0/24", + "104.28.167.0/24", + "104.28.168.0/24", + "104.28.169.0/24", + "104.28.170.0/24", + "104.28.171.0/24", + "104.28.172.0/24", + "104.28.173.0/24", + "104.28.174.0/24", + "104.28.175.0/24", + "104.28.176.0/24", + "104.28.177.0/24", + "104.28.178.0/24", + "104.28.179.0/24", + "104.28.180.0/24", + "104.28.181.0/24", + "104.28.182.0/24", + "104.28.183.0/24", + "104.28.184.0/24", + "104.28.185.0/24", + "104.28.186.0/24", + "104.28.187.0/24", + "104.28.188.0/24", + "104.28.189.0/24", + "104.28.190.0/24", + "104.28.191.0/24", + "104.28.192.0/24", + "104.28.193.0/24", + "104.28.194.0/24", + "104.28.195.0/24", + "104.28.196.0/24", + "104.28.197.0/24", + "104.28.198.0/24", + "104.28.199.0/24", + "104.28.200.0/24", + "104.28.201.0/24", + "104.28.202.0/24", + "104.28.203.0/24", + "104.28.204.0/24", + "104.28.205.0/24", + "104.28.206.0/24", + "104.28.207.0/24", + "104.28.208.0/24", + "104.28.209.0/24", + "104.28.210.0/24", + "104.28.211.0/24", + "104.28.212.0/24", + "104.28.213.0/24", + "104.28.214.0/24", + "104.28.215.0/24", + "104.28.216.0/24", + "104.28.217.0/24", + "104.28.218.0/24", + "104.28.219.0/24", + "104.28.220.0/24", + "104.28.221.0/24", + "104.28.222.0/24", + "104.28.223.0/24", + "104.28.224.0/24", + "104.28.225.0/24", + "104.28.226.0/24", + "104.28.227.0/24", + "104.28.228.0/24", + "104.28.229.0/24", + "104.28.230.0/24", + "104.28.231.0/24", + "104.28.232.0/24", + "104.28.233.0/24", + "104.28.234.0/24", + "104.28.235.0/24", + "104.28.236.0/24", + "104.28.237.0/24", + "104.28.238.0/24", + "104.28.239.0/24", + "104.28.240.0/24", + "104.28.241.0/24", + "104.28.242.0/24", + "104.28.243.0/24", + "104.28.244.0/24", + "104.28.245.0/24", + "104.28.246.0/24", + "104.28.247.0/24", + "104.28.248.0/24", + "104.28.249.0/24", + "104.28.250.0/24", + "104.28.251.0/24", + "104.28.252.0/24", + "104.28.253.0/24", + "104.28.254.0/24", + "104.28.255.0/24", + "104.29.0.0/24", + "104.29.1.0/24", + "104.29.2.0/24", + "104.29.3.0/24", + "104.29.4.0/24", + "104.29.5.0/24", + "104.29.6.0/24", + "104.29.7.0/24", + "104.29.8.0/24", + "104.29.9.0/24", + "104.29.10.0/24", + "104.29.11.0/24", + "104.29.12.0/24", + "104.29.13.0/24", + "104.29.14.0/24", + "104.29.15.0/24", + "104.29.16.0/24", + "104.29.17.0/24", + "104.29.18.0/24", + "104.29.19.0/24", + "104.29.20.0/24", + "104.29.21.0/24", + "104.29.22.0/24", + "104.29.23.0/24", + "104.29.24.0/24", + "104.29.25.0/24", + "104.29.26.0/24", + "104.29.27.0/24", + "104.29.28.0/24", + "104.29.29.0/24", + "104.29.30.0/24", + "104.29.31.0/24", + "104.29.32.0/24", + "104.29.33.0/24", + "104.29.34.0/24", + "104.29.35.0/24", + "104.29.36.0/24", + "104.29.37.0/24", + "104.29.38.0/24", + "104.29.39.0/24", + "104.29.40.0/24", + "104.29.41.0/24", + "104.29.42.0/24", + "104.29.43.0/24", + "104.29.44.0/24", + "104.29.45.0/24", + "104.29.46.0/24", + "104.29.47.0/24", + "104.29.48.0/24", + "104.29.49.0/24", + "104.29.50.0/24", + "104.29.51.0/24", + "104.29.52.0/24", + "104.29.53.0/24", + "104.29.54.0/24", + "104.29.55.0/24", + "104.29.56.0/24", + "104.29.57.0/24", + "104.29.58.0/24", + "104.29.59.0/24", + "104.29.60.0/24", + "104.29.61.0/24", + "104.29.62.0/24", + "104.29.63.0/24", + "104.29.64.0/24", + "104.29.65.0/24", + "104.29.66.0/24", + "104.29.67.0/24", + "104.29.68.0/24", + "104.29.69.0/24", + "104.29.70.0/24", + "104.29.71.0/24", + "104.29.72.0/24", + "104.29.73.0/24", + "104.29.74.0/24", + "104.29.75.0/24", + "104.29.76.0/24", + "104.29.77.0/24", + "104.29.78.0/24", + "104.29.79.0/24", + "104.29.80.0/24", + "104.29.81.0/24", + "104.29.82.0/24", + "104.29.83.0/24", + "104.29.84.0/24", + "104.29.85.0/24", + "104.29.86.0/24", + "104.29.87.0/24", + "104.29.88.0/24", + "104.29.89.0/24", + "104.29.90.0/24", + "104.29.91.0/24", + "104.29.92.0/24", + "104.29.93.0/24", + "104.29.94.0/24", + "104.29.95.0/24", + "104.29.96.0/24", + "104.29.97.0/24", + "104.29.98.0/24", + "104.29.99.0/24", + "104.29.100.0/24", + "104.29.101.0/24", + "104.29.102.0/24", + "104.29.103.0/24", + "104.29.104.0/24", + "104.29.105.0/24", + "104.29.106.0/24", + "104.29.107.0/24", + "104.29.108.0/24", + "104.29.109.0/24", + "104.29.110.0/24", + "104.29.111.0/24", + "104.29.112.0/24", + "104.29.113.0/24", + "104.29.114.0/24", + "104.29.115.0/24", + "104.29.116.0/24", + "104.29.117.0/24", + "104.29.118.0/24", + "104.29.119.0/24", + "104.29.120.0/24", + "104.29.121.0/24", + "104.29.122.0/24", + "104.29.123.0/24", + "104.29.124.0/24", + "104.29.125.0/24", + "104.29.126.0/24", + "104.29.127.0/24", + "104.29.128.0/24", + "104.29.129.0/24", + "104.29.130.0/24", + "104.29.131.0/24", + "104.29.132.0/24", + "104.29.133.0/24", + "104.29.134.0/24", + "104.29.135.0/24", + "104.29.136.0/24", + "104.29.137.0/24", + "104.29.138.0/24", + "104.29.139.0/24", + "104.29.140.0/24", + "104.29.141.0/24", + "104.29.142.0/24", + "104.29.143.0/24", + "104.29.144.0/24", + "104.29.145.0/24", + "104.29.146.0/24", + "104.29.147.0/24", + "104.29.148.0/24", + "104.29.149.0/24", + "104.29.150.0/24", + "104.29.151.0/24", + "104.29.152.0/24", + "104.29.153.0/24", + "104.29.154.0/24", + "104.29.155.0/24", + "104.29.156.0/24", + "104.29.157.0/24", + "104.29.158.0/24", + "104.29.159.0/24", + "104.29.160.0/24", + "104.29.161.0/24", + "104.29.162.0/24", + "104.29.163.0/24", + "104.29.164.0/24", + "104.29.165.0/24", + "104.29.166.0/24", + "104.29.167.0/24", + "104.29.168.0/24", + "104.29.169.0/24", + "104.29.170.0/24", + "104.29.171.0/24", + "104.29.172.0/24", + "104.29.173.0/24", + "104.29.174.0/24", + "104.29.175.0/24", + "104.29.176.0/24", + "104.29.177.0/24", + "104.29.178.0/24", + "104.29.179.0/24", + "104.29.180.0/24", + "104.29.181.0/24", + "104.29.182.0/24", + "104.29.183.0/24", + "104.29.184.0/24", + "104.29.185.0/24", + "104.29.186.0/24", + "104.29.187.0/24", + "104.29.188.0/24", + "104.29.189.0/24", + "104.29.190.0/24", + "104.29.191.0/24", + "104.29.192.0/24", + "104.29.193.0/24", + "104.29.194.0/24", + "104.29.195.0/24", + "104.29.196.0/24", + "104.29.197.0/24", + "104.29.198.0/24", + "104.29.199.0/24", + "104.29.200.0/24", + "104.29.201.0/24", + "104.29.202.0/24", + "104.29.203.0/24", + "104.29.204.0/24", + "104.29.205.0/24", + "104.29.206.0/24", + "104.29.207.0/24", + "104.29.208.0/24", + "104.29.209.0/24", + "104.29.210.0/24", + "104.29.211.0/24", + "104.29.212.0/24", + "104.29.213.0/24", + "104.29.214.0/24", + "104.29.215.0/24", + "104.29.216.0/24", + "104.29.217.0/24", + "104.29.218.0/24", + "104.29.219.0/24", + "104.29.220.0/24", + "104.29.221.0/24", + "104.29.222.0/24", + "104.29.223.0/24", + "104.29.224.0/24", + "104.29.225.0/24", + "104.29.226.0/24", + "104.29.227.0/24", + "104.29.228.0/24", + "104.29.229.0/24", + "104.29.230.0/24", + "104.29.231.0/24", + "104.29.232.0/24", + "104.29.233.0/24", + "104.29.234.0/24", + "104.29.235.0/24", + "104.29.236.0/24", + "104.29.237.0/24", + "104.29.238.0/24", + "104.29.239.0/24", + "104.29.240.0/24", + "104.29.241.0/24", + "104.29.242.0/24", + "104.29.243.0/24", + "104.29.244.0/24", + "104.29.245.0/24", + "104.29.246.0/24", + "104.29.247.0/24", + "104.29.248.0/24", + "104.29.249.0/24", + "104.29.250.0/24", + "104.29.251.0/24", + "104.29.252.0/24", + "104.29.253.0/24", + "104.29.254.0/24", + "104.29.255.0/24", + "104.30.0.0/24", + "104.30.1.0/24", + "104.30.2.0/24", + "104.30.3.0/24", + "104.30.4.0/24", + "104.30.5.0/24", + "104.30.6.0/24", + "104.30.7.0/24", + "104.30.8.0/24", + "104.30.9.0/24", + "104.30.10.0/24", + "104.30.11.0/24", + "104.30.12.0/24", + "104.30.13.0/24", + "104.30.14.0/24", + "104.30.15.0/24", + "104.30.16.0/24", + "104.30.17.0/24", + "104.30.18.0/24", + "104.30.19.0/24", + "104.30.20.0/24", + "104.30.21.0/24", + "104.30.22.0/24", + "104.30.23.0/24", + "104.30.24.0/24", + "104.30.25.0/24", + "104.30.26.0/24", + "104.30.27.0/24", + "104.30.28.0/24", + "104.30.29.0/24", + "104.30.30.0/24", + "104.30.31.0/24", + "104.30.32.0/24", + "104.30.33.0/24", + "104.30.34.0/24", + "104.30.35.0/24", + "104.30.36.0/24", + "104.30.37.0/24", + "104.30.38.0/24", + "104.30.39.0/24", + "104.30.40.0/24", + "104.30.41.0/24", + "104.30.42.0/24", + "104.30.43.0/24", + "104.30.44.0/24", + "104.30.45.0/24", + "104.30.46.0/24", + "104.30.47.0/24", + "104.30.48.0/24", + "104.30.49.0/24", + "104.30.50.0/24", + "104.30.51.0/24", + "104.30.52.0/24", + "104.30.53.0/24", + "104.30.54.0/24", + "104.30.55.0/24", + "104.30.56.0/24", + "104.30.57.0/24", + "104.30.58.0/24", + "104.30.59.0/24", + "104.30.60.0/24", + "104.30.61.0/24", + "104.30.62.0/24", + "104.30.63.0/24", + "104.30.64.0/24", + "104.30.65.0/24", + "104.30.66.0/24", + "104.30.67.0/24", + "104.30.68.0/24", + "104.30.69.0/24", + "104.30.70.0/24", + "104.30.71.0/24", + "104.30.72.0/24", + "104.30.73.0/24", + "104.30.74.0/24", + "104.30.75.0/24", + "104.30.76.0/24", + "104.30.77.0/24", + "104.30.78.0/24", + "104.30.79.0/24", + "104.30.80.0/24", + "104.30.81.0/24", + "104.30.82.0/24", + "104.30.83.0/24", + "104.30.84.0/24", + "104.30.85.0/24", + "104.30.86.0/24", + "104.30.87.0/24", + "104.30.88.0/24", + "104.30.89.0/24", + "104.30.90.0/24", + "104.30.91.0/24", + "104.30.92.0/24", + "104.30.93.0/24", + "104.30.94.0/24", + "104.30.95.0/24", + "104.30.96.0/24", + "104.30.97.0/24", + "104.30.98.0/24", + "104.30.99.0/24", + "104.30.100.0/24", + "104.30.101.0/24", + "104.30.102.0/24", + "104.30.103.0/24", + "104.30.104.0/24", + "104.30.105.0/24", + "104.30.106.0/24", + "104.30.107.0/24", + "104.30.108.0/24", + "104.30.109.0/24", + "104.30.110.0/24", + "104.30.111.0/24", + "104.30.112.0/24", + "104.30.113.0/24", + "104.30.114.0/24", + "104.30.115.0/24", + "104.30.116.0/24", + "104.30.117.0/24", + "104.30.118.0/24", + "104.30.119.0/24", + "104.30.120.0/24", + "104.30.121.0/24", + "104.30.122.0/24", + "104.30.123.0/24", + "104.30.124.0/24", + "104.30.125.0/24", + "104.30.126.0/24", + "104.30.127.0/24", + "104.30.128.0/24", + "104.30.129.0/24", + "104.30.130.0/24", + "104.30.131.0/24", + "104.30.132.0/24", + "104.30.133.0/24", + "104.30.134.0/24", + "104.30.135.0/24", + "104.30.136.0/24", + "104.30.137.0/24", + "104.30.138.0/24", + "104.30.139.0/24", + "104.30.140.0/24", + "104.30.141.0/24", + "104.30.142.0/24", + "104.30.143.0/24", + "104.30.144.0/24", + "104.30.145.0/24", + "104.30.146.0/24", + "104.30.147.0/24", + "104.30.148.0/24", + "104.30.149.0/24", + "104.30.150.0/24", + "104.30.151.0/24", + "104.30.152.0/24", + "104.30.153.0/24", + "104.30.154.0/24", + "104.30.155.0/24", + "104.30.156.0/24", + "104.30.157.0/24", + "104.30.158.0/24", + "104.30.159.0/24", + "104.30.160.0/24", + "104.30.161.0/24", + "104.30.162.0/24", + "104.30.163.0/24", + "104.30.164.0/24", + "104.30.165.0/24", + "104.30.166.0/24", + "104.30.167.0/24", + "104.30.168.0/24", + "104.30.169.0/24", + "104.30.170.0/24", + "104.30.171.0/24", + "104.30.172.0/24", + "104.30.173.0/24", + "104.30.174.0/24", + "104.30.175.0/24", + "104.30.176.0/24", + "104.30.177.0/24", + "104.30.178.0/24", + "104.30.179.0/24", + "104.30.180.0/24", + "104.30.181.0/24", + "104.30.182.0/24", + "104.30.183.0/24", + "104.30.184.0/24", + "104.30.185.0/24", + "104.30.186.0/24", + "104.30.187.0/24", + "104.30.188.0/24", + "104.30.189.0/24", + "104.30.190.0/24", + "104.30.191.0/24", + "104.30.192.0/24", + "104.30.193.0/24", + "104.30.194.0/24", + "104.30.195.0/24", + "104.30.196.0/24", + "104.30.197.0/24", + "104.30.198.0/24", + "104.30.199.0/24", + "104.30.200.0/24", + "104.30.201.0/24", + "104.30.202.0/24", + "104.30.203.0/24", + "104.30.204.0/24", + "104.30.205.0/24", + "104.30.206.0/24", + "104.30.207.0/24", + "104.30.208.0/24", + "104.30.209.0/24", + "104.30.210.0/24", + "104.30.211.0/24", + "104.30.212.0/24", + "104.30.213.0/24", + "104.30.214.0/24", + "104.30.215.0/24", + "104.30.216.0/24", + "104.30.217.0/24", + "104.30.218.0/24", + "104.30.219.0/24", + "104.30.220.0/24", + "104.30.221.0/24", + "104.30.222.0/24", + "104.30.223.0/24", + "104.30.224.0/24", + "104.30.225.0/24", + "104.30.226.0/24", + "104.30.227.0/24", + "104.30.228.0/24", + "104.30.229.0/24", + "104.30.230.0/24", + "104.30.231.0/24", + "104.30.232.0/24", + "104.30.233.0/24", + "104.30.234.0/24", + "104.30.235.0/24", + "104.30.236.0/24", + "104.30.237.0/24", + "104.30.238.0/24", + "104.30.239.0/24", + "104.30.240.0/24", + "104.30.241.0/24", + "104.30.242.0/24", + "104.30.243.0/24", + "104.30.244.0/24", + "104.30.245.0/24", + "104.30.246.0/24", + "104.30.247.0/24", + "104.30.248.0/24", + "104.30.249.0/24", + "104.30.250.0/24", + "104.30.251.0/24", + "104.30.252.0/24", + "104.30.253.0/24", + "104.30.254.0/24", + "104.30.255.0/24", + "104.31.0.0/24", + "104.31.1.0/24", + "104.31.2.0/24", + "104.31.3.0/24", + "104.31.4.0/24", + "104.31.5.0/24", + "104.31.6.0/24", + "104.31.7.0/24", + "104.31.8.0/24", + "104.31.9.0/24", + "104.31.10.0/24", + "104.31.11.0/24", + "104.31.12.0/24", + "104.31.13.0/24", + "104.31.14.0/24", + "104.31.15.0/24", + "104.31.16.0/24", + "104.31.17.0/24", + "104.31.18.0/24", + "104.31.19.0/24", + "104.31.20.0/24", + "104.31.21.0/24", + "104.31.22.0/24", + "104.31.23.0/24", + "104.31.24.0/24", + "104.31.25.0/24", + "104.31.26.0/24", + "104.31.27.0/24", + "104.31.28.0/24", + "104.31.29.0/24", + "104.31.30.0/24", + "104.31.31.0/24", + "104.31.32.0/24", + "104.31.33.0/24", + "104.31.34.0/24", + "104.31.35.0/24", + "104.31.36.0/24", + "104.31.37.0/24", + "104.31.38.0/24", + "104.31.39.0/24", + "104.31.40.0/24", + "104.31.41.0/24", + "104.31.42.0/24", + "104.31.43.0/24", + "104.31.44.0/24", + "104.31.45.0/24", + "104.31.46.0/24", + "104.31.47.0/24", + "104.31.48.0/24", + "104.31.49.0/24", + "104.31.50.0/24", + "104.31.51.0/24", + "104.31.52.0/24", + "104.31.53.0/24", + "104.31.54.0/24", + "104.31.55.0/24", + "104.31.56.0/24", + "104.31.57.0/24", + "104.31.58.0/24", + "104.31.59.0/24", + "104.31.60.0/24", + "104.31.61.0/24", + "104.31.62.0/24", + "104.31.63.0/24", + "104.31.64.0/24", + "104.31.65.0/24", + "104.31.66.0/24", + "104.31.67.0/24", + "104.31.68.0/24", + "104.31.69.0/24", + "104.31.70.0/24", + "104.31.71.0/24", + "104.31.72.0/24", + "104.31.73.0/24", + "104.31.74.0/24", + "104.31.75.0/24", + "104.31.76.0/24", + "104.31.77.0/24", + "104.31.78.0/24", + "104.31.79.0/24", + "104.31.80.0/24", + "104.31.81.0/24", + "104.31.82.0/24", + "104.31.83.0/24", + "104.31.84.0/24", + "104.31.85.0/24", + "104.31.86.0/24", + "104.31.87.0/24", + "104.31.88.0/24", + "104.31.89.0/24", + "104.31.90.0/24", + "104.31.91.0/24", + "104.31.92.0/24", + "104.31.93.0/24", + "104.31.94.0/24", + "104.31.95.0/24", + "104.31.96.0/24", + "104.31.97.0/24", + "104.31.98.0/24", + "104.31.99.0/24", + "104.31.100.0/24", + "104.31.101.0/24", + "104.31.102.0/24", + "104.31.103.0/24", + "104.31.104.0/24", + "104.31.105.0/24", + "104.31.106.0/24", + "104.31.107.0/24", + "104.31.108.0/24", + "104.31.109.0/24", + "104.31.110.0/24", + "104.31.111.0/24", + "104.31.112.0/24", + "104.31.113.0/24", + "104.31.114.0/24", + "104.31.115.0/24", + "104.31.116.0/24", + "104.31.117.0/24", + "104.31.118.0/24", + "104.31.119.0/24", + "104.31.120.0/24", + "104.31.121.0/24", + "104.31.122.0/24", + "104.31.123.0/24", + "104.31.124.0/24", + "104.31.125.0/24", + "104.31.126.0/24", + "104.31.127.0/24", + "104.31.128.0/24", + "104.31.129.0/24", + "104.31.130.0/24", + "104.31.131.0/24", + "104.31.132.0/24", + "104.31.133.0/24", + "104.31.134.0/24", + "104.31.135.0/24", + "104.31.136.0/24", + "104.31.137.0/24", + "104.31.138.0/24", + "104.31.139.0/24", + "104.31.140.0/24", + "104.31.141.0/24", + "104.31.142.0/24", + "104.31.143.0/24", + "104.31.144.0/24", + "104.31.145.0/24", + "104.31.146.0/24", + "104.31.147.0/24", + "104.31.148.0/24", + "104.31.149.0/24", + "104.31.150.0/24", + "104.31.151.0/24", + "104.31.152.0/24", + "104.31.153.0/24", + "104.31.154.0/24", + "104.31.155.0/24", + "104.31.156.0/24", + "104.31.157.0/24", + "104.31.158.0/24", + "104.31.159.0/24", + "104.31.160.0/24", + "104.31.161.0/24", + "104.31.162.0/24", + "104.31.163.0/24", + "104.31.164.0/24", + "104.31.165.0/24", + "104.31.166.0/24", + "104.31.167.0/24", + "104.31.168.0/24", + "104.31.169.0/24", + "104.31.170.0/24", + "104.31.171.0/24", + "104.31.172.0/24", + "104.31.173.0/24", + "104.31.174.0/24", + "104.31.175.0/24", + "104.31.176.0/24", + "104.31.177.0/24", + "104.31.178.0/24", + "104.31.179.0/24", + "104.31.180.0/24", + "104.31.181.0/24", + "104.31.182.0/24", + "104.31.183.0/24", + "104.31.184.0/24", + "104.31.185.0/24", + "104.31.186.0/24", + "104.31.187.0/24", + "104.31.188.0/24", + "104.31.189.0/24", + "104.31.190.0/24", + "104.31.191.0/24", + "104.31.192.0/24", + "104.31.193.0/24", + "104.31.194.0/24", + "104.31.195.0/24", + "104.31.196.0/24", + "104.31.197.0/24", + "104.31.198.0/24", + "104.31.199.0/24", + "104.31.200.0/24", + "104.31.201.0/24", + "104.31.202.0/24", + "104.31.203.0/24", + "104.31.204.0/24", + "104.31.205.0/24", + "104.31.206.0/24", + "104.31.207.0/24", + "104.31.208.0/24", + "104.31.209.0/24", + "104.31.210.0/24", + "104.31.211.0/24", + "104.31.212.0/24", + "104.31.213.0/24", + "104.31.214.0/24", + "104.31.215.0/24", + "104.31.216.0/24", + "104.31.217.0/24", + "104.31.218.0/24", + "104.31.219.0/24", + "104.31.220.0/24", + "104.31.221.0/24", + "104.31.222.0/24", + "104.31.223.0/24", + "104.31.224.0/24", + "104.31.225.0/24", + "104.31.226.0/24", + "104.31.227.0/24", + "104.31.228.0/24", + "104.31.229.0/24", + "104.31.230.0/24", + "104.31.231.0/24", + "104.31.232.0/24", + "104.31.233.0/24", + "104.31.234.0/24", + "104.31.235.0/24", + "104.31.236.0/24", + "104.31.237.0/24", + "104.31.238.0/24", + "104.31.239.0/24", + "104.31.240.0/24", + "104.31.241.0/24", + "104.31.242.0/24", + "104.31.243.0/24", + "104.31.244.0/24", + "104.31.245.0/24", + "104.31.246.0/24", + "104.31.247.0/24", + "104.31.248.0/24", + "104.31.249.0/24", + "104.31.250.0/24", + "104.31.251.0/24", + "104.31.252.0/24", + "104.31.253.0/24", + "104.31.254.0/24", + "104.31.255.0/24", + "104.18.10.128/24", + "108.162.192.0/24", + "108.162.193.0/24", + "108.162.194.0/24", + "108.162.195.0/24", + "108.162.196.0/24", + "108.162.197.0/24", + "108.162.198.0/24", + "108.162.199.0/24", + "108.162.200.0/24", + "108.162.201.0/24", + "108.162.202.0/24", + "108.162.203.0/24", + "108.162.204.0/24", + "108.162.205.0/24", + "108.162.206.0/24", + "108.162.207.0/24", + "108.162.210.0/24", + "108.162.211.0/24", + "108.162.212.0/24", + "108.162.213.0/24", + "108.162.216.0/24", + "108.162.217.0/24", + "108.162.218.0/24", + "108.162.226.0/24", + "108.162.227.0/24", + "108.162.235.0/24", + "108.162.236.0/24", + "108.162.237.0/24", + "108.162.238.0/24", + "108.162.239.0/24", + "108.162.240.0/24", + "108.162.241.0/24", + "108.162.242.0/24", + "108.162.243.0/24", + "108.162.244.0/24", + "108.162.245.0/24", + "108.162.246.0/24", + "108.162.247.0/24", + "108.162.248.0/24", + "108.162.249.0/24", + "108.162.250.0/24", + "108.162.252.0/24", + "108.162.253.0/24", + "141.101.65.0/24", + "141.101.66.0/24", + "141.101.67.0/24", + "141.101.68.0/24", + "141.101.69.0/24", + "141.101.70.0/24", + "141.101.71.0/24", + "141.101.72.0/24", + "141.101.73.0/24", + "141.101.74.0/24", + "141.101.75.0/24", + "141.101.76.0/24", + "141.101.77.0/24", + "141.101.82.0/24", + "141.101.83.0/24", + "141.101.84.0/24", + "141.101.85.0/24", + "141.101.86.0/24", + "141.101.87.0/24", + "141.101.90.0/24", + "141.101.92.0/24", + "141.101.93.0/24", + "141.101.94.0/24", + "141.101.95.0/24", + "141.101.96.0/24", + "141.101.97.0/24", + "141.101.98.0/24", + "141.101.99.0/24", + "141.101.100.0/24", + "141.101.108.0/24", + "141.101.109.0/24", + "141.101.110.0/24", + "141.101.112.0/24", + "141.101.113.0/24", + "141.101.114.0/24", + "141.101.115.0/24", + "141.101.116.0/24", + "141.101.117.0/24", + "141.101.118.0/24", + "141.101.119.0/24", + "141.101.120.0/24", + "141.101.121.0/24", + "141.101.122.0/24", + "141.101.123.0/24", + "141.101.124.0/24", + "141.101.125.0/24", + "141.101.126.0/24", + "141.101.127.0/24", + "162.158.0.0/24", + "162.158.1.0/24", + "162.158.2.0/24", + "162.158.3.0/24", + "162.158.4.0/24", + "162.158.5.0/24", + "162.158.8.0/24", + "162.158.9.0/24", + "162.158.10.0/24", + "162.158.11.0/24", + "162.158.12.0/24", + "162.158.13.0/24", + "162.158.14.0/24", + "162.158.15.0/24", + "162.158.16.0/24", + "162.158.17.0/24", + "162.158.18.0/24", + "162.158.19.0/24", + "162.158.20.0/24", + "162.158.21.0/24", + "162.158.22.0/24", + "162.158.23.0/24", + "162.158.24.0/24", + "162.158.25.0/24", + "162.158.26.0/24", + "162.158.27.0/24", + "162.158.28.0/24", + "162.158.29.0/24", + "162.158.30.0/24", + "162.158.31.0/24", + "162.158.32.0/24", + "162.158.33.0/24", + "162.158.34.0/24", + "162.158.35.0/24", + "162.158.36.0/24", + "162.158.37.0/24", + "162.158.38.0/24", + "162.158.39.0/24", + "162.158.40.0/24", + "162.158.41.0/24", + "162.158.42.0/24", + "162.158.43.0/24", + "162.158.44.0/24", + "162.158.45.0/24", + "162.158.46.0/24", + "162.158.47.0/24", + "162.158.48.0/24", + "162.158.51.0/24", + "162.158.52.0/24", + "162.158.53.0/24", + "162.158.54.0/24", + "162.158.55.0/24", + "162.158.56.0/24", + "162.158.57.0/24", + "162.158.58.0/24", + "162.158.59.0/24", + "162.158.60.0/24", + "162.158.61.0/24", + "162.158.62.0/24", + "162.158.63.0/24", + "162.158.72.0/24", + "162.158.73.0/24", + "162.158.74.0/24", + "162.158.75.0/24", + "162.158.76.0/24", + "162.158.77.0/24", + "162.158.78.0/24", + "162.158.79.0/24", + "162.158.80.0/24", + "162.158.81.0/24", + "162.158.82.0/24", + "162.158.84.0/24", + "162.158.85.0/24", + "162.158.86.0/24", + "162.158.87.0/24", + "162.158.88.0/24", + "162.158.89.0/24", + "162.158.90.0/24", + "162.158.91.0/24", + "162.158.92.0/24", + "162.158.93.0/24", + "162.158.94.0/24", + "162.158.95.0/24", + "162.158.96.0/24", + "162.158.97.0/24", + "162.158.98.0/24", + "162.158.99.0/24", + "162.158.100.0/24", + "162.158.101.0/24", + "162.158.102.0/24", + "162.158.103.0/24", + "162.158.104.0/24", + "162.158.105.0/24", + "162.158.106.0/24", + "162.158.107.0/24", + "162.158.108.0/24", + "162.158.109.0/24", + "162.158.110.0/24", + "162.158.111.0/24", + "162.158.112.0/24", + "162.158.113.0/24", + "162.158.114.0/24", + "162.158.116.0/24", + "162.158.117.0/24", + "162.158.118.0/24", + "162.158.119.0/24", + "162.158.124.0/24", + "162.158.125.0/24", + "162.158.126.0/24", + "162.158.127.0/24", + "162.158.128.0/24", + "162.158.129.0/24", + "162.158.130.0/24", + "162.158.131.0/24", + "162.158.132.0/24", + "162.158.133.0/24", + "162.158.134.0/24", + "162.158.135.0/24", + "162.158.136.0/24", + "162.158.137.0/24", + "162.158.138.0/24", + "162.158.139.0/24", + "162.158.140.0/24", + "162.158.141.0/24", + "162.158.142.0/24", + "162.158.143.0/24", + "162.158.144.0/24", + "162.158.145.0/24", + "162.158.146.0/24", + "162.158.147.0/24", + "162.158.148.0/24", + "162.158.149.0/24", + "162.158.150.0/24", + "162.158.151.0/24", + "162.158.152.0/24", + "162.158.153.0/24", + "162.158.154.0/24", + "162.158.155.0/24", + "162.158.156.0/24", + "162.158.157.0/24", + "162.158.158.0/24", + "162.158.159.0/24", + "162.158.160.0/24", + "162.158.161.0/24", + "162.158.162.0/24", + "162.158.163.0/24", + "162.158.164.0/24", + "162.158.165.0/24", + "162.158.166.0/24", + "162.158.167.0/24", + "162.158.168.0/24", + "162.158.169.0/24", + "162.158.170.0/24", + "162.158.171.0/24", + "162.158.172.0/24", + "162.158.173.0/24", + "162.158.174.0/24", + "162.158.175.0/24", + "162.158.176.0/24", + "162.158.178.0/24", + "162.158.179.0/24", + "162.158.180.0/24", + "162.158.181.0/24", + "162.158.182.0/24", + "162.158.183.0/24", + "162.158.184.0/24", + "162.158.185.0/24", + "162.158.186.0/24", + "162.158.187.0/24", + "162.158.188.0/24", + "162.158.189.0/24", + "162.158.190.0/24", + "162.158.191.0/24", + "162.158.192.0/24", + "162.158.193.0/24", + "162.158.194.0/24", + "162.158.195.0/24", + "162.158.196.0/24", + "162.158.198.0/24", + "162.158.199.0/24", + "162.158.200.0/24", + "162.158.201.0/24", + "162.158.202.0/24", + "162.158.203.0/24", + "162.158.204.0/24", + "162.158.205.0/24", + "162.158.206.0/24", + "162.158.207.0/24", + "162.158.208.0/24", + "162.158.209.0/24", + "162.158.210.0/24", + "162.158.211.0/24", + "162.158.212.0/24", + "162.158.214.0/24", + "162.158.215.0/24", + "162.158.216.0/24", + "162.158.217.0/24", + "162.158.218.0/24", + "162.158.219.0/24", + "162.158.220.0/24", + "162.158.221.0/24", + "162.158.222.0/24", + "162.158.223.0/24", + "162.158.224.0/24", + "162.158.225.0/24", + "162.158.226.0/24", + "162.158.227.0/24", + "162.158.228.0/24", + "162.158.232.0/24", + "162.158.233.0/24", + "162.158.234.0/24", + "162.158.235.0/24", + "162.158.236.0/24", + "162.158.237.0/24", + "162.158.238.0/24", + "162.158.239.0/24", + "162.158.240.0/24", + "162.158.241.0/24", + "162.158.242.0/24", + "162.158.243.0/24", + "162.158.244.0/24", + "162.158.245.0/24", + "162.158.248.0/24", + "162.158.249.0/24", + "162.158.250.0/24", + "162.158.251.0/24", + "162.158.253.0/24", + "162.158.254.0/24", + "162.158.255.0/24", + "162.159.0.0/24", + "162.159.1.0/24", + "162.159.2.0/24", + "162.159.3.0/24", + "162.159.4.0/24", + "162.159.5.0/24", + "162.159.6.0/24", + "162.159.7.0/24", + "162.159.8.0/24", + "162.159.9.0/24", + "162.159.10.0/24", + "162.159.11.0/24", + "162.159.12.0/24", + "162.159.13.0/24", + "162.159.14.0/24", + "162.159.15.0/24", + "162.159.16.0/24", + "162.159.17.0/24", + "162.159.18.0/24", + "162.159.19.0/24", + "162.159.20.0/24", + "162.159.21.0/24", + "162.159.22.0/24", + "162.159.23.0/24", + "162.159.24.0/24", + "162.159.25.0/24", + "162.159.26.0/24", + "162.159.27.0/24", + "162.159.28.0/24", + "162.159.29.0/24", + "162.159.30.0/24", + "162.159.31.0/24", + "162.159.32.0/24", + "162.159.33.0/24", + "162.159.34.0/24", + "162.159.35.0/24", + "162.159.36.0/24", + "162.159.37.0/24", + "162.159.38.0/24", + "162.159.39.0/24", + "162.159.40.0/24", + "162.159.41.0/24", + "162.159.42.0/24", + "162.159.43.0/24", + "162.159.44.0/24", + "162.159.45.0/24", + "162.159.46.0/24", + "162.159.47.0/24", + "162.159.48.0/24", + "162.159.49.0/24", + "162.159.50.0/24", + "162.159.51.0/24", + "162.159.52.0/24", + "162.159.53.0/24", + "162.159.54.0/24", + "162.159.55.0/24", + "162.159.56.0/24", + "162.159.57.0/24", + "162.159.58.0/24", + "162.159.59.0/24", + "162.159.60.0/24", + "162.159.61.0/24", + "162.159.62.0/24", + "162.159.63.0/24", + "162.159.64.0/24", + "162.159.65.0/24", + "162.159.66.0/24", + "162.159.67.0/24", + "162.159.68.0/24", + "162.159.69.0/24", + "162.159.70.0/24", + "162.159.71.0/24", + "162.159.72.0/24", + "162.159.73.0/24", + "162.159.74.0/24", + "162.159.75.0/24", + "162.159.76.0/24", + "162.159.77.0/24", + "162.159.78.0/24", + "162.159.79.0/24", + "162.159.128.0/24", + "162.159.129.0/24", + "162.159.130.0/24", + "162.159.131.0/24", + "162.159.132.0/24", + "162.159.133.0/24", + "162.159.134.0/24", + "162.159.135.0/24", + "162.159.136.0/24", + "162.159.137.0/24", + "162.159.138.0/24", + "162.159.139.0/24", + "162.159.140.0/24", + "162.159.141.0/24", + "162.159.142.0/24", + "162.159.143.0/24", + "162.159.144.0/24", + "162.159.145.0/24", + "162.159.146.0/24", + "162.159.147.0/24", + "162.159.148.0/24", + "162.159.149.0/24", + "162.159.150.0/24", + "162.159.151.0/24", + "162.159.152.0/24", + "162.159.153.0/24", + "162.159.154.0/24", + "162.159.155.0/24", + "162.159.156.0/24", + "162.159.157.0/24", + "162.159.158.0/24", + "162.159.159.0/24", + "162.159.160.0/24", + "162.159.161.0/24", + "162.159.162.0/24", + "162.159.163.0/24", + "162.159.164.0/24", + "162.159.165.0/24", + "162.159.166.0/24", + "162.159.167.0/24", + "162.159.168.0/24", + "162.159.169.0/24", + "162.159.170.0/24", + "162.159.171.0/24", + "162.159.172.0/24", + "162.159.173.0/24", + "162.159.174.0/24", + "162.159.175.0/24", + "162.159.176.0/24", + "162.159.177.0/24", + "162.159.178.0/24", + "162.159.179.0/24", + "162.159.180.0/24", + "162.159.181.0/24", + "162.159.182.0/24", + "162.159.183.0/24", + "162.159.184.0/24", + "162.159.185.0/24", + "162.159.186.0/24", + "162.159.187.0/24", + "162.159.188.0/24", + "162.159.189.0/24", + "162.159.190.0/24", + "162.159.191.0/24", + "162.159.192.0/24", + "162.159.193.0/24", + "162.159.194.0/24", + "162.159.195.0/24", + "162.159.196.0/24", + "162.159.197.0/24", + "162.159.198.0/24", + "162.159.199.0/24", + "162.159.200.0/24", + "162.159.201.0/24", + "162.159.202.0/24", + "162.159.203.0/24", + "162.159.204.0/24", + "162.159.205.0/24", + "162.159.206.0/24", + "162.159.207.0/24", + "162.159.208.0/24", + "162.159.209.0/24", + "162.159.210.0/24", + "162.159.211.0/24", + "162.159.212.0/24", + "162.159.213.0/24", + "162.159.214.0/24", + "162.159.215.0/24", + "162.159.216.0/24", + "162.159.217.0/24", + "162.159.218.0/24", + "162.159.219.0/24", + "162.159.220.0/24", + "162.159.221.0/24", + "162.159.222.0/24", + "162.159.223.0/24", + "162.159.224.0/24", + "162.159.225.0/24", + "162.159.226.0/24", + "162.159.227.0/24", + "162.159.228.0/24", + "162.159.229.0/24", + "162.159.230.0/24", + "162.159.231.0/24", + "162.159.232.0/24", + "162.159.233.0/24", + "162.159.234.0/24", + "162.159.235.0/24", + "162.159.236.0/24", + "162.159.237.0/24", + "162.159.238.0/24", + "162.159.239.0/24", + "162.159.240.0/24", + "162.159.241.0/24", + "162.159.242.0/24", + "162.159.243.0/24", + "162.159.244.0/24", + "162.159.245.0/24", + "162.159.246.0/24", + "162.159.247.0/24", + "162.159.248.0/24", + "162.159.249.0/24", + "162.159.250.0/24", + "162.159.251.0/24", + "162.159.252.0/24", + "162.159.253.0/24", + "162.159.254.0/24", + "162.159.255.0/24", + "162.251.82.0/24", + "172.64.0.0/24", + "172.64.1.0/24", + "172.64.2.0/24", + "172.64.3.0/24", + "172.64.4.0/24", + "172.64.5.0/24", + "172.64.6.0/24", + "172.64.7.0/24", + "172.64.8.0/24", + "172.64.9.0/24", + "172.64.10.0/24", + "172.64.11.0/24", + "172.64.12.0/24", + "172.64.13.0/24", + "172.64.14.0/24", + "172.64.15.0/24", + "172.64.16.0/24", + "172.64.17.0/24", + "172.64.18.0/24", + "172.64.19.0/24", + "172.64.20.0/24", + "172.64.21.0/24", + "172.64.22.0/24", + "172.64.23.0/24", + "172.64.24.0/24", + "172.64.25.0/24", + "172.64.26.0/24", + "172.64.27.0/24", + "172.64.28.0/24", + "172.64.29.0/24", + "172.64.30.0/24", + "172.64.31.0/24", + "172.64.32.0/24", + "172.64.33.0/24", + "172.64.34.0/24", + "172.64.35.0/24", + "172.64.36.0/24", + "172.64.37.0/24", + "172.64.38.0/24", + "172.64.39.0/24", + "172.64.40.0/24", + "172.64.41.0/24", + "172.64.42.0/24", + "172.64.43.0/24", + "172.64.44.0/24", + "172.64.45.0/24", + "172.64.46.0/24", + "172.64.47.0/24", + "172.64.48.0/24", + "172.64.49.0/24", + "172.64.50.0/24", + "172.64.51.0/24", + "172.64.52.0/24", + "172.64.53.0/24", + "172.64.54.0/24", + "172.64.55.0/24", + "172.64.56.0/24", + "172.64.57.0/24", + "172.64.58.0/24", + "172.64.59.0/24", + "172.64.60.0/24", + "172.64.61.0/24", + "172.64.62.0/24", + "172.64.63.0/24", + "172.64.64.0/24", + "172.64.65.0/24", + "172.64.66.0/24", + "172.64.67.0/24", + "172.64.68.0/24", + "172.64.69.0/24", + "172.64.70.0/24", + "172.64.71.0/24", + "172.64.72.0/24", + "172.64.73.0/24", + "172.64.74.0/24", + "172.64.75.0/24", + "172.64.76.0/24", + "172.64.77.0/24", + "172.64.78.0/24", + "172.64.79.0/24", + "172.64.80.0/24", + "172.64.81.0/24", + "172.64.82.0/24", + "172.64.83.0/24", + "172.64.84.0/24", + "172.64.85.0/24", + "172.64.86.0/24", + "172.64.87.0/24", + "172.64.88.0/24", + "172.64.89.0/24", + "172.64.90.0/24", + "172.64.91.0/24", + "172.64.92.0/24", + "172.64.93.0/24", + "172.64.94.0/24", + "172.64.95.0/24", + "172.64.96.0/24", + "172.64.97.0/24", + "172.64.98.0/24", + "172.64.99.0/24", + "172.64.100.0/24", + "172.64.101.0/24", + "172.64.102.0/24", + "172.64.103.0/24", + "172.64.104.0/24", + "172.64.105.0/24", + "172.64.106.0/24", + "172.64.107.0/24", + "172.64.108.0/24", + "172.64.109.0/24", + "172.64.110.0/24", + "172.64.111.0/24", + "172.64.112.0/24", + "172.64.113.0/24", + "172.64.114.0/24", + "172.64.115.0/24", + "172.64.116.0/24", + "172.64.117.0/24", + "172.64.118.0/24", + "172.64.119.0/24", + "172.64.120.0/24", + "172.64.121.0/24", + "172.64.122.0/24", + "172.64.123.0/24", + "172.64.124.0/24", + "172.64.125.0/24", + "172.64.126.0/24", + "172.64.127.0/24", + "172.64.128.0/24", + "172.64.129.0/24", + "172.64.130.0/24", + "172.64.131.0/24", + "172.64.132.0/24", + "172.64.133.0/24", + "172.64.134.0/24", + "172.64.135.0/24", + "172.64.136.0/24", + "172.64.137.0/24", + "172.64.138.0/24", + "172.64.139.0/24", + "172.64.140.0/24", + "172.64.141.0/24", + "172.64.142.0/24", + "172.64.143.0/24", + "172.64.144.0/24", + "172.64.145.0/24", + "172.64.146.0/24", + "172.64.147.0/24", + "172.64.148.0/24", + "172.64.149.0/24", + "172.64.150.0/24", + "172.64.151.0/24", + "172.64.152.0/24", + "172.64.153.0/24", + "172.64.154.0/24", + "172.64.155.0/24", + "172.64.156.0/24", + "172.64.157.0/24", + "172.64.158.0/24", + "172.64.159.0/24", + "172.64.160.0/24", + "172.64.161.0/24", + "172.64.162.0/24", + "172.64.163.0/24", + "172.64.164.0/24", + "172.64.165.0/24", + "172.64.166.0/24", + "172.64.167.0/24", + "172.64.168.0/24", + "172.64.169.0/24", + "172.64.170.0/24", + "172.64.171.0/24", + "172.64.172.0/24", + "172.64.173.0/24", + "172.64.174.0/24", + "172.64.175.0/24", + "172.64.176.0/24", + "172.64.177.0/24", + "172.64.178.0/24", + "172.64.179.0/24", + "172.64.180.0/24", + "172.64.181.0/24", + "172.64.182.0/24", + "172.64.183.0/24", + "172.64.184.0/24", + "172.64.185.0/24", + "172.64.186.0/24", + "172.64.187.0/24", + "172.64.188.0/24", + "172.64.189.0/24", + "172.64.190.0/24", + "172.64.191.0/24", + "172.64.192.0/24", + "172.64.193.0/24", + "172.64.194.0/24", + "172.64.195.0/24", + "172.64.196.0/24", + "172.64.197.0/24", + "172.64.198.0/24", + "172.64.199.0/24", + "172.64.200.0/24", + "172.64.201.0/24", + "172.64.202.0/24", + "172.64.203.0/24", + "172.64.204.0/24", + "172.64.205.0/24", + "172.64.206.0/24", + "172.64.207.0/24", + "172.64.208.0/24", + "172.64.209.0/24", + "172.64.210.0/24", + "172.64.211.0/24", + "172.64.212.0/24", + "172.64.213.0/24", + "172.64.214.0/24", + "172.64.215.0/24", + "172.64.216.0/24", + "172.64.217.0/24", + "172.64.218.0/24", + "172.64.219.0/24", + "172.64.220.0/24", + "172.64.221.0/24", + "172.64.222.0/24", + "172.64.223.0/24", + "172.64.224.0/24", + "172.64.225.0/24", + "172.64.226.0/24", + "172.64.227.0/24", + "172.64.228.0/24", + "172.64.229.0/24", + "172.64.230.0/24", + "172.64.231.0/24", + "172.64.232.0/24", + "172.64.233.0/24", + "172.64.234.0/24", + "172.64.235.0/24", + "172.64.236.0/24", + "172.64.237.0/24", + "172.64.238.0/24", + "172.64.239.0/24", + "172.64.240.0/24", + "172.64.241.0/24", + "172.64.242.0/24", + "172.64.243.0/24", + "172.64.244.0/24", + "172.64.245.0/24", + "172.64.246.0/24", + "172.64.247.0/24", + "172.64.248.0/24", + "172.64.249.0/24", + "172.64.250.0/24", + "172.64.251.0/24", + "172.64.252.0/24", + "172.64.253.0/24", + "172.64.254.0/24", + "172.64.255.0/24", + "172.65.0.0/24", + "172.65.1.0/24", + "172.65.2.0/24", + "172.65.3.0/24", + "172.65.4.0/24", + "172.65.5.0/24", + "172.65.6.0/24", + "172.65.7.0/24", + "172.65.8.0/24", + "172.65.9.0/24", + "172.65.10.0/24", + "172.65.11.0/24", + "172.65.12.0/24", + "172.65.13.0/24", + "172.65.14.0/24", + "172.65.15.0/24", + "172.65.16.0/24", + "172.65.17.0/24", + "172.65.18.0/24", + "172.65.19.0/24", + "172.65.20.0/24", + "172.65.21.0/24", + "172.65.22.0/24", + "172.65.23.0/24", + "172.65.24.0/24", + "172.65.25.0/24", + "172.65.26.0/24", + "172.65.27.0/24", + "172.65.28.0/24", + "172.65.29.0/24", + "172.65.30.0/24", + "172.65.31.0/24", + "172.65.32.0/24", + "172.65.33.0/24", + "172.65.34.0/24", + "172.65.35.0/24", + "172.65.36.0/24", + "172.65.37.0/24", + "172.65.38.0/24", + "172.65.39.0/24", + "172.65.40.0/24", + "172.65.41.0/24", + "172.65.42.0/24", + "172.65.43.0/24", + "172.65.44.0/24", + "172.65.45.0/24", + "172.65.46.0/24", + "172.65.47.0/24", + "172.65.48.0/24", + "172.65.49.0/24", + "172.65.50.0/24", + "172.65.51.0/24", + "172.65.52.0/24", + "172.65.53.0/24", + "172.65.54.0/24", + "172.65.55.0/24", + "172.65.56.0/24", + "172.65.57.0/24", + "172.65.58.0/24", + "172.65.59.0/24", + "172.65.60.0/24", + "172.65.61.0/24", + "172.65.62.0/24", + "172.65.63.0/24", + "172.65.64.0/24", + "172.65.65.0/24", + "172.65.66.0/24", + "172.65.67.0/24", + "172.65.68.0/24", + "172.65.69.0/24", + "172.65.70.0/24", + "172.65.71.0/24", + "172.65.72.0/24", + "172.65.73.0/24", + "172.65.74.0/24", + "172.65.75.0/24", + "172.65.76.0/24", + "172.65.77.0/24", + "172.65.78.0/24", + "172.65.79.0/24", + "172.65.80.0/24", + "172.65.81.0/24", + "172.65.82.0/24", + "172.65.83.0/24", + "172.65.84.0/24", + "172.65.85.0/24", + "172.65.86.0/24", + "172.65.87.0/24", + "172.65.88.0/24", + "172.65.89.0/24", + "172.65.90.0/24", + "172.65.91.0/24", + "172.65.92.0/24", + "172.65.93.0/24", + "172.65.94.0/24", + "172.65.95.0/24", + "172.65.96.0/24", + "172.65.97.0/24", + "172.65.98.0/24", + "172.65.99.0/24", + "172.65.100.0/24", + "172.65.101.0/24", + "172.65.102.0/24", + "172.65.103.0/24", + "172.65.104.0/24", + "172.65.105.0/24", + "172.65.106.0/24", + "172.65.107.0/24", + "172.65.108.0/24", + "172.65.109.0/24", + "172.65.110.0/24", + "172.65.111.0/24", + "172.65.112.0/24", + "172.65.113.0/24", + "172.65.114.0/24", + "172.65.115.0/24", + "172.65.116.0/24", + "172.65.117.0/24", + "172.65.118.0/24", + "172.65.119.0/24", + "172.65.120.0/24", + "172.65.121.0/24", + "172.65.122.0/24", + "172.65.123.0/24", + "172.65.124.0/24", + "172.65.125.0/24", + "172.65.126.0/24", + "172.65.127.0/24", + "172.65.128.0/24", + "172.65.129.0/24", + "172.65.130.0/24", + "172.65.131.0/24", + "172.65.132.0/24", + "172.65.133.0/24", + "172.65.134.0/24", + "172.65.135.0/24", + "172.65.136.0/24", + "172.65.137.0/24", + "172.65.138.0/24", + "172.65.139.0/24", + "172.65.140.0/24", + "172.65.141.0/24", + "172.65.142.0/24", + "172.65.143.0/24", + "172.65.144.0/24", + "172.65.145.0/24", + "172.65.146.0/24", + "172.65.147.0/24", + "172.65.148.0/24", + "172.65.149.0/24", + "172.65.150.0/24", + "172.65.151.0/24", + "172.65.152.0/24", + "172.65.153.0/24", + "172.65.154.0/24", + "172.65.155.0/24", + "172.65.156.0/24", + "172.65.157.0/24", + "172.65.158.0/24", + "172.65.159.0/24", + "172.65.160.0/24", + "172.65.161.0/24", + "172.65.162.0/24", + "172.65.163.0/24", + "172.65.164.0/24", + "172.65.165.0/24", + "172.65.166.0/24", + "172.65.167.0/24", + "172.65.168.0/24", + "172.65.169.0/24", + "172.65.170.0/24", + "172.65.171.0/24", + "172.65.172.0/24", + "172.65.173.0/24", + "172.65.174.0/24", + "172.65.175.0/24", + "172.65.176.0/24", + "172.65.177.0/24", + "172.65.178.0/24", + "172.65.179.0/24", + "172.65.180.0/24", + "172.65.181.0/24", + "172.65.182.0/24", + "172.65.183.0/24", + "172.65.184.0/24", + "172.65.185.0/24", + "172.65.186.0/24", + "172.65.187.0/24", + "172.65.188.0/24", + "172.65.189.0/24", + "172.65.190.0/24", + "172.65.191.0/24", + "172.65.192.0/24", + "172.65.193.0/24", + "172.65.194.0/24", + "172.65.195.0/24", + "172.65.196.0/24", + "172.65.197.0/24", + "172.65.198.0/24", + "172.65.199.0/24", + "172.65.200.0/24", + "172.65.201.0/24", + "172.65.202.0/24", + "172.65.203.0/24", + "172.65.204.0/24", + "172.65.205.0/24", + "172.65.206.0/24", + "172.65.207.0/24", + "172.65.208.0/24", + "172.65.209.0/24", + "172.65.210.0/24", + "172.65.211.0/24", + "172.65.212.0/24", + "172.65.213.0/24", + "172.65.214.0/24", + "172.65.215.0/24", + "172.65.216.0/24", + "172.65.217.0/24", + "172.65.218.0/24", + "172.65.219.0/24", + "172.65.220.0/24", + "172.65.221.0/24", + "172.65.222.0/24", + "172.65.223.0/24", + "172.65.224.0/24", + "172.65.225.0/24", + "172.65.226.0/24", + "172.65.227.0/24", + "172.65.228.0/24", + "172.65.229.0/24", + "172.65.230.0/24", + "172.65.231.0/24", + "172.65.232.0/24", + "172.65.233.0/24", + "172.65.234.0/24", + "172.65.235.0/24", + "172.65.236.0/24", + "172.65.237.0/24", + "172.65.238.0/24", + "172.65.239.0/24", + "172.65.240.0/24", + "172.65.241.0/24", + "172.65.242.0/24", + "172.65.243.0/24", + "172.65.244.0/24", + "172.65.245.0/24", + "172.65.246.0/24", + "172.65.247.0/24", + "172.65.248.0/24", + "172.65.249.0/24", + "172.65.250.0/24", + "172.65.251.0/24", + "172.65.252.0/24", + "172.65.253.0/24", + "172.65.254.0/24", + "172.65.255.0/24", + "172.66.0.0/24", + "172.66.1.0/24", + "172.66.2.0/24", + "172.66.3.0/24", + "172.66.40.0/24", + "172.66.41.0/24", + "172.66.42.0/24", + "172.66.43.0/24", + "172.66.44.0/24", + "172.66.45.0/24", + "172.66.46.0/24", + "172.66.47.0/24", + "172.67.0.0/24", + "172.67.1.0/24", + "172.67.2.0/24", + "172.67.3.0/24", + "172.67.4.0/24", + "172.67.5.0/24", + "172.67.6.0/24", + "172.67.7.0/24", + "172.67.8.0/24", + "172.67.9.0/24", + "172.67.10.0/24", + "172.67.11.0/24", + "172.67.12.0/24", + "172.67.13.0/24", + "172.67.14.0/24", + "172.67.15.0/24", + "172.67.16.0/24", + "172.67.17.0/24", + "172.67.18.0/24", + "172.67.19.0/24", + "172.67.20.0/24", + "172.67.21.0/24", + "172.67.22.0/24", + "172.67.23.0/24", + "172.67.24.0/24", + "172.67.25.0/24", + "172.67.26.0/24", + "172.67.27.0/24", + "172.67.28.0/24", + "172.67.29.0/24", + "172.67.30.0/24", + "172.67.31.0/24", + "172.67.32.0/24", + "172.67.33.0/24", + "172.67.34.0/24", + "172.67.35.0/24", + "172.67.36.0/24", + "172.67.37.0/24", + "172.67.38.0/24", + "172.67.39.0/24", + "172.67.40.0/24", + "172.67.41.0/24", + "172.67.42.0/24", + "172.67.43.0/24", + "172.67.44.0/24", + "172.67.45.0/24", + "172.67.46.0/24", + "172.67.47.0/24", + "172.67.48.0/24", + "172.67.49.0/24", + "172.67.50.0/24", + "172.67.51.0/24", + "172.67.52.0/24", + "172.67.53.0/24", + "172.67.54.0/24", + "172.67.55.0/24", + "172.67.56.0/24", + "172.67.57.0/24", + "172.67.58.0/24", + "172.67.59.0/24", + "172.67.60.0/24", + "172.67.61.0/24", + "172.67.62.0/24", + "172.67.63.0/24", + "172.67.64.0/24", + "172.67.65.0/24", + "172.67.66.0/24", + "172.67.67.0/24", + "172.67.68.0/24", + "172.67.69.0/24", + "172.67.70.0/24", + "172.67.71.0/24", + "172.67.72.0/24", + "172.67.73.0/24", + "172.67.74.0/24", + "172.67.75.0/24", + "172.67.76.0/24", + "172.67.77.0/24", + "172.67.78.0/24", + "172.67.79.0/24", + "172.67.80.0/24", + "172.67.81.0/24", + "172.67.82.0/24", + "172.67.83.0/24", + "172.67.84.0/24", + "172.67.85.0/24", + "172.67.86.0/24", + "172.67.87.0/24", + "172.67.88.0/24", + "172.67.89.0/24", + "172.67.90.0/24", + "172.67.91.0/24", + "172.67.92.0/24", + "172.67.93.0/24", + "172.67.94.0/24", + "172.67.95.0/24", + "172.67.96.0/24", + "172.67.97.0/24", + "172.67.98.0/24", + "172.67.99.0/24", + "172.67.100.0/24", + "172.67.101.0/24", + "172.67.102.0/24", + "172.67.103.0/24", + "172.67.104.0/24", + "172.67.105.0/24", + "172.67.106.0/24", + "172.67.107.0/24", + "172.67.108.0/24", + "172.67.109.0/24", + "172.67.110.0/24", + "172.67.111.0/24", + "172.67.112.0/24", + "172.67.113.0/24", + "172.67.114.0/24", + "172.67.115.0/24", + "172.67.116.0/24", + "172.67.117.0/24", + "172.67.118.0/24", + "172.67.119.0/24", + "172.67.120.0/24", + "172.67.121.0/24", + "172.67.122.0/24", + "172.67.123.0/24", + "172.67.124.0/24", + "172.67.125.0/24", + "172.67.126.0/24", + "172.67.127.0/24", + "172.67.128.0/24", + "172.67.129.0/24", + "172.67.130.0/24", + "172.67.131.0/24", + "172.67.132.0/24", + "172.67.133.0/24", + "172.67.134.0/24", + "172.67.135.0/24", + "172.67.136.0/24", + "172.67.137.0/24", + "172.67.138.0/24", + "172.67.139.0/24", + "172.67.140.0/24", + "172.67.141.0/24", + "172.67.142.0/24", + "172.67.143.0/24", + "172.67.144.0/24", + "172.67.145.0/24", + "172.67.146.0/24", + "172.67.147.0/24", + "172.67.148.0/24", + "172.67.149.0/24", + "172.67.150.0/24", + "172.67.151.0/24", + "172.67.152.0/24", + "172.67.153.0/24", + "172.67.154.0/24", + "172.67.155.0/24", + "172.67.156.0/24", + "172.67.157.0/24", + "172.67.158.0/24", + "172.67.159.0/24", + "172.67.160.0/24", + "172.67.161.0/24", + "172.67.162.0/24", + "172.67.163.0/24", + "172.67.164.0/24", + "172.67.165.0/24", + "172.67.166.0/24", + "172.67.167.0/24", + "172.67.168.0/24", + "172.67.169.0/24", + "172.67.170.0/24", + "172.67.171.0/24", + "172.67.172.0/24", + "172.67.173.0/24", + "172.67.174.0/24", + "172.67.175.0/24", + "172.67.176.0/24", + "172.67.177.0/24", + "172.67.178.0/24", + "172.67.179.0/24", + "172.67.180.0/24", + "172.67.181.0/24", + "172.67.182.0/24", + "172.67.183.0/24", + "172.67.184.0/24", + "172.67.185.0/24", + "172.67.186.0/24", + "172.67.187.0/24", + "172.67.188.0/24", + "172.67.189.0/24", + "172.67.190.0/24", + "172.67.191.0/24", + "172.67.192.0/24", + "172.67.193.0/24", + "172.67.194.0/24", + "172.67.195.0/24", + "172.67.196.0/24", + "172.67.197.0/24", + "172.67.198.0/24", + "172.67.199.0/24", + "172.67.200.0/24", + "172.67.201.0/24", + "172.67.202.0/24", + "172.67.203.0/24", + "172.67.204.0/24", + "172.67.205.0/24", + "172.67.206.0/24", + "172.67.207.0/24", + "172.67.208.0/24", + "172.67.209.0/24", + "172.67.210.0/24", + "172.67.211.0/24", + "172.67.212.0/24", + "172.67.213.0/24", + "172.67.214.0/24", + "172.67.215.0/24", + "172.67.216.0/24", + "172.67.217.0/24", + "172.67.218.0/24", + "172.67.219.0/24", + "172.67.220.0/24", + "172.67.221.0/24", + "172.67.222.0/24", + "172.67.223.0/24", + "172.67.224.0/24", + "172.67.225.0/24", + "172.67.226.0/24", + "172.67.227.0/24", + "172.67.228.0/24", + "172.67.229.0/24", + "172.67.230.0/24", + "172.67.231.0/24", + "172.67.232.0/24", + "172.67.233.0/24", + "172.67.234.0/24", + "172.67.235.0/24", + "172.67.236.0/24", + "172.67.237.0/24", + "172.67.238.0/24", + "172.67.239.0/24", + "172.67.240.0/24", + "172.67.241.0/24", + "172.67.242.0/24", + "172.67.243.0/24", + "172.67.244.0/24", + "172.67.245.0/24", + "172.67.246.0/24", + "172.67.247.0/24", + "172.67.248.0/24", + "172.67.249.0/24", + "172.67.250.0/24", + "172.67.251.0/24", + "172.67.252.0/24", + "172.67.253.0/24", + "172.67.254.0/24", + "172.67.255.0/24", + "172.68.0.0/24", + "172.68.1.0/24", + "172.68.2.0/24", + "172.68.3.0/24", + "172.68.4.0/24", + "172.68.5.0/24", + "172.68.6.0/24", + "172.68.7.0/24", + "172.68.8.0/24", + "172.68.9.0/24", + "172.68.10.0/24", + "172.68.11.0/24", + "172.68.12.0/24", + "172.68.13.0/24", + "172.68.14.0/24", + "172.68.15.0/24", + "172.68.16.0/24", + "172.68.17.0/24", + "172.68.18.0/24", + "172.68.19.0/24", + "172.68.20.0/24", + "172.68.21.0/24", + "172.68.22.0/24", + "172.68.23.0/24", + "172.68.24.0/24", + "172.68.25.0/24", + "172.68.26.0/24", + "172.68.27.0/24", + "172.68.28.0/24", + "172.68.29.0/24", + "172.68.30.0/24", + "172.68.31.0/24", + "172.68.32.0/24", + "172.68.33.0/24", + "172.68.34.0/24", + "172.68.35.0/24", + "172.68.36.0/24", + "172.68.37.0/24", + "172.68.38.0/24", + "172.68.39.0/24", + "172.68.40.0/24", + "172.68.41.0/24", + "172.68.42.0/24", + "172.68.43.0/24", + "172.68.45.0/24", + "172.68.46.0/24", + "172.68.47.0/24", + "172.68.48.0/24", + "172.68.49.0/24", + "172.68.50.0/24", + "172.68.51.0/24", + "172.68.52.0/24", + "172.68.53.0/24", + "172.68.54.0/24", + "172.68.55.0/24", + "172.68.56.0/24", + "172.68.57.0/24", + "172.68.58.0/24", + "172.68.59.0/24", + "172.68.60.0/24", + "172.68.61.0/24", + "172.68.62.0/24", + "172.68.63.0/24", + "172.68.64.0/24", + "172.68.65.0/24", + "172.68.66.0/24", + "172.68.67.0/24", + "172.68.68.0/24", + "172.68.69.0/24", + "172.68.70.0/24", + "172.68.71.0/24", + "172.68.72.0/24", + "172.68.73.0/24", + "172.68.74.0/24", + "172.68.75.0/24", + "172.68.76.0/24", + "172.68.77.0/24", + "172.68.78.0/24", + "172.68.79.0/24", + "172.68.80.0/24", + "172.68.81.0/24", + "172.68.83.0/24", + "172.68.84.0/24", + "172.68.85.0/24", + "172.68.86.0/24", + "172.68.87.0/24", + "172.68.88.0/24", + "172.68.89.0/24", + "172.68.90.0/24", + "172.68.91.0/24", + "172.68.92.0/24", + "172.68.93.0/24", + "172.68.94.0/24", + "172.68.95.0/24", + "172.68.96.0/24", + "172.68.97.0/24", + "172.68.98.0/24", + "172.68.99.0/24", + "172.68.100.0/24", + "172.68.101.0/24", + "172.68.102.0/24", + "172.68.103.0/24", + "172.68.104.0/24", + "172.68.105.0/24", + "172.68.106.0/24", + "172.68.107.0/24", + "172.68.108.0/24", + "172.68.109.0/24", + "172.68.110.0/24", + "172.68.111.0/24", + "172.68.112.0/24", + "172.68.113.0/24", + "172.68.114.0/24", + "172.68.115.0/24", + "172.68.116.0/24", + "172.68.117.0/24", + "172.68.118.0/24", + "172.68.119.0/24", + "172.68.120.0/24", + "172.68.121.0/24", + "172.68.123.0/24", + "172.68.124.0/24", + "172.68.125.0/24", + "172.68.126.0/24", + "172.68.127.0/24", + "172.68.128.0/24", + "172.68.129.0/24", + "172.68.130.0/24", + "172.68.131.0/24", + "172.68.132.0/24", + "172.68.133.0/24", + "172.68.134.0/24", + "172.68.135.0/24", + "172.68.136.0/24", + "172.68.137.0/24", + "172.68.138.0/24", + "172.68.139.0/24", + "172.68.140.0/24", + "172.68.141.0/24", + "172.68.142.0/24", + "172.68.143.0/24", + "172.68.144.0/24", + "172.68.145.0/24", + "172.68.146.0/24", + "172.68.147.0/24", + "172.68.148.0/24", + "172.68.149.0/24", + "172.68.150.0/24", + "172.68.151.0/24", + "172.68.152.0/24", + "172.68.153.0/24", + "172.68.154.0/24", + "172.68.155.0/24", + "172.68.161.0/24", + "172.68.162.0/24", + "172.68.163.0/24", + "172.68.164.0/24", + "172.68.165.0/24", + "172.68.166.0/24", + "172.68.167.0/24", + "172.68.168.0/24", + "172.68.169.0/24", + "172.68.170.0/24", + "172.68.171.0/24", + "172.68.172.0/24", + "172.68.173.0/24", + "172.68.174.0/24", + "172.68.175.0/24", + "172.68.176.0/24", + "172.68.177.0/24", + "172.68.179.0/24", + "172.68.180.0/24", + "172.68.181.0/24", + "172.68.182.0/24", + "172.68.183.0/24", + "172.68.184.0/24", + "172.68.185.0/24", + "172.68.186.0/24", + "172.68.187.0/24", + "172.68.188.0/24", + "172.68.189.0/24", + "172.68.190.0/24", + "172.68.191.0/24", + "172.68.196.0/24", + "172.68.197.0/24", + "172.68.198.0/24", + "172.68.199.0/24", + "172.68.200.0/24", + "172.68.201.0/24", + "172.68.202.0/24", + "172.68.203.0/24", + "172.68.204.0/24", + "172.68.205.0/24", + "172.68.206.0/24", + "172.68.207.0/24", + "172.68.208.0/24", + "172.68.209.0/24", + "172.68.210.0/24", + "172.68.211.0/24", + "172.68.212.0/24", + "172.68.213.0/24", + "172.68.214.0/24", + "172.68.215.0/24", + "172.68.217.0/24", + "172.68.218.0/24", + "172.68.219.0/24", + "172.68.220.0/24", + "172.68.221.0/24", + "172.68.222.0/24", + "172.68.223.0/24", + "172.68.224.0/24", + "172.68.225.0/24", + "172.68.226.0/24", + "172.68.227.0/24", + "172.68.228.0/24", + "172.68.229.0/24", + "172.68.230.0/24", + "172.68.231.0/24", + "172.68.232.0/24", + "172.68.233.0/24", + "172.68.234.0/24", + "172.68.235.0/24", + "172.68.236.0/24", + "172.68.237.0/24", + "172.68.238.0/24", + "172.68.239.0/24", + "172.68.240.0/24", + "172.68.241.0/24", + "172.68.242.0/24", + "172.68.243.0/24", + "172.68.244.0/24", + "172.68.245.0/24", + "172.68.246.0/24", + "172.68.247.0/24", + "172.68.248.0/24", + "172.68.249.0/24", + "172.68.250.0/24", + "172.68.251.0/24", + "172.68.252.0/24", + "172.68.253.0/24", + "172.68.255.0/24", + "172.69.0.0/24", + "172.69.1.0/24", + "172.69.2.0/24", + "172.69.3.0/24", + "172.69.4.0/24", + "172.69.5.0/24", + "172.69.6.0/24", + "172.69.7.0/24", + "172.69.8.0/24", + "172.69.9.0/24", + "172.69.10.0/24", + "172.69.11.0/24", + "172.69.12.0/24", + "172.69.13.0/24", + "172.69.14.0/24", + "172.69.15.0/24", + "172.69.16.0/24", + "172.69.18.0/24", + "172.69.19.0/24", + "172.69.20.0/24", + "172.69.21.0/24", + "172.69.22.0/24", + "172.69.23.0/24", + "172.69.32.0/24", + "172.69.33.0/24", + "172.69.34.0/24", + "172.69.35.0/24", + "172.69.36.0/24", + "172.69.37.0/24", + "172.69.38.0/24", + "172.69.39.0/24", + "172.69.40.0/24", + "172.69.41.0/24", + "172.69.42.0/24", + "172.69.43.0/24", + "172.69.44.0/24", + "172.69.45.0/24", + "172.69.46.0/24", + "172.69.47.0/24", + "172.69.48.0/24", + "172.69.52.0/24", + "172.69.53.0/24", + "172.69.54.0/24", + "172.69.55.0/24", + "172.69.60.0/24", + "172.69.61.0/24", + "172.69.62.0/24", + "172.69.63.0/24", + "172.69.64.0/24", + "172.69.65.0/24", + "172.69.66.0/24", + "172.69.67.0/24", + "172.69.68.0/24", + "172.69.69.0/24", + "172.69.70.0/24", + "172.69.71.0/24", + "172.69.72.0/24", + "172.69.73.0/24", + "172.69.74.0/24", + "172.69.75.0/24", + "172.69.76.0/24", + "172.69.77.0/24", + "172.69.78.0/24", + "172.69.79.0/24", + "172.69.80.0/24", + "172.69.81.0/24", + "172.69.82.0/24", + "172.69.83.0/24", + "172.69.84.0/24", + "172.69.85.0/24", + "172.69.86.0/24", + "172.69.87.0/24", + "172.69.88.0/24", + "172.69.89.0/24", + "172.69.90.0/24", + "172.69.91.0/24", + "172.69.92.0/24", + "172.69.93.0/24", + "172.69.94.0/24", + "172.69.95.0/24", + "172.69.96.0/24", + "172.69.97.0/24", + "172.69.100.0/24", + "172.69.101.0/24", + "172.69.102.0/24", + "172.69.103.0/24", + "172.69.105.0/24", + "172.69.106.0/24", + "172.69.107.0/24", + "172.69.108.0/24", + "172.69.109.0/24", + "172.69.110.0/24", + "172.69.111.0/24", + "172.69.112.0/24", + "172.69.113.0/24", + "172.69.114.0/24", + "172.69.115.0/24", + "172.69.116.0/24", + "172.69.117.0/24", + "172.69.118.0/24", + "172.69.119.0/24", + "172.69.124.0/24", + "172.69.125.0/24", + "172.69.126.0/24", + "172.69.127.0/24", + "172.69.128.0/24", + "172.69.129.0/24", + "172.69.130.0/24", + "172.69.131.0/24", + "172.69.132.0/24", + "172.69.133.0/24", + "172.69.134.0/24", + "172.69.135.0/24", + "172.69.136.0/24", + "172.69.137.0/24", + "172.69.138.0/24", + "172.69.139.0/24", + "172.69.140.0/24", + "172.69.141.0/24", + "172.69.142.0/24", + "172.69.143.0/24", + "172.69.144.0/24", + "172.69.145.0/24", + "172.69.146.0/24", + "172.69.147.0/24", + "172.69.148.0/24", + "172.69.149.0/24", + "172.69.150.0/24", + "172.69.151.0/24", + "172.69.156.0/24", + "172.69.157.0/24", + "172.69.158.0/24", + "172.69.159.0/24", + "172.69.160.0/24", + "172.69.161.0/24", + "172.69.162.0/24", + "172.69.163.0/24", + "172.69.164.0/24", + "172.69.165.0/24", + "172.69.166.0/24", + "172.69.167.0/24", + "172.69.168.0/24", + "172.69.169.0/24", + "172.69.170.0/24", + "172.69.171.0/24", + "172.69.172.0/24", + "172.69.173.0/24", + "172.69.174.0/24", + "172.69.175.0/24", + "172.69.180.0/24", + "172.69.181.0/24", + "172.69.182.0/24", + "172.69.183.0/24", + "172.69.184.0/24", + "172.69.185.0/24", + "172.69.186.0/24", + "172.69.187.0/24", + "172.69.188.0/24", + "172.69.189.0/24", + "172.69.190.0/24", + "172.69.191.0/24", + "172.69.192.0/24", + "172.69.193.0/24", + "172.69.194.0/24", + "172.69.195.0/24", + "172.69.196.0/24", + "172.69.197.0/24", + "172.69.198.0/24", + "172.69.199.0/24", + "172.69.200.0/24", + "172.69.201.0/24", + "172.69.202.0/24", + "172.69.203.0/24", + "172.69.204.0/24", + "172.69.205.0/24", + "172.69.206.0/24", + "172.69.207.0/24", + "172.69.208.0/24", + "172.69.210.0/24", + "172.69.211.0/24", + "172.69.212.0/24", + "172.69.216.0/24", + "172.69.217.0/24", + "172.69.218.0/24", + "172.69.219.0/24", + "172.69.220.0/24", + "172.69.221.0/24", + "172.69.224.0/24", + "172.69.225.0/24", + "172.69.226.0/24", + "172.69.227.0/24", + "172.69.228.0/24", + "172.69.229.0/24", + "172.69.230.0/24", + "172.69.231.0/24", + "172.69.232.0/24", + "172.69.233.0/24", + "172.69.234.0/24", + "172.69.235.0/24", + "172.69.236.0/24", + "172.69.237.0/24", + "172.69.238.0/24", + "172.69.239.0/24", + "172.69.241.0/24", + "172.69.242.0/24", + "172.69.244.0/24", + "172.69.245.0/24", + "172.69.246.0/24", + "172.69.247.0/24", + "172.69.248.0/24", + "172.69.250.0/24", + "172.69.251.0/24", + "172.69.252.0/24", + "172.69.253.0/24", + "172.69.254.0/24", + "172.69.255.0/24", + "172.70.32.0/24", + "172.70.33.0/24", + "172.70.34.0/24", + "172.70.35.0/24", + "172.70.36.0/24", + "172.70.37.0/24", + "172.70.38.0/24", + "172.70.39.0/24", + "172.70.40.0/24", + "172.70.41.0/24", + "172.70.42.0/24", + "172.70.43.0/24", + "172.70.44.0/24", + "172.70.45.0/24", + "172.70.46.0/24", + "172.70.47.0/24", + "172.70.48.0/24", + "172.70.49.0/24", + "172.70.51.0/24", + "172.70.52.0/24", + "172.70.53.0/24", + "172.70.54.0/24", + "172.70.55.0/24", + "172.70.56.0/24", + "172.70.57.0/24", + "172.70.58.0/24", + "172.70.59.0/24", + "172.70.60.0/24", + "172.70.61.0/24", + "172.70.62.0/24", + "172.70.63.0/24", + "172.70.80.0/24", + "172.70.81.0/24", + "172.70.82.0/24", + "172.70.83.0/24", + "172.70.84.0/24", + "172.70.85.0/24", + "172.70.86.0/24", + "172.70.87.0/24", + "172.70.88.0/24", + "172.70.89.0/24", + "172.70.90.0/24", + "172.70.91.0/24", + "172.70.92.0/24", + "172.70.93.0/24", + "172.70.94.0/24", + "172.70.95.0/24", + "172.70.96.0/24", + "172.70.97.0/24", + "172.70.98.0/24", + "172.70.99.0/24", + "172.70.100.0/24", + "172.70.101.0/24", + "172.70.102.0/24", + "172.70.103.0/24", + "172.70.104.0/24", + "172.70.105.0/24", + "172.70.106.0/24", + "172.70.107.0/24", + "172.70.108.0/24", + "172.70.109.0/24", + "172.70.110.0/24", + "172.70.111.0/24", + "172.70.112.0/24", + "172.70.113.0/24", + "172.70.114.0/24", + "172.70.115.0/24", + "172.70.116.0/24", + "172.70.117.0/24", + "172.70.120.0/24", + "172.70.121.0/24", + "172.70.122.0/24", + "172.70.123.0/24", + "172.70.124.0/24", + "172.70.125.0/24", + "172.70.126.0/24", + "172.70.127.0/24", + "172.70.128.0/24", + "172.70.129.0/24", + "172.70.130.0/24", + "172.70.131.0/24", + "172.70.132.0/24", + "172.70.133.0/24", + "172.70.134.0/24", + "172.70.135.0/24", + "172.70.136.0/24", + "172.70.138.0/24", + "172.70.139.0/24", + "172.70.140.0/24", + "172.70.141.0/24", + "172.70.142.0/24", + "172.70.143.0/24", + "172.70.144.0/24", + "172.70.145.0/24", + "172.70.146.0/24", + "172.70.147.0/24", + "172.70.148.0/24", + "172.70.149.0/24", + "172.70.150.0/24", + "172.70.152.0/24", + "172.70.153.0/24", + "172.70.154.0/24", + "172.70.155.0/24", + "172.70.156.0/24", + "172.70.157.0/24", + "172.70.158.0/24", + "172.70.160.0/24", + "172.70.161.0/24", + "172.70.162.0/24", + "172.70.163.0/24", + "172.70.172.0/24", + "172.70.173.0/24", + "172.70.174.0/24", + "172.70.175.0/24", + "172.70.176.0/24", + "172.70.177.0/24", + "172.70.178.0/24", + "172.70.179.0/24", + "172.70.180.0/24", + "172.70.181.0/24", + "172.70.182.0/24", + "172.70.183.0/24", + "172.70.186.0/24", + "172.70.187.0/24", + "172.70.188.0/24", + "172.70.189.0/24", + "172.70.190.0/24", + "172.70.191.0/24", + "172.70.192.0/24", + "172.70.193.0/24", + "172.70.194.0/24", + "172.70.195.0/24", + "172.70.196.0/24", + "172.70.197.0/24", + "172.70.198.0/24", + "172.70.199.0/24", + "172.70.200.0/24", + "172.70.202.0/24", + "172.70.203.0/24", + "172.70.204.0/24", + "172.70.205.0/24", + "172.70.206.0/24", + "172.70.207.0/24", + "172.70.208.0/24", + "172.70.209.0/24", + "172.70.210.0/24", + "172.70.211.0/24", + "172.70.212.0/24", + "172.70.213.0/24", + "172.70.214.0/24", + "172.70.215.0/24", + "172.70.216.0/24", + "172.70.217.0/24", + "172.70.218.0/24", + "172.70.219.0/24", + "172.70.220.0/24", + "172.70.221.0/24", + "172.70.222.0/24", + "172.70.223.0/24", + "172.70.224.0/24", + "172.70.225.0/24", + "172.70.226.0/24", + "172.70.227.0/24", + "172.70.228.0/24", + "172.70.229.0/24", + "172.70.230.0/24", + "172.70.231.0/24", + "172.70.232.0/24", + "172.70.233.0/24", + "172.70.234.0/24", + "172.70.235.0/24", + "172.70.236.0/24", + "172.70.237.0/24", + "172.70.238.0/24", + "172.70.239.0/24", + "172.70.240.0/24", + "172.70.241.0/24", + "172.70.242.0/24", + "172.70.243.0/24", + "172.70.244.0/24", + "172.70.245.0/24", + "172.70.246.0/24", + "172.70.247.0/24", + "172.70.248.0/24", + "172.70.249.0/24", + "172.70.250.0/24", + "172.70.251.0/24", + "172.70.252.0/24", + "172.70.253.0/24", + "172.70.254.0/24", + "172.70.255.0/24", + "172.71.0.0/24", + "172.71.2.0/24", + "172.71.3.0/24", + "172.71.4.0/24", + "172.71.5.0/24", + "172.71.6.0/24", + "172.71.7.0/24", + "172.71.8.0/24", + "172.71.9.0/24", + "172.71.10.0/24", + "172.71.11.0/24", + "172.71.12.0/24", + "172.71.13.0/24", + "172.71.14.0/24", + "172.71.15.0/24", + "172.71.16.0/24", + "172.71.17.0/24", + "172.71.20.0/24", + "172.71.21.0/24", + "172.71.22.0/24", + "172.71.23.0/24", + "172.71.24.0/24", + "172.71.25.0/24", + "172.71.26.0/24", + "172.71.27.0/24", + "172.71.28.0/24", + "172.71.29.0/24", + "172.71.30.0/24", + "172.71.31.0/24", + "172.71.80.0/24", + "172.71.81.0/24", + "172.71.82.0/24", + "172.71.83.0/24", + "172.71.84.0/24", + "172.71.85.0/24", + "172.71.86.0/24", + "172.71.87.0/24", + "172.71.88.0/24", + "172.71.89.0/24", + "172.71.90.0/24", + "172.71.92.0/24", + "172.71.93.0/24", + "172.71.94.0/24", + "172.71.95.0/24", + "172.71.96.0/24", + "172.71.97.0/24", + "172.71.98.0/24", + "172.71.99.0/24", + "172.71.100.0/24", + "172.71.101.0/24", + "172.71.102.0/24", + "172.71.103.0/24", + "172.71.108.0/24", + "172.71.109.0/24", + "172.71.110.0/24", + "172.71.111.0/24", + "172.71.112.0/24", + "172.71.113.0/24", + "172.71.114.0/24", + "172.71.115.0/24", + "172.71.116.0/24", + "172.71.117.0/24", + "172.71.118.0/24", + "172.71.119.0/24", + "172.71.120.0/24", + "172.71.121.0/24", + "172.71.122.0/24", + "172.71.123.0/24", + "172.71.124.0/24", + "172.71.125.0/24", + "172.71.126.0/24", + "172.71.127.0/24", + "172.71.128.0/24", + "172.71.129.0/24", + "172.71.130.0/24", + "172.71.131.0/24", + "172.71.132.0/24", + "172.71.133.0/24", + "172.71.134.0/24", + "172.71.135.0/24", + "172.71.137.0/24", + "172.71.138.0/24", + "172.71.139.0/24", + "172.71.140.0/24", + "172.71.141.0/24", + "172.71.142.0/24", + "172.71.143.0/24", + "172.71.144.0/24", + "172.71.145.0/24", + "172.71.146.0/24", + "172.71.147.0/24", + "172.71.148.0/24", + "172.71.149.0/24", + "172.71.150.0/24", + "172.71.151.0/24", + "172.71.152.0/24", + "172.71.153.0/24", + "172.71.154.0/24", + "172.71.155.0/24", + "172.71.156.0/24", + "172.71.157.0/24", + "172.71.158.0/24", + "172.71.159.0/24", + "172.71.160.0/24", + "172.71.161.0/24", + "172.71.162.0/24", + "172.71.163.0/24", + "172.71.164.0/24", + "172.71.165.0/24", + "172.71.166.0/24", + "172.71.167.0/24", + "172.71.168.0/24", + "172.71.169.0/24", + "172.71.170.0/24", + "172.71.171.0/24", + "172.71.172.0/24", + "172.71.173.0/24", + "172.71.174.0/24", + "172.71.175.0/24", + "172.71.176.0/24", + "172.71.177.0/24", + "172.71.178.0/24", + "172.71.179.0/24", + "172.71.180.0/24", + "172.71.181.0/24", + "172.71.182.0/24", + "172.71.183.0/24", + "172.71.184.0/24", + "172.71.185.0/24", + "172.71.186.0/24", + "172.71.187.0/24", + "172.71.188.0/24", + "172.71.189.0/24", + "172.71.190.0/24", + "172.71.191.0/24", + "172.71.192.0/24", + "172.71.193.0/24", + "172.71.194.0/24", + "172.71.195.0/24", + "172.71.196.0/24", + "172.71.197.0/24", + "172.71.198.0/24", + "172.71.199.0/24", + "172.71.200.0/24", + "172.71.201.0/24", + "172.71.202.0/24", + "172.71.203.0/24", + "172.71.204.0/24", + "172.71.205.0/24", + "172.71.206.0/24", + "172.71.207.0/24", + "172.71.208.0/24", + "172.71.209.0/24", + "172.71.210.0/24", + "172.71.211.0/24", + "172.71.212.0/24", + "172.71.213.0/24", + "172.71.214.0/24", + "172.71.215.0/24", + "172.71.216.0/24", + "172.71.217.0/24", + "172.71.218.0/24", + "172.71.219.0/24", + "172.71.220.0/24", + "172.71.221.0/24", + "172.71.222.0/24", + "172.71.223.0/24", + "172.71.224.0/24", + "172.71.225.0/24", + "172.71.226.0/24", + "172.71.227.0/24", + "172.71.228.0/24", + "172.71.229.0/24", + "172.71.230.0/24", + "172.71.231.0/24", + "172.71.232.0/24", + "172.71.233.0/24", + "172.71.234.0/24", + "172.71.235.0/24", + "172.71.236.0/24", + "172.71.237.0/24", + "172.71.238.0/24", + "172.71.239.0/24", + "172.71.240.0/24", + "172.71.241.0/24", + "172.71.242.0/24", + "172.71.243.0/24", + "172.71.244.0/24", + "172.71.245.0/24", + "172.71.246.0/24", + "172.71.247.0/24", + "172.71.248.0/24", + "172.71.249.0/24", + "172.71.250.0/24", + "172.71.251.0/24", + "172.71.252.0/24", + "172.71.253.0/24", + "172.71.254.0/24", + "172.71.255.0/24", + "173.245.49.0/24", + "173.245.54.0/24", + "173.245.58.0/24", + "173.245.59.0/24", + "173.245.63.0/24", + "185.146.172.0/24", + "185.146.173.0/24", + "188.114.96.0/24", + "188.114.97.0/24", + "188.114.98.0/24", + "188.114.99.0/24", + "188.114.100.0/24", + "188.114.102.0/24", + "188.114.103.0/24", + "188.114.106.0/24", + "188.114.107.0/24", + "188.114.108.0/24", + "188.114.111.0/24", + "190.93.240.0/24", + "190.93.241.0/24", + "190.93.242.0/24", + "190.93.243.0/24", + "190.93.244.0/24", + "190.93.245.0/24", + "190.93.246.0/24", + "190.93.247.0/24", + "190.93.248.0/24", + "190.93.249.0/24", + "190.93.250.0/24", + "190.93.251.0/24", + "190.93.252.0/24", + "190.93.253.0/24", + "190.93.254.0/24", + "190.93.255.0/24", + "195.242.122.0/24", + "195.242.123.0/24", + "197.234.240.0/24", + "197.234.241.0/24", + "197.234.242.0/24", + "197.234.243.0/24", + "198.41.129.0/24", + "198.41.192.0/24", + "198.41.193.0/24", + "198.41.194.0/24", + "198.41.195.0/24", + "198.41.196.0/24", + "198.41.197.0/24", + "198.41.198.0/24", + "198.41.199.0/24", + "198.41.200.0/24", + "198.41.201.0/24", + "198.41.202.0/24", + "198.41.203.0/24", + "198.41.204.0/24", + "198.41.205.0/24", + "198.41.206.0/24", + "198.41.207.0/24", + "198.41.208.0/24", + "198.41.209.0/24", + "198.41.211.0/24", + "198.41.212.0/24", + "198.41.214.0/24", + "198.41.215.0/24", + "198.41.216.0/24", + "198.41.217.0/24", + "198.41.218.0/24", + "198.41.219.0/24", + "198.41.220.0/24", + "198.41.221.0/24", + "198.41.222.0/24", + "198.41.223.0/24", + "198.41.224.0/24", + "198.41.225.0/24", + "198.41.226.0/24", + "198.41.227.0/24", + "198.41.228.0/24", + "198.41.229.0/24", + "198.41.230.0/24", + "198.41.231.0/24", + "198.41.232.0/24", + "198.41.233.0/24", + "198.41.236.0/24", + "198.41.237.0/24", + "198.41.238.0/24", + "198.41.239.0/24", + "198.41.240.0/24", + "198.41.241.0/24", + "198.41.242.0/24", + "198.217.251.0/24", + "199.27.128.0/24", + "199.27.129.0/24", + "199.27.130.0/24", + "199.27.131.0/24", + "199.27.132.0/24", + "199.27.134.0/24", + "199.27.135.0/24" + ]; + const cidrToRangeMask = (cidr) => { + const [ipRange, maskLength] = cidr.split('/'); + const ipInt = ipRange.split('.').reduce((acc, val) => (acc << 8) + parseInt(val, 10), 0); + const ipMask = -1 << (32 - parseInt(maskLength, 10)); + return [ipInt, ipMask]; + }; + + console.log(cidrList.map(cidrToRangeMask)); + + const ipInt = "142.250.204.68".split('.').reduce((acc, val) => (acc << 8) + parseInt(val, 10), 0) >>> 0; + console.log(ipInt); diff --git a/test/webstream.mjs b/test/webstream.mjs new file mode 100644 index 0000000..8c8400e --- /dev/null +++ b/test/webstream.mjs @@ -0,0 +1,73 @@ +let isCancel = false; +const readableStream = new ReadableStream({ + start(controller) { + let count = 0; + controller.enqueue(`Chunk ${count}`); + count++; + controller.enqueue(`Chunk ${count}`); + + // controller.error(new Error('uuid is not valid')); + // setTimeout(() => { + // console.log('ReadableStream was closed------valid22-------.'); + // controller.error(new Error('uuid is not valid22')); + // }, 1000); + + // const intervalId = setInterval(() => { + // if(!isCancel){ + // controller.enqueue(`Chunk ${count}`); + // } + // // controller.enqueue(`Chunk ${count}`); + // count++; + // if (count > 5) { + // console.log('ReadableStream was closed-------------.'); + // // controller.close() + // controller.error(new Error('uuid is not valid')); + // // clearInterval(intervalId); + // } + // }, 1000); + }, + async pull(controller) { + console.log('ReadableStream Pulling data...'); + // await new Promise((resolve) => setTimeout(resolve, 2000)); + }, + cancel() { + isCancel = true; + console.log('ReadableStream was canceled.'); + }, +}); + +const writableStream = new WritableStream({ + write(chunk, controller) { + console.log(`Received data: ${chunk}`); + if(chunk === 'Chunk 1'){ + controller.error('eroorooororo') + return; + } + // throw new Error('uuid is not valid'); + + // setTimeout( ()=>{ + // try { + // throw new Error('setTimeout hasve error valid'); + // }catch(error){ + // console.log('////setTimeout hasve error valid'); + // } + + // }, 2000) + + // controller.error(new Error('Received error')); + if(chunk === 'Chunk 3'){ + throw new Error('uuid is not valid'); + } + }, + close() { + console.log('WritableStream was closed'); + }, + abort() { + console.log('WritableStream was aborted'); + } +}); + +readableStream.pipeTo(writableStream).catch((err) => { + console.log('-----------------------error-------------------'); + console.log(err); +}); \ No newline at end of file diff --git a/test/worker/cf-cdn-cgi-trace.js b/test/worker/cf-cdn-cgi-trace.js new file mode 100644 index 0000000..64d9af1 --- /dev/null +++ b/test/worker/cf-cdn-cgi-trace.js @@ -0,0 +1,11 @@ +export default { + async fetch(request, env, ctx) { + const url = new URL(request.url); + const address = url.searchParams.get("address"); + if(!address){ + return new Response('not pass address', { status: 200 }); + } + const resp = fetch(`http://${address}/cdn-cgi/trace`); + return new Response((await resp).body, { status: 200 }); + } +}; diff --git a/test/worker/cf-worker-http-header.js b/test/worker/cf-worker-http-header.js new file mode 100644 index 0000000..0200b19 --- /dev/null +++ b/test/worker/cf-worker-http-header.js @@ -0,0 +1,22 @@ +export default { + /** + * @param {import("@cloudflare/workers-types").Request} request + * @param {{uuid: string}} env + * @param {import("@cloudflare/workers-types").ExecutionContext} ctx + * @returns {Promise} + */ + async fetch(request, env, ctx) { + const headers = {}; + for (const [name, value] of request.headers.entries()) { + headers[name] = value; + } + + const result = { + "http-header": headers, + "cf": request.cf + } + const headersJson = JSON.stringify(result); + console.log(headersJson); + return new Response(headersJson, { status: 200 }); + } +}; diff --git a/test/worker/cidr.js b/test/worker/cidr.js new file mode 100644 index 0000000..3d07c82 --- /dev/null +++ b/test/worker/cidr.js @@ -0,0 +1,33 @@ + +import IPCIDR from 'ip-cidr'; + +const chunk = '0'.repeat(1024 * 5); +export default { + async fetch(request, env, ctx) { + const isin = checkIPInCIDR("192.168.1.1", "102.1.5.2/24"); + + return new Response(null, { + status: 101 + }); + + + }, +}; + +function checkIPInCIDR(ip, cidr) { + const cidrObject = new IPCIDR(cidr); + + // Check if the IP address is valid + // if (!cidrObject.isValidAddress(ip)) { + // return false; + // } + + // Check if the IP address is within the CIDR range + return cidrObject.contains(ip); + } + +function delay(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms) + }) +} \ No newline at end of file diff --git a/test/worker/ipaddr-test.js b/test/worker/ipaddr-test.js new file mode 100644 index 0000000..6c873ad --- /dev/null +++ b/test/worker/ipaddr-test.js @@ -0,0 +1,1029 @@ +export default { + /** + * @param {import("@cloudflare/workers-types").Request} request + * @param {{uuid: string}} env + * @param {import("@cloudflare/workers-types").ExecutionContext} ctx + * @returns {Promise} + */ + async fetch(request, env, ctx) { + const headers = {}; + for (const [name, value] of request.headers.entries()) { + headers[name] = value; + } + + const result = { + "http-header": headers, + "cf": request.cf + } + const headersJson = JSON.stringify(result); + console.log(headersJson); + const addr = ipaddr.parse('2001:db8:1234::1'); + const range = ipaddr.parse('2001:db8::'); + + addr.match(range, 32); // => true + return new Response(headersJson, { status: 200 }); + } +}; + + +//ipadder.js +(function (root) { + 'use strict'; + // A list of regular expressions that match arbitrary IPv4 addresses, + // for which a number of weird notations exist. + // Note that an address like 0010.0xa5.1.1 is considered legal. + const ipv4Part = '(0?\\d+|0x[a-f0-9]+)'; + const ipv4Regexes = { + fourOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, 'i'), + threeOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, 'i'), + twoOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}$`, 'i'), + longValue: new RegExp(`^${ipv4Part}$`, 'i') + }; + + // Regular Expression for checking Octal numbers + const octalRegex = new RegExp(`^0[0-7]+$`, 'i'); + const hexRegex = new RegExp(`^0x[a-f0-9]+$`, 'i'); + + const zoneIndex = '%[0-9a-z]{1,}'; + + // IPv6-matching regular expressions. + // For IPv6, the task is simpler: it is enough to match the colon-delimited + // hexadecimal IPv6 and a transitional variant with dotted-decimal IPv4 at + // the end. + const ipv6Part = '(?:[0-9a-f]+::?)+'; + const ipv6Regexes = { + zoneIndex: new RegExp(zoneIndex, 'i'), + 'native': new RegExp(`^(::)?(${ipv6Part})?([0-9a-f]+)?(::)?(${zoneIndex})?$`, 'i'), + deprecatedTransitional: new RegExp(`^(?:::)(${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?)$`, 'i'), + transitional: new RegExp(`^((?:${ipv6Part})|(?:::)(?:${ipv6Part})?)${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?$`, 'i') + }; + + // Expand :: in an IPv6 address or address part consisting of `parts` groups. + function expandIPv6 (string, parts) { + // More than one '::' means invalid adddress + if (string.indexOf('::') !== string.lastIndexOf('::')) { + return null; + } + + let colonCount = 0; + let lastColon = -1; + let zoneId = (string.match(ipv6Regexes.zoneIndex) || [])[0]; + let replacement, replacementCount; + + // Remove zone index and save it for later + if (zoneId) { + zoneId = zoneId.substring(1); + string = string.replace(/%.+$/, ''); + } + + // How many parts do we already have? + while ((lastColon = string.indexOf(':', lastColon + 1)) >= 0) { + colonCount++; + } + + // 0::0 is two parts more than :: + if (string.substr(0, 2) === '::') { + colonCount--; + } + + if (string.substr(-2, 2) === '::') { + colonCount--; + } + + // The following loop would hang if colonCount > parts + if (colonCount > parts) { + return null; + } + + // replacement = ':' + '0:' * (parts - colonCount) + replacementCount = parts - colonCount; + replacement = ':'; + while (replacementCount--) { + replacement += '0:'; + } + + // Insert the missing zeroes + string = string.replace('::', replacement); + + // Trim any garbage which may be hanging around if :: was at the edge in + // the source strin + if (string[0] === ':') { + string = string.slice(1); + } + + if (string[string.length - 1] === ':') { + string = string.slice(0, -1); + } + + parts = (function () { + const ref = string.split(':'); + const results = []; + + for (let i = 0; i < ref.length; i++) { + results.push(parseInt(ref[i], 16)); + } + + return results; + })(); + + return { + parts: parts, + zoneId: zoneId + }; + } + + // A generic CIDR (Classless Inter-Domain Routing) RFC1518 range matcher. + function matchCIDR (first, second, partSize, cidrBits) { + if (first.length !== second.length) { + throw new Error('ipaddr: cannot match CIDR for objects with different lengths'); + } + + let part = 0; + let shift; + + while (cidrBits > 0) { + shift = partSize - cidrBits; + if (shift < 0) { + shift = 0; + } + + if (first[part] >> shift !== second[part] >> shift) { + return false; + } + + cidrBits -= partSize; + part += 1; + } + + return true; + } + + function parseIntAuto (string) { + // Hexadedimal base 16 (0x#) + if (hexRegex.test(string)) { + return parseInt(string, 16); + } + // While octal representation is discouraged by ECMAScript 3 + // and forbidden by ECMAScript 5, we silently allow it to + // work only if the rest of the string has numbers less than 8. + if (string[0] === '0' && !isNaN(parseInt(string[1], 10))) { + if (octalRegex.test(string)) { + return parseInt(string, 8); + } + throw new Error(`ipaddr: cannot parse ${string} as octal`); + } + // Always include the base 10 radix! + return parseInt(string, 10); + } + + function padPart (part, length) { + while (part.length < length) { + part = `0${part}`; + } + + return part; + } + + const ipaddr = {}; + + // An IPv4 address (RFC791). + ipaddr.IPv4 = (function () { + // Constructs a new IPv4 address from an array of four octets + // in network order (MSB first) + // Verifies the input. + function IPv4 (octets) { + if (octets.length !== 4) { + throw new Error('ipaddr: ipv4 octet count should be 4'); + } + + let i, octet; + + for (i = 0; i < octets.length; i++) { + octet = octets[i]; + if (!((0 <= octet && octet <= 255))) { + throw new Error('ipaddr: ipv4 octet should fit in 8 bits'); + } + } + + this.octets = octets; + } + + // Special IPv4 address ranges. + // See also https://en.wikipedia.org/wiki/Reserved_IP_addresses + IPv4.prototype.SpecialRanges = { + unspecified: [[new IPv4([0, 0, 0, 0]), 8]], + broadcast: [[new IPv4([255, 255, 255, 255]), 32]], + // RFC3171 + multicast: [[new IPv4([224, 0, 0, 0]), 4]], + // RFC3927 + linkLocal: [[new IPv4([169, 254, 0, 0]), 16]], + // RFC5735 + loopback: [[new IPv4([127, 0, 0, 0]), 8]], + // RFC6598 + carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]], + // RFC1918 + 'private': [ + [new IPv4([10, 0, 0, 0]), 8], + [new IPv4([172, 16, 0, 0]), 12], + [new IPv4([192, 168, 0, 0]), 16] + ], + // Reserved and testing-only ranges; RFCs 5735, 5737, 2544, 1700 + reserved: [ + [new IPv4([192, 0, 0, 0]), 24], + [new IPv4([192, 0, 2, 0]), 24], + [new IPv4([192, 88, 99, 0]), 24], + [new IPv4([198, 18, 0, 0]), 15], + [new IPv4([198, 51, 100, 0]), 24], + [new IPv4([203, 0, 113, 0]), 24], + [new IPv4([240, 0, 0, 0]), 4] + ] + }; + + // The 'kind' method exists on both IPv4 and IPv6 classes. + IPv4.prototype.kind = function () { + return 'ipv4'; + }; + + // Checks if this address matches other one within given CIDR range. + IPv4.prototype.match = function (other, cidrRange) { + let ref; + if (cidrRange === undefined) { + ref = other; + other = ref[0]; + cidrRange = ref[1]; + } + + if (other.kind() !== 'ipv4') { + throw new Error('ipaddr: cannot match ipv4 address with non-ipv4 one'); + } + + return matchCIDR(this.octets, other.octets, 8, cidrRange); + }; + + // returns a number of leading ones in IPv4 address, making sure that + // the rest is a solid sequence of 0's (valid netmask) + // returns either the CIDR length or null if mask is not valid + IPv4.prototype.prefixLengthFromSubnetMask = function () { + let cidr = 0; + // non-zero encountered stop scanning for zeroes + let stop = false; + // number of zeroes in octet + const zerotable = { + 0: 8, + 128: 7, + 192: 6, + 224: 5, + 240: 4, + 248: 3, + 252: 2, + 254: 1, + 255: 0 + }; + let i, octet, zeros; + + for (i = 3; i >= 0; i -= 1) { + octet = this.octets[i]; + if (octet in zerotable) { + zeros = zerotable[octet]; + if (stop && zeros !== 0) { + return null; + } + + if (zeros !== 8) { + stop = true; + } + + cidr += zeros; + } else { + return null; + } + } + + return 32 - cidr; + }; + + // Checks if the address corresponds to one of the special ranges. + IPv4.prototype.range = function () { + return ipaddr.subnetMatch(this, this.SpecialRanges); + }; + + // Returns an array of byte-sized values in network order (MSB first) + IPv4.prototype.toByteArray = function () { + return this.octets.slice(0); + }; + + // Converts this IPv4 address to an IPv4-mapped IPv6 address. + IPv4.prototype.toIPv4MappedAddress = function () { + return ipaddr.IPv6.parse(`::ffff:${this.toString()}`); + }; + + // Symmetrical method strictly for aligning with the IPv6 methods. + IPv4.prototype.toNormalizedString = function () { + return this.toString(); + }; + + // Returns the address in convenient, decimal-dotted format. + IPv4.prototype.toString = function () { + return this.octets.join('.'); + }; + + return IPv4; + })(); + + // A utility function to return broadcast address given the IPv4 interface and prefix length in CIDR notation + ipaddr.IPv4.broadcastAddressFromCIDR = function (string) { + + try { + const cidr = this.parseCIDR(string); + const ipInterfaceOctets = cidr[0].toByteArray(); + const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + const octets = []; + let i = 0; + while (i < 4) { + // Broadcast address is bitwise OR between ip interface and inverted mask + octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255); + i++; + } + + return new this(octets); + } catch (e) { + throw new Error('ipaddr: the address does not have IPv4 CIDR format'); + } + }; + + // Checks if a given string is formatted like IPv4 address. + ipaddr.IPv4.isIPv4 = function (string) { + return this.parser(string) !== null; + }; + + // Checks if a given string is a valid IPv4 address. + ipaddr.IPv4.isValid = function (string) { + try { + new this(this.parser(string)); + return true; + } catch (e) { + return false; + } + }; + + // Checks if a given string is a full four-part IPv4 Address. + ipaddr.IPv4.isValidFourPartDecimal = function (string) { + if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) { + return true; + } else { + return false; + } + }; + + // A utility function to return network address given the IPv4 interface and prefix length in CIDR notation + ipaddr.IPv4.networkAddressFromCIDR = function (string) { + let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets; + + try { + cidr = this.parseCIDR(string); + ipInterfaceOctets = cidr[0].toByteArray(); + subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + octets = []; + i = 0; + while (i < 4) { + // Network address is bitwise AND between ip interface and mask + octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10)); + i++; + } + + return new this(octets); + } catch (e) { + throw new Error('ipaddr: the address does not have IPv4 CIDR format'); + } + }; + + // Tries to parse and validate a string with IPv4 address. + // Throws an error if it fails. + ipaddr.IPv4.parse = function (string) { + const parts = this.parser(string); + + if (parts === null) { + throw new Error('ipaddr: string is not formatted like an IPv4 Address'); + } + + return new this(parts); + }; + + // Parses the string as an IPv4 Address with CIDR Notation. + ipaddr.IPv4.parseCIDR = function (string) { + let match; + + if ((match = string.match(/^(.+)\/(\d+)$/))) { + const maskLength = parseInt(match[2]); + if (maskLength >= 0 && maskLength <= 32) { + const parsed = [this.parse(match[1]), maskLength]; + Object.defineProperty(parsed, 'toString', { + value: function () { + return this.join('/'); + } + }); + return parsed; + } + } + + throw new Error('ipaddr: string is not formatted like an IPv4 CIDR range'); + }; + + // Classful variants (like a.b, where a is an octet, and b is a 24-bit + // value representing last three octets; this corresponds to a class C + // address) are omitted due to classless nature of modern Internet. + ipaddr.IPv4.parser = function (string) { + let match, part, value; + + // parseInt recognizes all that octal & hexadecimal weirdness for us + if ((match = string.match(ipv4Regexes.fourOctet))) { + return (function () { + const ref = match.slice(1, 6); + const results = []; + + for (let i = 0; i < ref.length; i++) { + part = ref[i]; + results.push(parseIntAuto(part)); + } + + return results; + })(); + } else if ((match = string.match(ipv4Regexes.longValue))) { + value = parseIntAuto(match[1]); + if (value > 0xffffffff || value < 0) { + throw new Error('ipaddr: address outside defined range'); + } + + return ((function () { + const results = []; + let shift; + + for (shift = 0; shift <= 24; shift += 8) { + results.push((value >> shift) & 0xff); + } + + return results; + })()).reverse(); + } else if ((match = string.match(ipv4Regexes.twoOctet))) { + return (function () { + const ref = match.slice(1, 4); + const results = []; + + value = parseIntAuto(ref[1]); + if (value > 0xffffff || value < 0) { + throw new Error('ipaddr: address outside defined range'); + } + + results.push(parseIntAuto(ref[0])); + results.push((value >> 16) & 0xff); + results.push((value >> 8) & 0xff); + results.push( value & 0xff); + + return results; + })(); + } else if ((match = string.match(ipv4Regexes.threeOctet))) { + return (function () { + const ref = match.slice(1, 5); + const results = []; + + value = parseIntAuto(ref[2]); + if (value > 0xffff || value < 0) { + throw new Error('ipaddr: address outside defined range'); + } + + results.push(parseIntAuto(ref[0])); + results.push(parseIntAuto(ref[1])); + results.push((value >> 8) & 0xff); + results.push( value & 0xff); + + return results; + })(); + } else { + return null; + } + }; + + // A utility function to return subnet mask in IPv4 format given the prefix length + ipaddr.IPv4.subnetMaskFromPrefixLength = function (prefix) { + prefix = parseInt(prefix); + if (prefix < 0 || prefix > 32) { + throw new Error('ipaddr: invalid IPv4 prefix length'); + } + + const octets = [0, 0, 0, 0]; + let j = 0; + const filledOctetCount = Math.floor(prefix / 8); + + while (j < filledOctetCount) { + octets[j] = 255; + j++; + } + + if (filledOctetCount < 4) { + octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - (prefix % 8); + } + + return new this(octets); + }; + + // An IPv6 address (RFC2460) + ipaddr.IPv6 = (function () { + // Constructs an IPv6 address from an array of eight 16 - bit parts + // or sixteen 8 - bit parts in network order(MSB first). + // Throws an error if the input is invalid. + function IPv6 (parts, zoneId) { + let i, part; + + if (parts.length === 16) { + this.parts = []; + for (i = 0; i <= 14; i += 2) { + this.parts.push((parts[i] << 8) | parts[i + 1]); + } + } else if (parts.length === 8) { + this.parts = parts; + } else { + throw new Error('ipaddr: ipv6 part count should be 8 or 16'); + } + + for (i = 0; i < this.parts.length; i++) { + part = this.parts[i]; + if (!((0 <= part && part <= 0xffff))) { + throw new Error('ipaddr: ipv6 part should fit in 16 bits'); + } + } + + if (zoneId) { + this.zoneId = zoneId; + } + } + + // Special IPv6 ranges + IPv6.prototype.SpecialRanges = { + // RFC4291, here and after + unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128], + linkLocal: [new IPv6([0xfe80, 0, 0, 0, 0, 0, 0, 0]), 10], + multicast: [new IPv6([0xff00, 0, 0, 0, 0, 0, 0, 0]), 8], + loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128], + uniqueLocal: [new IPv6([0xfc00, 0, 0, 0, 0, 0, 0, 0]), 7], + ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 0xffff, 0, 0]), 96], + // RFC6145 + rfc6145: [new IPv6([0, 0, 0, 0, 0xffff, 0, 0, 0]), 96], + // RFC6052 + rfc6052: [new IPv6([0x64, 0xff9b, 0, 0, 0, 0, 0, 0]), 96], + // RFC3056 + '6to4': [new IPv6([0x2002, 0, 0, 0, 0, 0, 0, 0]), 16], + // RFC6052, RFC6146 + teredo: [new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32], + // RFC4291 + reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]], + benchmarking: [new IPv6([0x2001, 0x2, 0, 0, 0, 0, 0, 0]), 48], + amt: [new IPv6([0x2001, 0x3, 0, 0, 0, 0, 0, 0]), 32], + as112v6: [new IPv6([0x2001, 0x4, 0x112, 0, 0, 0, 0, 0]), 48], + deprecated: [new IPv6([0x2001, 0x10, 0, 0, 0, 0, 0, 0]), 28], + orchid2: [new IPv6([0x2001, 0x20, 0, 0, 0, 0, 0, 0]), 28] + }; + + // Checks if this address is an IPv4-mapped IPv6 address. + IPv6.prototype.isIPv4MappedAddress = function () { + return this.range() === 'ipv4Mapped'; + }; + + // The 'kind' method exists on both IPv4 and IPv6 classes. + IPv6.prototype.kind = function () { + return 'ipv6'; + }; + + // Checks if this address matches other one within given CIDR range. + IPv6.prototype.match = function (other, cidrRange) { + let ref; + + if (cidrRange === undefined) { + ref = other; + other = ref[0]; + cidrRange = ref[1]; + } + + if (other.kind() !== 'ipv6') { + throw new Error('ipaddr: cannot match ipv6 address with non-ipv6 one'); + } + + return matchCIDR(this.parts, other.parts, 16, cidrRange); + }; + + // returns a number of leading ones in IPv6 address, making sure that + // the rest is a solid sequence of 0's (valid netmask) + // returns either the CIDR length or null if mask is not valid + IPv6.prototype.prefixLengthFromSubnetMask = function () { + let cidr = 0; + // non-zero encountered stop scanning for zeroes + let stop = false; + // number of zeroes in octet + const zerotable = { + 0: 16, + 32768: 15, + 49152: 14, + 57344: 13, + 61440: 12, + 63488: 11, + 64512: 10, + 65024: 9, + 65280: 8, + 65408: 7, + 65472: 6, + 65504: 5, + 65520: 4, + 65528: 3, + 65532: 2, + 65534: 1, + 65535: 0 + }; + let part, zeros; + + for (let i = 7; i >= 0; i -= 1) { + part = this.parts[i]; + if (part in zerotable) { + zeros = zerotable[part]; + if (stop && zeros !== 0) { + return null; + } + + if (zeros !== 16) { + stop = true; + } + + cidr += zeros; + } else { + return null; + } + } + + return 128 - cidr; + }; + + + // Checks if the address corresponds to one of the special ranges. + IPv6.prototype.range = function () { + return ipaddr.subnetMatch(this, this.SpecialRanges); + }; + + // Returns an array of byte-sized values in network order (MSB first) + IPv6.prototype.toByteArray = function () { + let part; + const bytes = []; + const ref = this.parts; + for (let i = 0; i < ref.length; i++) { + part = ref[i]; + bytes.push(part >> 8); + bytes.push(part & 0xff); + } + + return bytes; + }; + + // Returns the address in expanded format with all zeroes included, like + // 2001:0db8:0008:0066:0000:0000:0000:0001 + IPv6.prototype.toFixedLengthString = function () { + const addr = ((function () { + const results = []; + for (let i = 0; i < this.parts.length; i++) { + results.push(padPart(this.parts[i].toString(16), 4)); + } + + return results; + }).call(this)).join(':'); + + let suffix = ''; + + if (this.zoneId) { + suffix = `%${this.zoneId}`; + } + + return addr + suffix; + }; + + // Converts this address to IPv4 address if it is an IPv4-mapped IPv6 address. + // Throws an error otherwise. + IPv6.prototype.toIPv4Address = function () { + if (!this.isIPv4MappedAddress()) { + throw new Error('ipaddr: trying to convert a generic ipv6 address to ipv4'); + } + + const ref = this.parts.slice(-2); + const high = ref[0]; + const low = ref[1]; + + return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff]); + }; + + // Returns the address in expanded format with all zeroes included, like + // 2001:db8:8:66:0:0:0:1 + // + // Deprecated: use toFixedLengthString() instead. + IPv6.prototype.toNormalizedString = function () { + const addr = ((function () { + const results = []; + + for (let i = 0; i < this.parts.length; i++) { + results.push(this.parts[i].toString(16)); + } + + return results; + }).call(this)).join(':'); + + let suffix = ''; + + if (this.zoneId) { + suffix = `%${this.zoneId}`; + } + + return addr + suffix; + }; + + // Returns the address in compact, human-readable format like + // 2001:db8:8:66::1 + // in line with RFC 5952 (see https://tools.ietf.org/html/rfc5952#section-4) + IPv6.prototype.toRFC5952String = function () { + const regex = /((^|:)(0(:|$)){2,})/g; + const string = this.toNormalizedString(); + let bestMatchIndex = 0; + let bestMatchLength = -1; + let match; + + while ((match = regex.exec(string))) { + if (match[0].length > bestMatchLength) { + bestMatchIndex = match.index; + bestMatchLength = match[0].length; + } + } + + if (bestMatchLength < 0) { + return string; + } + + return `${string.substring(0, bestMatchIndex)}::${string.substring(bestMatchIndex + bestMatchLength)}`; + }; + + // Returns the address in compact, human-readable format like + // 2001:db8:8:66::1 + // Calls toRFC5952String under the hood. + IPv6.prototype.toString = function () { + return this.toRFC5952String(); + }; + + return IPv6; + + })(); + + // A utility function to return broadcast address given the IPv6 interface and prefix length in CIDR notation + ipaddr.IPv6.broadcastAddressFromCIDR = function (string) { + try { + const cidr = this.parseCIDR(string); + const ipInterfaceOctets = cidr[0].toByteArray(); + const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + const octets = []; + let i = 0; + while (i < 16) { + // Broadcast address is bitwise OR between ip interface and inverted mask + octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255); + i++; + } + + return new this(octets); + } catch (e) { + throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`); + } + }; + + // Checks if a given string is formatted like IPv6 address. + ipaddr.IPv6.isIPv6 = function (string) { + return this.parser(string) !== null; + }; + + // Checks to see if string is a valid IPv6 Address + ipaddr.IPv6.isValid = function (string) { + + // Since IPv6.isValid is always called first, this shortcut + // provides a substantial performance gain. + if (typeof string === 'string' && string.indexOf(':') === -1) { + return false; + } + + try { + const addr = this.parser(string); + new this(addr.parts, addr.zoneId); + return true; + } catch (e) { + return false; + } + }; + + // A utility function to return network address given the IPv6 interface and prefix length in CIDR notation + ipaddr.IPv6.networkAddressFromCIDR = function (string) { + let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets; + + try { + cidr = this.parseCIDR(string); + ipInterfaceOctets = cidr[0].toByteArray(); + subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + octets = []; + i = 0; + while (i < 16) { + // Network address is bitwise AND between ip interface and mask + octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10)); + i++; + } + + return new this(octets); + } catch (e) { + throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`); + } + }; + + // Tries to parse and validate a string with IPv6 address. + // Throws an error if it fails. + ipaddr.IPv6.parse = function (string) { + const addr = this.parser(string); + + if (addr.parts === null) { + throw new Error('ipaddr: string is not formatted like an IPv6 Address'); + } + + return new this(addr.parts, addr.zoneId); + }; + + ipaddr.IPv6.parseCIDR = function (string) { + let maskLength, match, parsed; + + if ((match = string.match(/^(.+)\/(\d+)$/))) { + maskLength = parseInt(match[2]); + if (maskLength >= 0 && maskLength <= 128) { + parsed = [this.parse(match[1]), maskLength]; + Object.defineProperty(parsed, 'toString', { + value: function () { + return this.join('/'); + } + }); + return parsed; + } + } + + throw new Error('ipaddr: string is not formatted like an IPv6 CIDR range'); + }; + + // Parse an IPv6 address. + ipaddr.IPv6.parser = function (string) { + let addr, i, match, octet, octets, zoneId; + + if ((match = string.match(ipv6Regexes.deprecatedTransitional))) { + return this.parser(`::ffff:${match[1]}`); + } + if (ipv6Regexes.native.test(string)) { + return expandIPv6(string, 8); + } + if ((match = string.match(ipv6Regexes.transitional))) { + zoneId = match[6] || ''; + addr = expandIPv6(match[1].slice(0, -1) + zoneId, 6); + if (addr.parts) { + octets = [ + parseInt(match[2]), + parseInt(match[3]), + parseInt(match[4]), + parseInt(match[5]) + ]; + for (i = 0; i < octets.length; i++) { + octet = octets[i]; + if (!((0 <= octet && octet <= 255))) { + return null; + } + } + + addr.parts.push(octets[0] << 8 | octets[1]); + addr.parts.push(octets[2] << 8 | octets[3]); + return { + parts: addr.parts, + zoneId: addr.zoneId + }; + } + } + + return null; + }; + + // A utility function to return subnet mask in IPv6 format given the prefix length + ipaddr.IPv6.subnetMaskFromPrefixLength = function (prefix) { + prefix = parseInt(prefix); + if (prefix < 0 || prefix > 128) { + throw new Error('ipaddr: invalid IPv6 prefix length'); + } + + const octets = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + let j = 0; + const filledOctetCount = Math.floor(prefix / 8); + + while (j < filledOctetCount) { + octets[j] = 255; + j++; + } + + if (filledOctetCount < 16) { + octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - (prefix % 8); + } + + return new this(octets); + }; + + // Try to parse an array in network order (MSB first) for IPv4 and IPv6 + ipaddr.fromByteArray = function (bytes) { + const length = bytes.length; + + if (length === 4) { + return new ipaddr.IPv4(bytes); + } else if (length === 16) { + return new ipaddr.IPv6(bytes); + } else { + throw new Error('ipaddr: the binary input is neither an IPv6 nor IPv4 address'); + } + }; + + // Checks if the address is valid IP address + ipaddr.isValid = function (string) { + return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string); + }; + + + // Attempts to parse an IP Address, first through IPv6 then IPv4. + // Throws an error if it could not be parsed. + ipaddr.parse = function (string) { + if (ipaddr.IPv6.isValid(string)) { + return ipaddr.IPv6.parse(string); + } else if (ipaddr.IPv4.isValid(string)) { + return ipaddr.IPv4.parse(string); + } else { + throw new Error('ipaddr: the address has neither IPv6 nor IPv4 format'); + } + }; + + // Attempt to parse CIDR notation, first through IPv6 then IPv4. + // Throws an error if it could not be parsed. + ipaddr.parseCIDR = function (string) { + try { + return ipaddr.IPv6.parseCIDR(string); + } catch (e) { + try { + return ipaddr.IPv4.parseCIDR(string); + } catch (e2) { + throw new Error('ipaddr: the address has neither IPv6 nor IPv4 CIDR format'); + } + } + }; + + // Parse an address and return plain IPv4 address if it is an IPv4-mapped address + ipaddr.process = function (string) { + const addr = this.parse(string); + + if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) { + return addr.toIPv4Address(); + } else { + return addr; + } + }; + + // An utility function to ease named range matching. See examples below. + // rangeList can contain both IPv4 and IPv6 subnet entries and will not throw errors + // on matching IPv4 addresses to IPv6 ranges or vice versa. + ipaddr.subnetMatch = function (address, rangeList, defaultName) { + let i, rangeName, rangeSubnets, subnet; + + if (defaultName === undefined || defaultName === null) { + defaultName = 'unicast'; + } + + for (rangeName in rangeList) { + if (Object.prototype.hasOwnProperty.call(rangeList, rangeName)) { + rangeSubnets = rangeList[rangeName]; + // ECMA5 Array.isArray isn't available everywhere + if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) { + rangeSubnets = [rangeSubnets]; + } + + for (i = 0; i < rangeSubnets.length; i++) { + subnet = rangeSubnets[i]; + if (address.kind() === subnet[0].kind() && address.match.apply(address, subnet)) { + return rangeName; + } + } + } + } + + return defaultName; + }; + + // Export for both the CommonJS and browser-like environment + if (typeof module !== 'undefined' && module.exports) { + module.exports = ipaddr; + + } else { + root.ipaddr = ipaddr; + } + +}(this)); \ No newline at end of file diff --git a/test/worker/stream-ws-test.js b/test/worker/stream-ws-test.js new file mode 100644 index 0000000..9743ab0 --- /dev/null +++ b/test/worker/stream-ws-test.js @@ -0,0 +1,55 @@ +export default { + async fetch(request, env, ctx) { + const upgradeHeader = request.headers.get('Upgrade'); + if (!upgradeHeader || upgradeHeader !== 'websocket') { + return new Response('not websocket', { status: 200 }); + } + const webSocketPair = new WebSocketPair(); + const [client, webSocket] = Object.values(webSocketPair); + webSocket.accept(); + let count = 0; + const readableStream = new ReadableStream({ + start(controller) { + setInterval(() => { + controller.enqueue(count); + count++; + }, 500) + + }, + async pull(controller) { + }, + cancel() { + console.log('ReadableStream was canceled.'); + }, + }); + + const writableStream = new WritableStream({ + write(chunk, controller) { + console.log(`Received data: ${chunk}`); + webSocket.send(`Received data: ${chunk}`); + if (chunk === 3) { + controller.error('eroorooororo') + return; + } + + }, + close() { + console.log('WritableStream was closed'); + }, + abort() { + console.log('WritableStream was aborted'); + } + }); + readableStream.pipeTo(writableStream).catch((error) => { + console.log('pipeTo error', error); + webSocket.close(); + }); + webSocket.addEventListener('close', () => { + console.log('close'); + }); + return new Response(null, { + status: 101, + webSocket: client, + }); + } +}; \ No newline at end of file diff --git a/test/worker/worker-connect-test.js b/test/worker/worker-connect-test.js new file mode 100644 index 0000000..ad6bb67 --- /dev/null +++ b/test/worker/worker-connect-test.js @@ -0,0 +1,46 @@ +import { connect } from 'cloudflare:sockets'; + +export default { + async fetch(request, env, ctx) { + console.log('start fetch'); + const cloudflare = 'www.cloudflare.com'; + const floodgap = 'gopher.floodgap.com'; + let host = floodgap; + const isFloodgap = request.url.includes('floodgap'); + const iscloudflare = request.url.includes('cloudflare'); + if (isFloodgap) { + host = floodgap; + } + if (iscloudflare) { + host = cloudflare; + } + + try { + const socket = connect( + { + hostname: host, + port: 443, + }, + { + secureTransport: 'on', + } + ); + console.log('start conneted', host); + const writer = socket.writable.getWriter(); + const encoder = new TextEncoder(); + const encoded = encoder.encode( + `GET / HTTP/1.1\r\nHost: ${host}\r\nUser-Agent: curl/8.0.1\r\nAccept: */*\r\n\r\n` + ); + await writer.write(encoded); + console.log('write end'); + + return new Response(socket.readable, { + headers: { 'Content-Type': 'text/plain' }, + }); + } catch (error) { + return new Response('Socket connection failed: ' + error, { + status: 500, + }); + } + }, +}; \ No newline at end of file diff --git a/test/worker/wrangler.toml b/test/worker/wrangler.toml new file mode 100644 index 0000000..7327796 --- /dev/null +++ b/test/worker/wrangler.toml @@ -0,0 +1,6 @@ +name = "cf-worker-http-header" # todo +main = "./cf-worker-http-header.js" +compatibility_date = "2023-05-26" + +[vars] +UUID = "example_dev_token" \ No newline at end of file diff --git a/test/worker/ws-send-issue.js b/test/worker/ws-send-issue.js new file mode 100644 index 0000000..685e293 --- /dev/null +++ b/test/worker/ws-send-issue.js @@ -0,0 +1,60 @@ + +const chunk = '0'.repeat(1024 * 5); +export default { + async fetch(request, env, ctx) { + try { + console.log('---------------'); + const webSocketPair = new WebSocketPair(); + /** @type {import("@cloudflare/workers-types").WebSocket[]} */ + const [client, webSocket] = Object.values(webSocketPair); + webSocket.accept(); + let btyes = 0; + // (async () => { + // const repose = await fetch('http://speed.cloudflare.com/__down?bytes=1145141919810') + // const body = repose.body; + // const reader = body?.getReader(); + // let packets = []; + // while (true && reader) { + // const { done, value } = await reader.read(); + // packets.push(value); + // console.log(btyes += value?.length || 0); + // if (packets.length > 100) { + // webSocket.send(value || ''); + // await delay(2); + // packets = []; + // } + // if (done) { + // break; + // } + // } + // })() + console.log('---------------'); + (async () => { + let packets = []; + console.log('---------------'); + while (true) { + console.log(btyes += chunk?.length || 0); + webSocket.send(chunk || ''); + await delay(1) + } + })() + // console.log(btyes += chunk?.length || 0); + // webSocket.send(chunk || ''); + + return new Response(null, { + status: 101, + webSocket: client, + }); + + } catch (err) { + /** @type {Error} */ let e = err; + return new Response(e.toString()); + } + }, +}; + +function delay(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms) + }) +} \ No newline at end of file diff --git a/wrangler.toml b/wrangler.toml new file mode 100644 index 0000000..ae75c1c --- /dev/null +++ b/wrangler.toml @@ -0,0 +1,7 @@ +name = "cf-worker-ws-dev" # todo +#main = "test/worker/cf-cdn-cgi-trace2.js" +main = "src/worker-vless.js" +compatibility_date = "2023-05-26" + +[vars] +UUID = "example_dev_token" \ No newline at end of file