Sample details: 7adc9b9e7361b042780d29b8ae1a8851 --

Hashes
MD5: 7adc9b9e7361b042780d29b8ae1a8851
SHA1: 5017ae4240a4cc970310e37a9150bbbf06c45ee9
SHA256: b405bc91f815ab6f32701c3b99eb779c585108400dc0d24aba8fc8d5d3ce12b4
SSDEEP: 1536:v2e0GFqFpfhKKi9iC+RUzr8Qi8i0UpSOKogyuBGYHEd0qWylY2ZMS6k1/tZ2Tyxk:+eGN6k1/ta
Details
File Type: UTF-8
Yara Hits
CuckooSandbox/embedded_pe | YRP/domain | YRP/url | YRP/contentis_base64 | YRP/android_meterpreter |
Parent Files
eae8b84e9121563341a0e4a268df0094
Strings
		/*******************************************************************************
    uBlock Origin - a browser extension to block requests.
    Copyright (C) 2014-present Raymond Hill
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see {http://www.gnu.org/licenses/}.
    Home: https://github.com/gorhill/uBlock
/* jshint bitwise: false */
/* global punycode */
'use strict';
/******************************************************************************/
Block.staticNetFilteringEngine = (( ) => {
/******************************************************************************/
const 
Block;
// fedcba9876543210
//       |    | |||
//       |    | |||
//       |    | |||
//       |    | |||
//       |    | ||+---- bit    0: [BlockAction | AllowAction]
//       |    | |+----- bit    1: `important`
//       |    | +------ bit 2- 3: party [0 - 3]
//       |    +-------- bit 4- 8: type [0 - 31]
//       +------------- bit 9-15: unused
const BlockAction = 0 << 0;
const AllowAction = 1 << 0;
const Important   = 1 << 1;
const AnyParty    = 0 << 2;
const FirstParty  = 1 << 2;
const ThirdParty  = 2 << 2;
const typeNameToTypeValue = {
           'no_type':  0 << 4,
        'stylesheet':  1 << 4,
             'image':  2 << 4,
            'object':  3 << 4,
 'object_subrequest':  3 << 4,
            'script':  4 << 4,
             'fetch':  5 << 4,
    'xmlhttprequest':  5 << 4,
         'sub_frame':  6 << 4,
              'font':  7 << 4,
             'media':  8 << 4,
         'websocket':  9 << 4,
             'other': 10 << 4,
             'popup': 11 << 4,  // start of behavorial filtering
          'popunder': 12 << 4,
        'main_frame': 13 << 4,  // start of 1st-party-only behavorial filtering
       'generichide': 14 << 4,
       'inline-font': 15 << 4,
     'inline-script': 16 << 4,
              'data': 17 << 4,  // special: a generic data holder
          'redirect': 18 << 4,
            'webrtc': 19 << 4,
       'unsupported': 20 << 4
const otherTypeBitValue = typeNameToTypeValue.other;
// All network request types to bitmap
//   bring origin to 0 (from 4 -- see typeNameToTypeValue)
//   left-shift 1 by the above-calculated value
//   subtract 1 to set all type bits
const allNetworkTypesBits =
    (1 << (otherTypeBitValue >>> 4)) - 1;
const allTypesBits =
    allNetworkTypesBits |
    1 << (typeNameToTypeValue['popup'] >>> 4) - 1 |
    1 << (typeNameToTypeValue['main_frame'] >>> 4) - 1 |
    1 << (typeNameToTypeValue['inline-font'] >>> 4) - 1 |
    1 << (typeNameToTypeValue['inline-script'] >>> 4) - 1;
const unsupportedTypeBit =
    1 << (typeNameToTypeValue['unsupported'] >>> 4) - 1;
const typeValueToTypeName = {
     1: 'stylesheet',
     2: 'image',
     3: 'object',
     4: 'script',
     5: 'xmlhttprequest',
     6: 'subdocument',
     7: 'font',
     8: 'media',
     9: 'websocket',
    10: 'other',
    11: 'popup',
    12: 'popunder',
    13: 'document',
    14: 'generichide',
    15: 'inline-font',
    16: 'inline-script',
    17: 'data',
    18: 'redirect',
    19: 'webrtc',
    20: 'unsupported'
const BlockImportant = BlockAction | Important;
const reIsWildcarded = /[\^\*]/;
// ABP filters: https://adblockplus.org/en/filters
// regex tester: http://regex101.com/
/******************************************************************************/
// See the following as short-lived registers, used during evaluation. They are
// valid until the next evaluation.
let urlRegister = '';
let pageHostnameRegister = '';
let requestHostnameRegister = '';
/******************************************************************************/
// First character of match must be within the hostname part of the url.
// https://github.com/gorhill/uBlock/issues/1929
//   Match only hostname label boundaries.
const isHnAnchored = (( ) => {
    let lastLen = 0, lastBeg = -1, lastEnd = -1;
    return (url, matchStart) => {
        const len = requestHostnameRegister.length;
        if ( len !== lastLen || url.endsWith('://', lastBeg) === false ) {
            lastBeg = len !== 0 ? url.indexOf('://') : -1;
            if ( lastBeg !== -1 ) {
                lastBeg += 3;
                lastEnd = lastBeg + len;
            } else {
                lastEnd = -1;
            }
        }
        return matchStart < lastEnd && (
            matchStart === lastBeg ||
            matchStart > lastBeg &&
                url.charCodeAt(matchStart - 1) === 0x2E /* '.' */
        );
    };
/******************************************************************************/
// Local helpers
const normalizeRegexSource = function(s) {
    try {
        const re = new RegExp(s);
        return re.source;
    } catch (ex) {
        normalizeRegexSource.message = ex.toString();
    return '';
const rawToRegexStr = function(s, anchor) {
    // https://www.loggly.com/blog/five-invaluable-techniques-to-improve-regex-performance/
    // https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions
    // Also: remove leading/trailing wildcards -- there is no point.
    let reStr = s.replace(rawToRegexStr.escape1, '\\$&')
                 .replace(rawToRegexStr.escape2, '(?:[^%.0-9a-z_-]|$)')
                 .replace(rawToRegexStr.escape3, '')
                 .replace(rawToRegexStr.escape4, '[^ ]*?');
    if ( anchor & 0b100 ) {
        reStr = (
            reStr.startsWith('\\.') ?
                rawToRegexStr.reTextHostnameAnchor2 :
                rawToRegexStr.reTextHostnameAnchor1
        ) + reStr;
    } else if ( anchor & 0b010 ) {
        reStr = '^' + reStr;
    if ( anchor & 0b001 ) {
        reStr += '$';
    return reStr;
rawToRegexStr.escape1 = /[.+?${}()|[\]\\]/g;
rawToRegexStr.escape2 = /\^/g;
rawToRegexStr.escape3 = /^\*|\*$/g;
rawToRegexStr.escape4 = /\*/g;
rawToRegexStr.reTextHostnameAnchor1 = '^[a-z-]+://(?:[^/?#]+\\.)?';
rawToRegexStr.reTextHostnameAnchor2 = '^[a-z-]+://(?:[^/?#]+)?';
// https://github.com/uBlockOrigin/uAssets/issues/4083#issuecomment-436914727
const rawToPlainStr = function(s, anchor) {
    if (
        anchor === 0 &&
        s.charCodeAt(0) === 0x2F /* '/' */ &&
        s.length > 2 &&
        s.charCodeAt(s.length-1) === 0x2F /* '/' */
    ) {
        s = s + '*';
    return s;
const filterDataSerialize = 
b.CompiledLineIO.serialize;
const toLogDataInternal = function(categoryBits, tokenHash, filter) {
    if ( filter === null ) { return undefined; }
    const logData = filter.logData();
    logData.compiled = filterDataSerialize([
        categoryBits,
        tokenHash,
        logData.compiled
    ]);
    if ( categoryBits & 0x001 ) {
        logData.raw = `@@${logData.raw}`;
    const opts = [];
    if ( categoryBits & 0x002 ) {
        opts.push('important');
    if ( categoryBits & 0x008 ) {
        opts.push('third-party');
    } else if ( categoryBits & 0x004 ) {
        opts.push('first-party');
    const type = categoryBits & 0x1F0;
    if ( type !== 0 && type !== typeNameToTypeValue.data ) {
        opts.push(typeValueToTypeName[type >>> 4]);
    if ( logData.opts !== undefined ) {
        opts.push(logData.opts);
    if ( opts.length !== 0 ) {
        logData.raw += '$' + opts.join(',');
    return logData;
/*******************************************************************************
    Each filter class will register itself in the map. A filter class
    id MUST always stringify to ONE single character.
    IMPORTANT: any change which modifies the mapping will have to be
    reflected with 
Block.systemSettings.compiledMagic.
const filterClasses = [];
let   filterClassIdGenerator = 0;
const registerFilterClass = function(ctor) {
    let fid = filterClassIdGenerator++;
    ctor.fid = ctor.prototype.fid = fid;
    filterClasses[fid] = ctor;
const filterFromCompiledData = function(args) {
    return filterClasses[args[0]].load(args);
/******************************************************************************/
const FilterTrue = class {
    match() {
        return true;
    logData() {
        return {
            raw: '*',
            regex: '^',
            compiled: this.compile(),
        };
    compile() {
        return [ this.fid ];
    static compile() {
        return [ FilterTrue.fid ];
    static load() {
        return FilterTrue.instance;
FilterTrue.instance = new FilterTrue();
registerFilterClass(FilterTrue);
/******************************************************************************/
const FilterPlain = class {
    constructor(s) {
        this.s = s;
    match(url, tokenBeg) {
        return url.startsWith(this.s, tokenBeg);
    logData() {
        return {
            raw: rawToPlainStr(this.s, 0),
            regex: rawToRegexStr(this.s, 0),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s, this.tokenBeg ];
    addToTrie(trie) {
        if ( this.s.length > 255 ) { return false; }
        trie.add(this.s, this.tokenBeg);
        return true;
    static compile(details) {
        return [ FilterPlain.fid, details.f, details.tokenBeg ];
    static load(args) {
        if ( args[2] === 0 ) {
            return new FilterPlain(args[1]);
        }
        if ( args[2] === 1 ) {
            return new FilterPlain1(args[1]);
        }
        return new FilterPlainX(args[1], args[2]);
    static addToTrie(args, trie) {
        if ( args[1].length > 255 ) { return false; }
        trie.add(args[1], args[2]);
        return true;
FilterPlain.trieableId = 0;
FilterPlain.prototype.trieableId = FilterPlain.trieableId;
FilterPlain.prototype.tokenBeg = 0;
registerFilterClass(FilterPlain);
const FilterPlain1 = class extends FilterPlain {
    match(url, tokenBeg) {
        return url.startsWith(this.s, tokenBeg - 1);
FilterPlain1.prototype.tokenBeg = 1;
const FilterPlainX = class extends FilterPlain {
    constructor(s, tokenBeg) {
        super(s);
        this.tokenBeg = tokenBeg;
    match(url, tokenBeg) {
        return url.startsWith(this.s, tokenBeg - this.tokenBeg);
/******************************************************************************/
const FilterPlainHostname = class {
    constructor(s) {
        this.s = s;
    match() {
        const haystack = requestHostnameRegister;
        const needle = this.s;
        if ( haystack.endsWith(needle) === false ) { return false; }
        const offset = haystack.length - needle.length;
        return offset === 0 || haystack.charCodeAt(offset - 1) === 0x2E /* '.' */;
    logData() {
        return {
            raw: `||${this.s}^`,
            regex: rawToRegexStr(`${this.s}^`, 0),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s ];
    static compile(details) {
        return [ FilterPlainHostname.fid, details.f ];
    static load(args) {
        return new FilterPlainHostname(args[1]);
registerFilterClass(FilterPlainHostname);
/******************************************************************************/
const FilterPlainLeftAnchored = class {
    constructor(s) {
        this.s = s;
    match(url) {
        return url.startsWith(this.s);
    logData() {
        return {
            raw: `|${this.s}`,
            regex: rawToRegexStr(this.s, 0b010),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s ];
    static compile(details) {
        return [ FilterPlainLeftAnchored.fid, details.f ];
    static load(args) {
        return new FilterPlainLeftAnchored(args[1]);
registerFilterClass(FilterPlainLeftAnchored);
/******************************************************************************/
const FilterPlainRightAnchored = class {
    constructor(s) {
        this.s = s;
    match(url) {
        return url.endsWith(this.s);
    logData() {
        return {
            raw: `${this.s}|`,
            regex: rawToRegexStr(this.s, 0b001),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s ];
    static compile(details) {
        return [ FilterPlainRightAnchored.fid, details.f ];
    static load(args) {
        return new FilterPlainRightAnchored(args[1]);
registerFilterClass(FilterPlainRightAnchored);
/******************************************************************************/
const FilterExactMatch = class {
    constructor(s) {
        this.s = s;
    match(url) {
        return url === this.s;
    logData() {
        return {
            raw: `|${this.s}|`,
            regex: rawToRegexStr(this.s, 0b011),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s ];
    static compile(details) {
        return [ FilterExactMatch.fid, details.f ];
    static load(args) {
        return new FilterExactMatch(args[1]);
registerFilterClass(FilterExactMatch);
/******************************************************************************/
const FilterPlainHnAnchored = class {
    constructor(s) {
        this.s = s;
    match(url, tokenBeg) {
        return url.startsWith(this.s, tokenBeg) &&
               isHnAnchored(url, tokenBeg);
    logData() {
        return {
            raw: `||${this.s}`,
            regex: rawToRegexStr(this.s, this.tokenBeg),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s, this.tokenBeg ];
    addToTrie(trie) {
        if ( this.s.length > 255 ) { return false; }
        trie.add(this.s, this.tokenBeg);
        return true;
    static compile(details) {
        return [ FilterPlainHnAnchored.fid, details.f, details.tokenBeg ];
    static load(args) {
        if ( args[2] === 0 ) {
            return new FilterPlainHnAnchored(args[1]);
        }
        return new FilterPlainHnAnchoredX(args[1], args[2]);
    static addToTrie(args, trie) {
        if ( args[1].length > 255 ) { return false; }
        trie.add(args[1], args[2]);
        return true;
FilterPlainHnAnchored.trieableId = 1;
FilterPlainHnAnchored.prototype.trieableId = FilterPlainHnAnchored.trieableId;
FilterPlainHnAnchored.prototype.tokenBeg = 0;
registerFilterClass(FilterPlainHnAnchored);
const FilterPlainHnAnchoredX = class extends FilterPlainHnAnchored {
    constructor(s, tokenBeg) {
        super(s);
        this.tokenBeg = tokenBeg;
    match(url, tokenBeg) {
        const beg = tokenBeg - this.tokenBeg;
        return url.startsWith(this.s, beg) && isHnAnchored(url, beg);
/*******************************************************************************
    Filters with only one single occurrence of wildcard `*`
const FilterWildcard1 = class {
    constructor(s0, s1, tokenBeg) {
        this.s0 = s0;
        this.s1 = s1;
        this.tokenBeg = tokenBeg;
    match(url, tokenBeg) {
        if ( this.tokenBeg >= 0 ) {
            const s0Beg = tokenBeg - this.tokenBeg;
            return s0Beg >= 0 &&
                   url.startsWith(this.s0, s0Beg) &&
                   url.indexOf(this.s1, s0Beg + this.s0.length) !== -1;
        }
        const s1Beg = tokenBeg + this.tokenBeg;
        return s1Beg > 0 &&
               url.startsWith(this.s1, s1Beg) &&
               url.lastIndexOf(this.s0, s1Beg) !== -1;
    logData() {
        return {
            raw: `${this.s0}*${this.s1}`,
            regex: rawToRegexStr(`${this.s0}*${this.s1}`, 0),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s0, this.s1, this.tokenBeg ];
    static compile(details) {
        if ( details.token === '*' ) { return; }
        if ( details.anchor !== 0 ) { return; }
        const s = details.f;
        let pos = s.indexOf('*');
        if ( pos === -1 ) { return; }
        if ( reIsWildcarded.test(s.slice(pos + 1)) ) { return; }
        if ( reIsWildcarded.test(s.slice(0, pos)) ) { return; }
        return [
            FilterWildcard1.fid,
            s.slice(0, pos),
            s.slice(pos + 1),
            details.tokenBeg < pos
                ? details.tokenBeg
                : pos + 1 - details.tokenBeg,
        ];
    static load(args) {
        return new FilterWildcard1(args[1], args[2], args[3]);
registerFilterClass(FilterWildcard1);
/******************************************************************************/
const FilterGeneric = class {
    constructor(s, anchor) {
        this.s = s;
        this.anchor = anchor;
    match(url) {
        if ( this.re === null ) {
            this.re = new RegExp(rawToRegexStr(this.s, this.anchor));
        }
        return this.re.test(url);
    logData() {
        const out = {
            raw: rawToPlainStr(this.s, this.anchor),
            regex: this.re.source,
            compiled: this.compile()
        };
        if ( this.anchor & 0x2 ) {
            out.raw = `|${out.raw}`;
        }
        if ( this.anchor & 0x1 ) {
            out.raw += '|';
        }
        return out;
    compile() {
        return [ this.fid, this.s, this.anchor ];
    static compile(details) {
        const compiled = FilterWildcard1.compile(details);
        if ( compiled !== undefined ) { return compiled; }
        return [ FilterGeneric.fid, details.f, details.anchor ];
    static load(args) {
        return new FilterGeneric(args[1], args[2]);
FilterGeneric.prototype.re = null;
registerFilterClass(FilterGeneric);
/*******************************************************************************
    Hostname-anchored filters with only one occurrence of wildcard `*`
const FilterWildcard1HnAnchored = class {
    constructor(s0, s1, tokenBeg) {
        this.s0 = s0;
        this.s1 = s1;
        this.tokenBeg = tokenBeg;
    match(url, tokenBeg) {
        if ( this.tokenBeg >= 0 ) {
            const s0Beg = tokenBeg - this.tokenBeg;
            return s0Beg >= 0 &&
                   url.startsWith(this.s0, s0Beg) &&
                   isHnAnchored(url, s0Beg) &&
                   url.indexOf(this.s1, s0Beg + this.s0.length) !== -1;
        }
        const s1Beg = tokenBeg + this.tokenBeg;
        if ( s1Beg < 0 || url.startsWith(this.s1, s1Beg) === false ) {
            return false;
        }
        const s0Beg = url.lastIndexOf(this.s0, s1Beg);
        return s0Beg !== -1 && isHnAnchored(url, s0Beg);
    logData() {
        return {
            raw: `||${this.s0}*${this.s1}`,
            regex: rawToRegexStr(`${this.s0}*${this.s1}`, 0),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s0, this.s1, this.tokenBeg ];
    static compile(details) {
        if ( details.token === '*' ) { return; }
        if ( (details.anchor & 0x0b001) !== 0 ) { return; }
        const s = details.f;
        let pos = s.indexOf('*');
        if ( pos === -1 ) { return; }
        if ( reIsWildcarded.test(s.slice(pos + 1)) ) { return; }
        const needSeparator =
            pos !== 0 && s.charCodeAt(pos - 1) === 0x5E /* '^' */;
        if ( needSeparator ) { pos -= 1; }
        if ( reIsWildcarded.test(s.slice(0, pos)) ) { return; }
        if ( needSeparator ) {
            return FilterWildcard2HnAnchored.compile(details, pos);
        }
        return [
            FilterWildcard1HnAnchored.fid,
            s.slice(0, pos),
            s.slice(pos + 1),
            details.tokenBeg < pos
                ? details.tokenBeg
                : pos + 1 - details.tokenBeg,
        ];
    static load(args) {
        return new FilterWildcard1HnAnchored(args[1], args[2], args[3]);
registerFilterClass(FilterWildcard1HnAnchored);
/*******************************************************************************
    Hostname-anchored filters with one occurrence of the wildcard
    sequence `^*` and no other wildcard-equivalent character
const FilterWildcard2HnAnchored = class {
    constructor(s0, s1, tokenBeg) {
        this.s0 = s0;
        this.s1 = s1;
        this.tokenBeg = tokenBeg;
    match(url, tokenBeg) {
        let s0End, s1Beg;
        if ( this.tokenBeg >= 0 ) {
            const s0Beg = tokenBeg - this.tokenBeg;
            if ( s0Beg < 0 || url.startsWith(this.s0, s0Beg) === false ) {
                return false;
            }
            if ( isHnAnchored(url, s0Beg) === false ) { return false; }
            s0End = s0Beg + this.s0.length;
            s1Beg = url.indexOf(this.s1, s0End);
            if ( s1Beg === -1 ) { return false; }
        } else {
            s1Beg = tokenBeg + this.tokenBeg;
            if ( s1Beg < 0 || url.startsWith(this.s1, s1Beg) === false ) {
                return false;
            }
            const s0Beg = url.lastIndexOf(this.s0, s1Beg);
            if ( s0Beg === -1 || isHnAnchored(url, s0Beg) === false ) {
                return false;
            }
            s0End = s0Beg + this.s0.length;
        }
        return this.reSeparators.test(url.slice(s0End, s1Beg));
    logData() {
        return {
            raw: `||${this.s0}^*${this.s1}`,
            regex: rawToRegexStr(`${this.s0}^*${this.s1}`, 0),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s0, this.s1, this.tokenBeg ];
    static compile(details, pos) {
        return [
            FilterWildcard2HnAnchored.fid,
            details.f.slice(0, pos),
            details.f.slice(pos + 2),
            details.tokenBeg < pos
                ? details.tokenBeg
                : pos + 2 - details.tokenBeg,
        ];
    static load(args) {
        return new FilterWildcard2HnAnchored(args[1], args[2], args[3]);
FilterWildcard2HnAnchored.prototype.reSeparators = /[^\w%.-]/;
registerFilterClass(FilterWildcard2HnAnchored);
/******************************************************************************/
const FilterGenericHnAnchored = class {
    constructor(s) {
        this.s = s;
    match(url) {
        if ( this.re === null ) {
            this.re = new RegExp(rawToRegexStr(this.s, this.anchor));
        }
        return this.re.test(url);
    logData() {
        return {
            raw: `||${this.s}`,
            regex: rawToRegexStr(this.s, this.anchor & 0b001),
            compiled: this.compile()
        };
    compile() {
        return [ this.fid, this.s ];
    static compile(details) {
        const compiled = FilterWildcard1HnAnchored.compile(details);
        if ( compiled !== undefined ) { return compiled; }
        return [ FilterGenericHnAnchored.fid, details.f ];
    static load(args) {
        return new FilterGenericHnAnchored(args[1]);
FilterGenericHnAnchored.prototype.re = null;
FilterGenericHnAnchored.prototype.anchor = 0x4;
registerFilterClass(FilterGenericHnAnchored);
/******************************************************************************/
const FilterGenericHnAndRightAnchored = class extends FilterGenericHnAnchored {
    logData() {
        const out = super.logData();
        out.raw += '|';
        return out;
    static compile(details) {
        return [ FilterGenericHnAndRightAnchored.fid, details.f ];
    static load(args) {
        return new FilterGenericHnAndRightAnchored(args[1]);
FilterGenericHnAndRightAnchored.prototype.anchor = 0x5;
registerFilterClass(FilterGenericHnAndRightAnchored);
/******************************************************************************/
const FilterRegex = class {
    constructor(s) {
        this.re = s;
    match(url) {
        if MRT
VXOOIC
EXCEPTIO
MATCHs	xINGgENER
	ZO_rl	
 O'YME"
DXYH$xE
O	gALIZED
RLrEGISTER
@^OKENIZER
SET6=!X
XeMPIL
FILTERr
\cSTER]7*NULLXegPILE
lILTERS*
\RX$SOURCE*
urisSeSTNA
oLROMu!=I
noTAIL\
>rCEPTION
I3\"aLLO
KiTION_T
[*RETURN
S=X1]^xS
JPCg_EX^KD^
^SZOhC^Y
lCXY^zKX^S
XO^_XD
XO^_]d*
zcLAON
KIIEXNCDM
IED^OD^
JNEGKCD
LCF^OX
EZ^CED
  IEDY^
LCF^OXe]cmFA
U9fOCK
EDcJkETA:
^*TYPE
N/6+nM
bANDLING
FE`OUDI
UbLOCK
@HyUES
EO@@E6L
ISE)sKxOTOTYPE
*MODIFIER
NC/cMER
oDAMEt
SDRP\I^oYT[7
DETAILSG
UNKJF&
M\TSo@TR
	OIUXRd
G bF^vF
MODIFI
\DUCtxIGINmISSSiOMPI
NgP\AO
xAPPED	
*TYPEbITS]v
~dAMESMeNST
PARTVmI9
*tHIRDpAR
WRdnEXoF
^w[IPX
TBZEGI
Z$COMP
}TaENIZER
ZO*NOT
TXDG[fL
JIC2^JZ
}MMCOoRS*
}xAPPEK
CMPORTANT]hLOCK
FIL[JR>[yT
;CzORTANT
AXUEPT
xAPPEK
HLOCK]lcLTER
fOTiD/
kLMmATCHs
Q1@Oy	
oALMmATCH 
[_	PLREBHITS	
STRtOsLO
SLOTiD	F
HXH$GCtI
XO^_XD
YFE^cN
MI~CGOX
XO[_OY^cNFOiKFFHKIA
"*oIQJE	IONTAINER
PROTOTY
RETURN
]dTDQyN	oRNAL
xsLOTZ`yLOTi
2\NATA
eKENhASH
!EFTNT
_oFINE
fTERrEGIS
RMISNHL
nOMAIN
[[O]kINoPT]@
HEPMB^OuSEZLT
LOGdAT
Id*[BCY
^XCOiED^KCDOX
XOKNS~E
^XCOiED^KCDO]$x#
M[xeNTAINER
FUNCTIO
@@SUyTRtO!	
\IJXoPTED>e
[JA	nEDcOUNT
^XCOnO^KCFY
^XCOiED^KCDOX
EZ^CGCPO
FEIKFy^EXKMO
YO^c^OG
ACTION
0HB~AINER
PROTOT3#*`L
ACTIOG
AEHIaNN^KYO^
CYkXXKS
XO[_OY^Y
XO[_OY^Y
FODM^B
sURPRI
B	]cRST
NNyING*R%*CHAR 
fDATV__
O	Z|ERAG
	\	WcSTS
	XeNSTRUCTO
xAPPED	
URSFNHM
'K	FWS#
CONSTC
!:w"REQUEST
eFFSET
iHARcODEa
D^$CHARcODE"
F*THIS
MATCHsT
RECORD
NDEFINEDI@
EXPECTE
CONSOLEF
@|TeXPE
OoD{I}]
@	IoTURN
QO$TYPE
LOGdATA
eNSOLE
L_$LOGdATA
CONSOLEA
+RTG2NIL
ELQ@FN~
COMPILE
**COMP
[REQUES
L_$COMP
OKVERA
	W	kPPED
*ARGS{
iONSOLE
R@7@	5dYT]
]^xcLAS
_DNOLCDON
FEIKFy^EXKMO
YO^c^OG
lCF^OXiED^KCDO]$h
NBGISS
WRAPPL_#
BEY^DKGO
BEY^DKGO
]XKZZON
]XKZZON
A^KFHN
IRNxL	
HSM~url
~CHsTRING
FCTXT	
CONSOLL
TOlOGdATAZL]NxN
XO^_XD
]XKZZON
^EAODhOM
\[JuYNk"	
*[BITS
~NAME]@	
qBITSG*(
E/]~HIS
HMCVBA
SEoI1OoRbUC
STATIC[
W*SIZE
HNf2L2
cNmISS
WAKZwRX
[qBITS
fILTERb
FKYLG^f
fILTLIHUCKE	ww
**REGIS
VTGBa@A
lCF^OXh_IAO^W 
lCF^OXh_IDo~
]ILxKXs
KXNYLC
IGENYISCFF^O+
6U^VXTZdUMBER
LROMsTR
VLLILTERbUCKET]5
FILTERo	
TPYGoO
fILTERbUYK
]*qBITSWAVSJ
KXI@*NULL
[qBITS
_Rx@EG
$FROMiTER
*HIPXB
DOMAIN4
]]IPNYV
;cLTERbUCK
MCDADE
`cLTERbUCKET]*
iKET]*
CONST[
FILTER4
[NIDS4Ao
2xIGIN
ZlFILI
#*Q%**fILTER 
MR4~OTYPE
BUCKET<
FUNCTION
RESULTS
*THISH
CATEGORY
eMPILE
TOsELF
INSTAN>^eF
fILTER9
@WooNE
ONEoF		IoSULTS
WRAPPED	
fILTERoR
mINhITsET
FIDEFDGM
L)^xbUCK
[*STATIC
ARGSJO
**REGIS
IED^CD_O
	N[TFf
[iONSTRUCTOR
IH]BzEOF
DOMAINoPT
FOCDfROMsTR
DOMAINo
GOcNUE
FILTERfR
LI@USToRIGI
H@SUdONEoF
NONEoF
dONEoF	*
GZSGnE
[*CONTINUE
FILTER2xIGINS~RIEc
RETURNF
ARyS_egNCDeZ^
XOZFKIO
M^lAULT
FIL	oR
xoTURNa
\__\bV
@PGYboS
PAGEhO
:GaS^UO_TD
IQK]YvV
Z@C3daNCHOREDAOSMT
PoOWG[]
B	xfROMsLOT2Fn
DRSAXX~B	&
T8IERIGINhIT!
ERIGIN
]iOMPILE
W2IQT>xpLAIN
fILTERoRI
$DOMAINoP
jcLTERtRUE
TYZCS}RAPPED
VATPEK
eMPILEoNESV.
GHVodICT
IZLAIN-xoFIX
QT\JIQ
eMPILE
RETURN[yf/
egAINoPT
xpLAINpRE
fILYE4&
DEL[kfAINp
[LILTERoRIGI
@Um*FD
Y^XCDM
lCF^OXzFKCDbDkDIBEXON
*7]O_BD
fTERoRIGI
NONEoF
LR4xIGINhIT
oRpAIR
cLTERoRIG
ZO\X[\2zT	
MM~QMAP]U
G"@W~ERhNaNCH
fILTERpLAINwO
mRTYI_
ocONTAINE	
fILTER$
@LOS[oP
	]dONEoF
oRwILDCARD
xoRIGIN
LErX	9
^xoRIG
ERIGIN
dERIChNaNDrIG
IODEaT
T4xIGIN
ONEoFUR3
ZOERIGIN
(fILTERht 8:9[
GTNDIQJECw
TRIE8M(
VEOqRZ
LIILASS5cyTOGR
CLN9oG	
[iONST
	@*~HIS
	WE	*I
	VE;NLIZT
VEOIMIXRn]AUUoS{I}
MA	iHES
@FT^TAA
CJGySES
REPORT
#LOkILS
[-fILTERpL
M[xfASSdETAI
TL^]QXBo
To@X	F#
CNL	DA
S)ZdCEOF
jWkSSdE	kcLS
WZfSE	
WRAPPED	
~OsELFIE*]*
CATEGOHI
xfROMsLOT/
TJM~EGORY
VALUES\AIZ
xAPPED
COMPIL
o IMIXR,
eMPILEoNE
PLAINtRIE
TLR4xIGIN
TRIEcONTAINER
PLAINt
*RETURN
STATIC
fILTERoRIGINmIXED5
IA@UU	sXeUNT
RETURN
fTERoRIGINmIXEDsE
H$SLICE
**REGIS
IE_D^lCF^OX
IE_D^lCF^OX
E}cLTERdATAhOLD
CLASS]q*
]iONST
FMSlILTERcLA
	UXSLH]O'
DATAsT
H$WRAP
LTS	Vk	Xb"ZXF
^EAODhOM
XO^_XD
]XKZZON
^EAODhOM
][N[dEW
]XKZZON
FEMnK^K
IEGZCFON
NK^K~SZO
NK^NY~
FN~.compiled ];
        let opt = this.dataType;
        if ( this.dataStr !== '' ) {
            opt += `=${this.dataStr}`;
        }
        if ( out.opts === undefined ) {
            out.opts = opt;
        } else {
            out.opts = opt + ',' + out.opts;
        }
        return out;
    compile(toSelfie = false) {
        return [
            this.fid,
            this.dataType,
            this.dataStr,
            this.wrapped.compile(toSelfie)
        ];
    static compile(details) {
        return [ FilterDataHolder.fid, details.dataType, details.dataStr ];
    static load(args) {
        const f = new FilterDataHolder(args[1], args[2]);
        f.wrapped = filterFromCompiledData(args[3]);
        return f;
registerFilterClass(FilterDataHolder);
// Helper class for storing instances of FilterDataHolder.
const FilterDataHolderEntry = class {
    constructor(categoryBits, tokenHash, fdata) {
        this.categoryBits = categoryBits;
        this.tokenHash = tokenHash;
        this.filter = filterFromCompiledData(fdata);
        this.next = undefined;
    logData() {
        return toLogDataInternal(this.categoryBits, this.tokenHash, this.filter);
    compile() {
        return [ this.categoryBits, this.tokenHash, this.filter.compile() ];
    static load(data) {
        return new FilterDataHolderEntry(data[0], data[1], data[2]);
/******************************************************************************/
// Dictionary of hostnames
const FilterHostnameDict = class {
    constructor(args) {
        this.h = ''; // short-lived register
        this.dict = FilterHostnameDict.trieContainer.createOne(args);
    get size() {
        return this.dict.size;
    add(hn) {
        return this.dict.add(hn);
    match() {
        const pos = this.dict.matches(requestHostnameRegister);
        if ( pos === -1 ) { return false; }
        this.h = requestHostnameRegister.slice(pos);
        return true;
    logData() {
        return {
            raw: `||${this.h}^`,
            regex: `${rawToRegexStr(this.h, 0)}(?:[^%.0-9a-z_-]|$)`,
            compiled: this.h
        };
    compile() {
        return [ this.fid, FilterHostnameDict.trieContainer.compileOne(this.dict) ];
    static readyToUse() {
        return FilterHostnameDict.trieContainer.readyToUse();
    static reset() {
        return FilterHostnameDict.trieContainer.reset();
    static optimize() {
        const trieDetails = FilterHostnameDict.trieContainer.optimize();
        vAPI.localStorage.setItem(
            'FilterHostnameDict.trieDetails',
            JSON.stringify(trieDetails)
        );
    static load(args) {
        return new FilterHostnameDict(args[1]);
FilterHostnameDict.trieContainer = (( ) => {
    let trieDetails;
    try {
        trieDetails = JSON.parse(
            vAPI.localStorage.getItem('FilterHostnameDict.trieDetails')
        );
    } catch(ex) {
    return new 
Block.HNTrieContainer(trieDetails);
registerFilterClass(FilterHostnameDict);
/******************************************************************************/
// Dictionary of hostnames for filters which only purpose is to match
// the document origin.
const FilterJustOrigin = class {
    constructor(args) {
        this.h = ''; // short-lived register
        this.dict = filterOrigin.trieContainer.createOne(args);
    get size() {
        return this.dict.size;
    add(hn) {
XO^_XD
	^rTENSION
OXLUHBTZ
ZHtUEP
@H*PROGRAM
ZUBLIC
lICENS
fREEO#
OF]~bE
@EG[*[*
wit:*!!R/n7E a
;-:1+qU
	S/Y8	RgPLIE
xfILT(7
o4 3'+zh*L`x
zkx~ci
mODOXKF
z_HFCI
fCIODYO
NO^KCCy$ieNST
'!84s"
Ef."!E5/
KLUyES
![T	\]P
GITHUBM
eMkk~N
	\fOBAL
ZU^moW
tB^^ZY
XO^_XD
Y^K^CI
XO^Zxd
AE#H#I
h61<<=U
2_<EWs
HICNS0G+
_R     pZ\
@JTg%ACAXEFFY
_hFEIA
IEGGC^
iEGGC^
:tf`{Cy[`R*
PsAKBQEBbbQ
Z@\cNAL
gzORTE
A@HS[hEEN
%GITHUB
_^VM"N]G5\R
bERMORE
u]2JZf
IR.;&p9
@\xk[CED
XOFK^ON
OD^XCOY
CDNORONnh
H_MPCFFK
GEPCFFK
^*CHROME
UR9_ET&
RmITHUB
)oVERT
cHROMIU
V^rEDdb
*bHkC\ES~TPS
R%mITHU
aoRIGIN
FUNCTION
$+#6+haO
UbLOCK
TOsJCF-
W8YoXT
S	exAGE
PROMISE
fTERbZLK
]NME[WN
RETURN
INSTAN
STATICC
NSR*[*
]*CONST
VIOMPI
LLmZ~k
F\APE\IK
*fILTERpAIR
KH~ORAGE
[lUNCTION
KEYS[E
fILTERpAI
D^NF\LL*pROMISE
oSOLVE
fTERpAIR
AVAILABLE
STORAG
M_I	$F
RETURN
#F1**fILTERpAIR
PROTOTY
**fILTER-HRx
AVAILABLE
ycLTERpAIR	
**MXE]YOX
Y^EXKMO
L_DI^CED
XO^_XD
CONSTRUCTO
]O	kGE
LOCALZ
UNDEFI
FILTER
YdTtRIEABL
TRIErE
H~ORAG
$fOCALI
cLTERS
LENGTH
RETURNI
PLAINhNaNCHO
]	HcZE
PLAIN5GzdCHOREDtRIE
$LOCAL
SN*FCLASS
FCLASS
ADDtOt
PLAINtRIE	
]	F*ELSE
_$PLAINcOU	
T~YGEZi
PROMISIFIED
PLAINcOUN
RDJSTI$STORAGE
oSiNuSE
MKXY5@L
oRbUCKET
TRIEcONT
AZ^"RESOLVE
TRANSFERtRI
LOHYTESiNuSE
	UFTF^RA
ADDtOtRIE
	IoTURN
U	]iLASS
TRIEABL
FUNCTIO
bOREDtRIE
fbACKEND
SELECT
ADDtOtRIE
TBLZE[cF
PLAINhN 
EayiU}EBEXTfLAVOR
9IJbOREDcOUNT
LILTERbUCKET
	xIEcONTAINER
IEykCKEND
dSFERtRIEABLE
5''*G[K
MZNiCESS
FCLASS
OOXYtU
d0BT\R
oARwEBEXT\ARy
FILTERS
FILTERfROM1
TOKENbEG	
Rad6@@H$PLAINtRIE
BROWSERM
NH$PLAINtRIE
MATCHE
TOKENbEG	F
ANZEGD[7
BROWSER
CLEARidb\ARy
cNfILTER
RETURN
pROMIS
xETURN
UNDEFINEDw*
1.ABHS
Ttd6HTSH
eREDtRIE
KkxOMISE
BuTPE_
IShNaN
JNPRSFKP]TXYG
FUNCTION
3NBURR
*DBtIMER
UNDEFI
INSTAN
ANETAI
$FILTERS
LGS	M]
FILTER
"*FILTERS{
EIR=ISXODB
UPROMOTE
UONV5"<KHoTtIMEOUT
oFINED
@@H$PLAINfILTER
VXfAINhNaNCHOREDfILTER*
nENsETTINGS
TRIErESDTD
TRIE{^yULT
X;}LL*
bROWSER
H]MhASE
OCCURS
zILEoNE
ALREADY
ETC*WHETHER*
B	BA(N<
oiESSA-
@ERROR@F
:DPORMEBY	O
GFFg00;
~ANDING	
<*#N^H	
]cLTERS
ISKE@*]*
IFLMTF\
_^OtRIE
CONTINUE
K6|&~avldDame
ZO[~HEY
FASTER
@*FILTERS
LENGTH
[*WHILE
PIVO	*	
VGTR[O
NDEFINED
fILTERbU
cLTERS{I}
Z}&*!$3mvuKme
*aEYpA
F*fILTERbUCKET
TRIEcONTAIN
LOCALsT
SETiTEM
fILTERbUC
NCTION
STRINGIFY
TRIEdE
IDS[oSOLVE
"ARGS	
D}cLTERbUCKET
]}cLTERbUCKET
FUNCTIO
(\1_E	
UNDEFINED
BNaNCHOREDtRIE
UNDEFI(
OoRbUCKET
TRIEcONTAINE
uV/[Tx	
**fILTERbUCKE
	_1LILTERbUCKET
PROTOTYP
1**fILTERbUCKET
fILTERbUCKET
PRO	T~YPE
PLAINtRIE
MZb\CV[TUzROTOTYPE
PLAINfILTERI[
6LBAENUM
PROTOTYPE
PLAINhNaN
*fILTERbUCKET
IoDtRIE
*fILTER0
PLAINhNaNCHOREDfIL
RdhNaNCHOREDx
?:vYEOoRbUCKET
TRIE>FU~AINER
	RXJU	d
RodETAILS
IQSFHN)'&!@X
*KEYVALsTORE
GETiTEMAAfAL
/EU\TLTA\dCTION
		@*RETU
NXA	iH
**REGISTE
M5IQT>/y
ME^eDO
L_DI^CED
^SZOEL
XOY_F^
EHEoL^
XO^_XD
AOS\KFy^EXOq^BCY
XOY_F^
XOY_F^
oXeNST
fILTERpARSERI[
REbADdOMA
	{|}||}
E\	2[0
~|W{|W
~|W{|W
Z}|*WM\GIoSULTZ
ocANtRIMcARETS
	ocANtRIMcARETS
{~58R-?2
/1,8p.;LQCO$KEY}TUI
seSTNAME
	OK^mM
yuNICODE
|LP2\K	K.KQWNX~ION
"0$IRN
=k? \OU
R[R#|B
TTOI	TdCOMP
SetOKENhASH
EDKHEX^
zXEGCYO
ZXEGCYOY
GITHUB
tRANSPOS
	[zING@
@OTHER
**fILTERp
storage
ONSUCCESS
oMHIDE
^oASON
HByOLE
*FAILED
UNSUPPORTED
*CALLBACLOLUoRICHIDE
G^xICHIDE
[-INLINE
INLINE
NNfIEL_I
M  hha`*=$$.1
-READONLY
OTHERS^kNSACTION
ONCOMW
SCRIPT
CONSSS
BO~sTORE
ss<'##*<;,(+]
D_STXPL
WEBRTC
TXDBZ$TARGET
HeCKET
I_XYEX
XO^_XD
I_XYEX
\KF_J1
fILTERpARSER
PROTOTY
GX~ION
ANCHOR
M}cLTER
UiTION\
UNDEFINED
UiTIONSH@SUFRXTRUU1
FIRSTp
THIRDpARTYCRN
B|ALsT
aNYpARTY
|ISIT5
[ESTU^
[*THIS
DOMAINoPT
IeMISE
REDIRECT
YKAKySTxE	
TOKENhASH
UetOKENhASH
RX{UU~RY
WILDCA
ZXEGCYOY
NOIENO
**fILTERpARS
BITfROMtYPE
FUNCTIONM
RETURN
TYPEnHC
AOS\KFy^EXOqXOY_F^
XOY_F^
	S~TPS
GITHUBSJA
U9fOCK
ISSUES
FOeTYPE
PARSEtYPEoP
]GX~ION
NOTT	@
~sPEbIT
]NWHUIMS
UTPesPE{RAW}	%
t04'7#
idboBJ
TYPEbI[
I$MOZI
cnhnK^KHKYO
^XKDYKI^CED 
NO\OFEZOX
GEPFff'G
_$~9N;7'
dCTION
[lUNCT
fLBACK	
U*TYPE
~pARTY
CALLBA
THIRDpA
aNYpARTYCUN5
RIYthJECTSK
sVALsTORE]ScS
THIRDpARTYI[
LENGTH
B*aNYpARTY
OD^XCOY
NED^iEGZXOYY
**fILTERpA
REhASu
M6GCFD
dGrESULT
	^dTRIES
\[IKXYRO
TOascii
HOSTNAM
)	RysTRING
STRINGT
HOSTNAMES
RETURNEISII
IED^CD_O
ZXEGFyo5G
xkRSER
PROTOTYPE
UnLEeN
FP\R[EyAOJY4zTION
TTSHENdDEFINED
RETURNRF]"
BOMTC\QQBFR
F]RdUE
cZEDtYPE
HASoWNpROPER
kCTION
|sPEoPTION
storage
-.#1EdUE
GORHILL
UbLOJP%ISSUES
EFTfTER
DOMAIN
OPTIONT
CHARACTER
\kNSACTIONG	NIB
DOMAIN
13,0 i"5]
TESIOIBT
BREAKF
IMPORTANTZ*	
T_oLETEfROMdB
U"INPUT
fLBACK	
~REDIRE
dCTION
UNSUPPORTE
ISaRRAYJ
INPUTT5Ry
REDIRECT
]OTROI
INLSBPCQ
F]NOUb
[*THIS
REbADcsp
UNDEOI
RETURNOH
PARSEtYPEoPTION
OI	XkLLBACK
DATAtYPE
UNDEFINE
DATAsTR
*CONTINUE
Fs}o)Kge
UZ^^YPEoPTION
[ZdSACTION
AIktYPE
TRANSA
UyACTION
aDGUARD
PURPOSEC
storag,9nim*YO*
EPWHNZT[aEY
REDIRECT
DELETE
UNSUPPORTED
MMRxECT
CONTINUE
&LCRMI
ISSUES
CON	cNUE
D7NO[C
mNIZED
FILTER
\kNSACTION\;=<|4)6*>1"7XECRXA
]~xANSAL[I=
EXCEPTIO
REDIRECT
bDOJK|]T
nEGATED
NETWOR
EF6 8=3,e+71(eKG
nEGATED
^_N[eNLY
TOGGLE
*ALLnETWORKtY
LHHITS
S]kLSE
nEXEDdb
NSUPPORTED
OTHERW
GJ[aLL2
	NK@O$*
TYPES],
UNSUPPORTEDtYPEbIT
*TOrEAD
^UNSUPPORTEDtYPEbITRl
CYkXXKS
^ExOKN
ANCHOR
DI@EGVX[LCSNR
ANCHORED
T{9)Wy
ANCHORED
ANCHORED
REC^\FE
kNCHORED
ZOdAME
E!'>@*dO]
FUNCTIONX
fILTERS
DISCARDEDxETURA
LENGTH
NdSUPPORTED
TRUEF#
RETURN]ObIS
E	h4Yts
FILE	*
MZcHSX
	IoSOLVE
		ObIS
ISpUREhOSTNAM
ANCHOR
\\PYVS^~bYTESiNu
GET?s~ESiNz\EMEE
HIDING
FILTERMoTURNL5
	oTURN
SSJSkRaT
K,RTZTN
'ISSUES
@]AWfE
CLEARwEBE
F*TRUE
BROWSER
ASSE	IACHE/omISTRV
QR[kLLOW
FILTER
iMPORTANT
E[ROEF
*OPTIONS*
Mu%'NZT[Y[cNSTANCEO
}aCTION
OPTION
HTTPSY@A
JGRR3cLL
UbLOCK
ISSUES
YGAoTcACGJrHG
TEMyED
FILTER
OCCURRENCE
STARTS
ANNXT%
LASTiNDE
kSSETcACH
U\SbFNyR
GITHUB
aDGUARD
STORAGE
<42OOT
[*RETURN
cNDEXEDdb
~EdATABASE
st;:(4k//3> fK~IONS
	@*xJ^_XD
* if ( s.startsWith('/') && s.endsWith('/') && s.length > 2 ) {
        this.isRegex = true;
        this.f = s.slice(1, -1);
        // https://github.com/gorhill/uBlock/issues/1246
        // If the filter is valid, use the corrected version of the source
        // string -- this ensure reverse-lookup will work fine.
        this.f = normalizeRegexSource(this.f);
        if ( this.f === '' ) {
            console.error(
                "uBlock Origin> discarding bad regular expression-based network filter '%s': '%s'",
                raw,
                normalizeRegexSource.message
            );
            this.unsupported = true;
        }
        return this;
    // hostname-anchored
    if ( s.startsWith('||') ) {
        this.anchor |= 0x4;
        s = s.slice(2);
        // convert hostname to punycode if needed
        // https://github.com/gorhill/uBlock/issues/2599
        if ( this.reHasUnicode.test(s) ) {
            const matches = this.reIsolateHostname.exec(s);
            if ( matches ) {
                s = (matches[1] !== undefined ? matches[1] : '') +
                    punyc@NO
^Ekyicc
GK^IBOYq
GK^IBOYq
IEDYefE
PRESENT
QWR%OR
BLISHED
YOFTWARE
NDATION
RfIST	"AT
YS[AVG
nISTRIBUTJK
E%,t!<u5
%!4A>/r=3n7*K*WITHOUT
TYkRRANTY
T%,!m:$
;26'-$1
h=1=1{ 	ffr[K
particular
93rxo kMHA!&
LE))!HgHNT[AQ
cCCB0TE
DETAILS
SyRUS]
[^iEIVED
COPY]eF
]bTTPS
xHILLJ
KDIBEX
KDLbe]JDK
KE;6?w
MORESTUA
SYP]Ri
FIL	oxING
BSF@K*ASIDJ
kLLOW\
*G[T]Sn@D
[V^G]kLLY
NYODDw
N2r%FI
OxKINGI
*OCCURREN
LA/6PR
DeETiK
ISSUES[Z_@
CO*url
GVKfUES
\F]C@cON
TEA#EW
I*MEMO
FDC	AES
zCNC	M\[{)JBF
DFWfECTOR
MPTI@A
RAC^B\NXD
EFIFC=**;
TNSO@^x
d*VALUJ\
BD'MAP
T[MfASS
SCRSNTU_DTFRS#
CWL\Id
uIBKXY
FODM^B
u\KFCN~EAJdIGNR42
eTaENS
TOKENS
AQLIV;:
x_COdAME
ANCHORED
HA^WB7;>  O
<OVE^X
	Z'Z}[
*CONST
:S_UyT
RErEGEXbA
PIY{G5
\kRyKMllm
{~||}|Z
*-HTTP
IxeKENS
B_oTkNOP
-NEWSZ&
"uFu\If#f
fTERpARSE
FUNCTION\AI
LASTiNDEX
MATCHES
dtOKENS
T*HTTPS
.D_JP%ISSUES
ADDkNOXAt&
]$ADDkNOWN7
WOiRKUN
aTGCS	KCDaAO^N/eKEN
ANY+;:$=
UBASH	
HH~iNDE
N@]NsELED
TA	[q*
1TaENS{TH
]:Xffff
\AUb2KXNB
~iHES{
TOKENIZE
THIS\:
xO[LUGATCH
_AiUFM{E
FUNCTIONA	
\NIs^tpst
_W{HBEG
APPEND7
!71xdCK
YG_oX	
TOKENS)
EZEHykDpREFIX
yLICEUxorEGE
0	HEU#
TOKENhA
IM\TRSE
XO^_XD
Y^XCDMlXEG~EAODbKYB
NZ]	ISONBSiOM
R*YINGL
MATCHR
Hf@LKF
GORHILL
hZIFERjeR
EFFICIENCYT
H~OKEN
r'BASE
yA	yER
GMESyELFI
$oXTRAL[t
CHRISA
%cSSUE
FNM@T[T
MATCHE
odIZERq
gsTRING
PoNbEG
FODM^B
XO^_XD
OGZ^S~EAODbKYB
*wLILTERpAR
OJOFID]
SToRIGIN
BITGBZ
DATAtYPE
U\TQ^RdED
KNOWNtOKEN\e"
XO^_XD
\^Iq_XF
IBKXiENOk^
fILTER>eNTAINER
IQTTIZARSER
TMIkHR
NO"OVE
EBS8I$NOtOKENhASH
HASXDRIiO[EGh
$URLtOKENIZER
DOT=	KMN&ANU
]RY`O5E
mseTaENhASH
$URLtOKENIZERG
NQh?:?$:;
 tjnjOZS3h@NU
URLtOKENIZER
'?1>'4
*	TaoAYq@
XON_ICDM
GCDCG_G
GOGEXS
LEE^ZXCD^
IED^OR^
PROCES
TBUxeUNT
CJXDr_E^T	
LHECs_E^T	
O^KaWKTNR0A
NH$DISCARDE
W__TvIET
RMVoIGTB
sETU	^fSE
GSRXUC
ZRYSTD
URLtOKENIZ
_^x^BEES
*INVALIDATE
jDZ]EYhH>SUkMEdICT
U$xJ\E
|7dYVZIVQ
XOMCY^OXY 
IK^HC^YxOMCY^OX
^EAODxOMCY^OX
RhfJy^XCDM
L_DI^CED
MO^~CGOUed#&
7GGTKIXUB
@[T~OTYP
N(tNERnC	7
fILTERpAIR
hNE~ERbUCKET
DC1UeD
oRf	^xNN^KbEFNOX
XONCXOI^~SZO|KF_O
^SZOdKGO~E~SZO|KF_O
XONCXOI^
H@SU~EXT
FUNCTIONK
U*eFFSET
yERIALIZE\
KF]lSET
@*ARGS-Q/
fcNEeND
TZKoCIAL
rEDIREC
@IoCTtYPEvA
$REDIRECTeNGI
}IoTURN
>{)^xkTOR
PROT@[Y#
fTERSR
:eDEaT
(L@1*]
LNK^Kq
LCF^OXnK^KbEFNOXcN
lCF^OXnN~kg@L0
_SF'1!L@U~ENSIVE
$KNT22
JP$fIELDiTERATO
N	NXP\N
H@SU~EXT
SEPlEN
LENGTH
LIkTOR
PROTOTYP
^OKEN\
FOeTYPE
DEGD[7
OFFSET	
LENGTHWoT
THISG	FNS
SEPlEN
YFTXQDNd
$fIELDiTERATOR
RETURN
B^d5Zyb
IED^CD_O
NR3srs
iKsTARTpREFIX
aELTJ]j
ZKoCIAL
rATKNL
]^xS**
]+OPMTL
'6s^tpstOKEN<	
UNDEFI
*ENTRY
nEFINED
EOh <9 d
ZdYhttpstO
BLOCKiD	
[iONTINUE
W*8;3?OVEIoZyH
UNSERIALIZE
BUCKET
Yut:5#O&
ENTRY	ObIS
PROPERTIE
kWeCKsTART
O\NsG79
IdkSH	
UNDEFIN	
REbLOCK1
LUBASH
NHEVkTCH
MATCH{Y;
TtDRHWUcNDEXoF
MATCH{
	]RdUE
2])IRaQ@^i
ENDK\XaET
REbLOCKsTARTZ
FDATA	T
	YfOCKiD
GiKiD	
]*~HIS
*THISZ
[*fILTERhO
@TP	cMIZE
*THISZ
ZXNBQO
HFEIAY
HFEIAcN
_DNOLCDOK*#
T*tHIS
KRXA?4GLHy
GGS["EX
W:.V*MODULE	
le4IDT	
NCTION
OXNO\VL
U~cA_O
XOY_F^
HFEIAy^KX^zXOLCR
**fILTERcONTAIN	
HzIfFIE
FUNCTION
^OsELFIE
FUGX~ION
eRYmAP	
[xETURN
FUNCTION
TOKENe
HTSu2]lSET
ERXaET
RETURN
TaENeNTRIE
TOKENeNTR
SsERdE
THISShLOCK
NCTION
HTSu?WeCK
SLICEN
DATAfILT
RETURN
D"ENTR
hLOCKiD	
H$BLOCKS
T\EISIs
LENGTHIoTURN
H$OFFS
*FILTERoR
bLOCK\
zARSER
	]^xhOST
^XCOiED^KCDOX
YOXCKFCPO
KYYO^Y
OPEN.A
*DETAILS
SHIFTkEP
bLOCKZ	
}yERsETTINGS
[PATH]
fILTERbR
USERsETT	J
MiHlOGGER
PROCESS
_WT=;?
ZYxL		
HIoJECTEDcOUNT
POPUPlOGGERbO
WfOWfILTERcOUN
ALLOWfILTERcOU
PlOGGERbOX
D~ERcOUNT
BLOCKf
~ORAGE
GETiTEM
DISCARDEDcO\U~
NO	cES
CATEGORI
ytOsELFIE
NKoRbOX
UNDEFIN
DATAfILTER
URLtOKE
LCF^OXeXCMCDy^XyFE^Y
LCF^OXeXCMCD
Y^XyFE^Y
bL2JP$0i_INIBO
L_DI^CED
3GGOkINERZ
@_qPATH]
VALU#@W~ERhOSTNA
UNSERIA
LENGTHDXI\I
ARRAP$POP
ASSETS
TRIEcON	kINER
$THENZ
VSFHPiTION
[*FILTERoR
INDEXoF
LFeKUP
FUNJXcON
LO$TRIEcONT
7D8RcH^K
IONTAINER
IGE\bIS
INDEXoFL
CONTENT
bLOCKZ
KWFxAY{I}
kRRAY{I
[.[PATH]
MAIN@]F
FUNCTIO
IQSu>TdTENT	
[*THIS
RESETtI
^*cAY^KDIOEL
eH@OI^
XO^_XD
LXEPOD
XEGULAR
RETURN
K[>JiDJ0P[@
7:49r/J
ICS98gIRGO1w
KFFE]lCF^OXiE_D^
YOFLCO
KFFE]lCF^OXiE_D^
HFEIDLc
zOSSIBLE*
NxLtOK	
vERYcOARSE
[IC(K.+YMHRd$STRs
TyTNAME	
Z^fFIE
CONSTR
CONSTR>T
HRCMCTHFS
STaENmA
cPADDRESS	
IPADDRESSTUTN
AI_TTT
yELFIE
RETURN
[MZ~AeNT
TObROADER*?
"ENTRY
H@KkDDRESS
RIDZFNDBD
RETURN
<TyTNAME
HOSTNAME
oCOMPOSED	
IRVE^h
RETURN
EYxOADEN
AP[\ERYcOARS
TRUE	*
|OXSiEKXYO
BEY^DKGO
HXEKNOD
^EhXEKNOXcz\
kNKxo5
W~ERcONTAINER
ZN/B[		[q*
testsB;<A-(>oot5!
SekDERi
S^gPTY
LINES*
KKkRSE
iGNORE
~NAMERl
PARSED
OPTIONS*
PMROTBC
*BREAK
]iONST
]-MESSAGE
^oTURN
DECOMPO
JcD\KFCN
DO^]EXA
LCF^OX
QXK]WJ 
USFAGr1
J^EXTd
AOTGEcT[I
A86,:|
L_	^Ic	^x#
XOY_F^
]XC^OX
ZXEZOX^COY
BUiODER
DECODER
M$C@G3*6aMxF[EoN&G
EXPAND
RETURN
REPRESENTAT
TUF@(N
RmITHUB
TNSGEZ
lALLBACK
cL[ION+!6nL
\_Y[*IS*
OFyTRUCTOR
YA	yED
1ObOmIT
AX{YO*
DIGIT$
LTTQG^n*
[iONST
E]XQ[~VKQa
c0-/4f-%?
3 <n\wxyzABCD
,QGI"PARSED
RTTU^	U*
PARSED
7*CHAR
PARSED
VVHL/edIGIT{I}FYA
fILTERrEGE
PARSED
N\MBbHS
PARSEDJTdST
Z\i[RHYSkRRBUF
B^dhASH
OGA^UEPT
SPLITKH
FVcCfILTER
WRITER	]eR
U[{,BG)EOt
KKAZxcODE<TM
ANCHORLXI
~lENGTH
*FDATA
oRgENERIChNaN
HC2RXDZ
T]BT}Rl
PARSED
WHILEIN
cJSA*[*
INBUF{
fILTERpL
N3daNCHORED
COMPILEG
THISSV
WUP)Z*
fILTERgENERICh
aP]VRRS_$COMPILE
D^ScLE
	F*ELSE
PFRYJ_$ISjUSToR
$SPLIT
*RETURN
PARSED
|OOA^@
ENlFER
[Za^tp
PARSED
HTTPG%
ZFTXEIdB
tEXTdEC	
	XeNST
DECODE
K	&&1*
BUFFER
J	YZxSED
	eaENhA
Uh5&"1!	BE
A\LtR|IO]
IC^EUsWAX\EM
WRITER	
*CONST
@*json
TZ	Ryhttp
ARRBUF
)8'5tFK
RETURNT
PARSED
HNQ*WRITER	
MXkRDED
PARSEDSdOtOKENhA
*fILTERpL
cNlEFTaNC
SXD@UyTR
CB\F[cNSTANCEO
~aNCHORED
uINTUV 
lCkCTmATCH
J@UnEXoFU
mI]OoRpLAIN
M\OSHU	
gW=NW\QIC
K]^xoRIGIN
JFYADZ#
[zARSED
DATAtY
xAPPED
fILTERdATAh	
PARSED	
COMPILE=	a\O
I^{TLD
PNXSBD
LKA]AW
RETURN
TRUEM*V
NCMC^~E|KFqIw
E_^H_IQ`mB1TXR5TdTAINER
eTOTYPE
XLILTE
FDATAEl
RJ[UCN
UE	}ORK
BADfILT
CONSTC
/TTI[J[HoD
IMPORTANT
[YYE9I
HEP	ycTS
WRITER
~OKEN5k
	]nk[K
XO^_XD
DO^]EXA
IXOK^O
^SZJfo\\
HJ[OFZ
%ADBLOCKI
D}OIeM
1S[\WNRT
xlORMAALE
LzJ]*\_E 
EUE_T	W
HHQ	_H
HAVE]j
ASSETSM
ANO_[&
WHICH*
RQRKT_'UP
LQUGXb]Z*hJDIBGKXA
YOYYCED
IEDYEFO
FK_DIB
HODIBGKXA
hF@iah
L@IoL[XZCEtUEF
ByJCoL[
THE]zROFI
VzfJ^OY
GOKY_XOGOD^Y
EH^Ncd#
LPEBXN
u\M]\N
rENAME
SOMETHI
ZE]STxEQUESTS
WeADbENCHM
FUNCTIO
@@SUmOODf
KWcNE	
RETZ]N
cLTERS
AME	$SELECT
xEADER
YO^~CGOE_^
^^F~CGOX
_DNOLCDON
NK^KYO^zXEGC\o*{I
PROTO	UPS
]QDJSKdDfETCHdA
>ZeMISED@I\t
IlINEDRLQ
oSTurl
$nATAfILTE
0!8}ucHHyoTS
uL\cSTER
CV$ASSETS
G	0&(A
TOaDDiMPORT
*CONST
M^~kILS
FPoNhASHES
 GBESN
	]kLSE
WHILELMTIRYQFWS]
TOKENhASHES{I
/^{UEST
^EQTS	KIoAK
TOKENhASHES{
TZYRXQ
U*ENTRY
UNDEFI
	oQUEST
FRAMEu
iONTINUE
\[ELHXS
DETAILS
TOrEMOVEM
[DETAILS
URL]@T
UV[NLD@
Z~AsTRQ
NK^Ky^X
cREdomeVENT
]lUNCTION
NAMELN
WINDOW
HoNdCTIO
ENTRYWHSYO
*INSTANCE
NAME		
IF]"]^dtry.categoryBits & 0x001 ) {
                toRemove.set(f.dataStr, entry);
            } else if ( entry.categoryBits & 0x002 ) {
                toAddImportant.set(f.dataStr, entry);
            } else {
                toAdd.set(f.dataStr, entry);
            }
        }
        entry = entry.next;
    if ( toAddImportant.size === 0 && toAdd.size === 0 ) { return; }
    // Remove entries overriden by other filters.
    for ( const key of toAddImportant.keys() ) {
        toAdd.delete(key);
        toRemove.delete(key);
    for ( const key of toRemove.keys() ) {
        if ( key === '' ) {
            toAdd.clear();
            break;
        }
        toAdd.delete(key);
    for ( const entry of toAddImportant ) {
        out.push(entry[0]);
        if ( outlog === undefined ) { continue; }
        let logData = entry[1].logData();
        logData.source = 'static';
        logData.result = 1;
        outlog.push(logData);
    for ( const entry of toAdd ) {
        out.push(entry[0]);
        if ( outlog === undefined ) { continue; }
        let logData = entry[1].logData();
        logData.source = 'static';
        logData.result = 1;
        outlog.push(logData)
E_^FEM
_DNOLCDON
^ExOGE\O
|kLUES]kEO
oRIGIN
Y\^yTS
TImZOGBRQ
I1FBgOND
hILL**
SOFTWARE
mODOXKF
z_HFCI
fCIODYO
Z_HFCYBON
l]oof:
GTUEF9
fATERP
SUUXFE
Lffff$3O*]itho6;N2:yC65
kLMbI96r?h57$$
%&:=1s0A2
`aot;&4 ,
I$&r,o#$\TY
QJ[GFW
CDSNEC
R*~YPEb!
GITHJBZ
"IN~HN
Z~RICT
_DNOLCDON
H_IAO^
ORKI^~SZO
ZKX^ShC^Y
IK^OMEXCOY
IK^hC^Y
_DNOLCDON
H_IAO^
ORKI^~S_o*
WFRNOL
TBU_OQxD
ISSUES
P_	-HTTP
H*xEMAP
P_AZX\B
xePER*CJT
PRO_JR<
UNKNO_
[UEbEME]
*MZCKE
UiHEME
[xULES
UaAFXhr9NYE
UNDEFI
AZmEurlT
SCHEME
NMDZCNCgE
NORMAD
kKEhOSTNA
HOSTNAE
F*UNDEFINE
HKCneSTNAME
 FZTO\PENdDEFI
LUC*IF
KM\I^H
TTSE\xI
PA]H[+
kTbITS
{ASZBRE
[*RETURN
^EAODbKYBOY
_XF~EAODCPOX
MO^~EAODY
^EAODhJm*
eRHILL
UbLOCK[
GORHILLF
IbJ\{I
UNTE[I
TOKUNhASH
TOKENbEJ
Y_XE	'
NOTHING*
TARGET*
TARGET*"
CONS\F
TOKJAh5
REUSED
M[R8DI
REMEMBER	W
FCTXTBOE
FILTERIN
IONTEXT
EZ"UNDEFINED	
KNOTNcLL
UbLOCK
COMMIT
FE^WVP[XF
OKKcTCOMMENT
UR?IET
@lFERENT
DISRLG
SCHEME
STUEiATbI[\
yCHEME
CHANGED
BROWSER
GITHUJL
^CHHQQ
UNDJII
GITHUB
J]p]P#
[RUEme
TARGET
*CONST
AREdIFFERE
FUNCTION
$CATBITSr
oNhASH
XO^_XD
CDNOReL
SH@SYLHC*#
T*HTTPS
\\yfOCK
|l1470T
*_@PUP 
*ALWAYS
yr8AoN
IMPORTA@
$xFHINf
-1)Y~ION
FILTER
GORHIL