kornerr
/
mahjong


			
				
					
						
						
							
							
<!DOCTYPE html>
<html>
    <meta charset="utf-8">
	<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
    <body>
        <script>
var муром = {};
var murom = муром;

муром.темы = [

];

Object.defineProperty(murom, "themes", {
    get: function()
    {
        return муром.темы;
    },
    set: function(значения)
    {
        муром.темы = значения;
    }
});

муром.модули = [

[
"муром.загрузка_1.0.1",
"/*
 * NOTE Only ASCII is allowed in this loading module
 * NOTE because it's deciphered with btoa() call,
 * NOTE which can't handle Unicode.
 * NOTE However, murom.atob/btoa functions (defined here)
 * NOTE work fine with Unicode, so you are free
 * NOTE to use Unicode in other modules
 */

murom.installLocalForage = function()
{
/*
    localForage -- Offline Storage, Improved
    Version 1.7.3
    https://localforage.github.io/localForage
    (c) 2013-2017 Mozilla, Apache License 2.0
*/
!function(a){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=a();else if("function"==typeof define&&define.amd)define([],a);else{var b;b="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,b.localforage=a()}}(function(){return function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);var j=new Error("Cannot find module '"+g+"'");throw j.code="MODULE_NOT_FOUND",j}var k=c[g]={exports:{}};b[g][0].call(k.exports,function(a){var c=b[g][1][a];return e(c||a)},k,k.exports,a,b,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;g<d.length;g++)e(d[g]);return e}({1:[function(a,b,c){(function(a){"use strict";function c(){k=!0;for(var a,b,c=l.length;c;){for(b=l,l=[],a=-1;++a<c;)b[a]();c=l.length}k=!1}function d(a){1!==l.push(a)||k||e()}var e,f=a.MutationObserver||a.WebKitMutationObserver;if(f){var g=0,h=new f(c),i=a.document.createTextNode("");h.observe(i,{characterData:!0}),e=function(){i.data=g=++g%2}}else if(a.setImmediate||void 0===a.MessageChannel)e="document"in a&&"onreadystatechange"in a.document.createElement("script")?function(){var b=a.document.createElement("script");b.onreadystatechange=function(){c(),b.onreadystatechange=null,b.parentNode.removeChild(b),b=null},a.document.documentElement.appendChild(b)}:function(){setTimeout(c,0)};else{var j=new a.MessageChannel;j.port1.onmessage=c,e=function(){j.port2.postMessage(0)}}var k,l=[];b.exports=d}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],2:[function(a,b,c){"use strict";function d(){}function e(a){if("function"!=typeof a)throw new TypeError("resolver must be a function");this.state=s,this.queue=[],this.outcome=void 0,a!==d&&i(this,a)}function f(a,b,c){this.promise=a,"function"==typeof b&&(this.onFulfilled=b,this.callFulfilled=this.otherCallFulfilled),"function"==typeof c&&(this.onRejected=c,this.callRejected=this.otherCallRejected)}function g(a,b,c){o(function(){var d;try{d=b(c)}catch(b){return p.reject(a,b)}d===a?p.reject(a,new TypeError("Cannot resolve promise with itself")):p.resolve(a,d)})}function h(a){var b=a&&a.then;if(a&&("object"==typeof a||"function"==typeof a)&&"function"==typeof b)return function(){b.apply(a,arguments)}}function i(a,b){function c(b){f||(f=!0,p.reject(a,b))}function d(b){f||(f=!0,p.resolve(a,b))}function e(){b(d,c)}var f=!1,g=j(e);"error"===g.status&&c(g.value)}function j(a,b){var c={};try{c.value=a(b),c.status="success"}catch(a){c.status="error",c.value=a}return c}function k(a){return a instanceof this?a:p.resolve(new this(d),a)}function l(a){var b=new this(d);return p.reject(b,a)}function m(a){function b(a,b){function d(a){g[b]=a,++h!==e||f||(f=!0,p.resolve(j,g))}c.resolve(a).then(d,function(a){f||(f=!0,p.reject(j,a))})}var c=this;if("[object Array]"!==Object.prototype.toString.call(a))return this.reject(new TypeError("must be an array"));var e=a.length,f=!1;if(!e)return this.resolve([]);for(var g=new Array(e),h=0,i=-1,j=new this(d);++i<e;)b(a[i],i);return j}function n(a){function b(a){c.resolve(a).then(function(a){f||(f=!0,p.resolve(h,a))},function(a){f||(f=!0,p.reject(h,a))})}var c=this;if("[object Array]"!==Object.prototype.toString.call(a))return this.reject(new TypeError("must be an array"));var e=a.length,f=!1;if(!e)return this.resolve([]);for(var g=-1,h=new this(d);++g<e;)b(a[g]);return h}var o=a(1),p={},q=["REJECTED"],r=["FULFILLED"],s=["PENDING"];b.exports=e,e.prototype.catch=function(a){return this.then(null,a)},e.prototype.then=function(a,b){if("function"!=typeof a&&this.state===r||"function"!=typeof b&&this.state===q)return this;var c=new this.constructor(d);if(this.state!==s){g(c,this.state===r?a:b,this.outcome)}else this.queue.push(new f(c,a,b));return c},f.prototype.callFulfilled=function(a){p.resolve(this.promise,a)},f.prototype.otherCallFulfilled=function(a){g(this.promise,this.onFulfilled,a)},f.prototype.callRejected=function(a){p.reject(this.promise,a)},f.prototype.otherCallRejected=function(a){g(this.promise,this.onRejected,a)},p.resolve=function(a,b){var c=j(h,b);if("error"===c.status)return p.reject(a,c.value);var d=c.value;if(d)i(a,d);else{a.state=r,a.outcome=b;for(var e=-1,f=a.queue.length;++e<f;)a.queue[e].callFulfilled(b)}return a},p.reject=function(a,b){a.state=q,a.outcome=b;for(var c=-1,d=a.queue.length;++c<d;)a.queue[c].callRejected(b);return a},e.resolve=k,e.reject=l,e.all=m,e.race=n},{1:1}],3:[function(a,b,c){(function(b){"use strict";"function"!=typeof b.Promise&&(b.Promise=a(2))}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{2:2}],4:[function(a,b,c){"use strict";function d(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function e(){try{if("undefined"!=typeof indexedDB)return indexedDB;if("undefined"!=typeof webkitIndexedDB)return webkitIndexedDB;if("undefined"!=typeof mozIndexedDB)return mozIndexedDB;if("undefined"!=typeof OIndexedDB)return OIndexedDB;if("undefined"!=typeof msIndexedDB)return msIndexedDB}catch(a){return}}function f(){try{if(!ua)return!1;var a="undefined"!=typeof openDatabase&&/(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent)&&!/Chrome/.test(navigator.userAgent)&&!/BlackBerry/.test(navigator.platform),b="function"==typeof fetch&&-1!==fetch.toString().indexOf("[native code");return(!a||b)&&"undefined"!=typeof indexedDB&&"undefined"!=typeof IDBKeyRange}catch(a){return!1}}function g(a,b){a=a||[],b=b||{};try{return new Blob(a,b)}catch(f){if("TypeError"!==f.name)throw f;for(var c="undefined"!=typeof BlobBuilder?BlobBuilder:"undefined"!=typeof MSBlobBuilder?MSBlobBuilder:"undefined"!=typeof MozBlobBuilder?MozBlobBuilder:WebKitBlobBuilder,d=new c,e=0;e<a.length;e+=1)d.append(a[e]);return d.getBlob(b.type)}}function h(a,b){b&&a.then(function(a){b(null,a)},function(a){b(a)})}function i(a,b,c){"function"==typeof b&&a.then(b),"function"==typeof c&&a.catch(c)}function j(a){return"string"!=typeof a&&(console.warn(a+" used as a key, but it is not a string."),a=String(a)),a}function k(){if(arguments.length&&"function"==typeof arguments[arguments.length-1])return arguments[arguments.length-1]}function l(a){for(var b=a.length,c=new ArrayBuffer(b),d=new Uint8Array(c),e=0;e<b;e++)d[e]=a.charCodeAt(e);return c}function m(a){return new va(function(b){var c=a.transaction(wa,Ba),d=g([""]);c.objectStore(wa).put(d,"key"),c.onabort=function(a){a.preventDefault(),a.stopPropagation(),b(!1)},c.oncomplete=function(){var a=navigator.userAgent.match(/Chrome\/(\d+)/),c=navigator.userAgent.match(/Edge\//);b(c||!a||parseInt(a[1],10)>=43)}}).catch(function(){return!1})}function n(a){return"boolean"==typeof xa?va.resolve(xa):m(a).then(function(a){return xa=a})}function o(a){var b=ya[a.name],c={};c.promise=new va(function(a,b){c.resolve=a,c.reject=b}),b.deferredOperations.push(c),b.dbReady?b.dbReady=b.dbReady.then(function(){return c.promise}):b.dbReady=c.promise}function p(a){var b=ya[a.name],c=b.deferredOperations.pop();if(c)return c.resolve(),c.promise}function q(a,b){var c=ya[a.name],d=c.deferredOperations.pop();if(d)return d.reject(b),d.promise}function r(a,b){return new va(function(c,d){if(ya[a.name]=ya[a.name]||B(),a.db){if(!b)return c(a.db);o(a),a.db.close()}var e=[a.name];b&&e.push(a.version);var f=ua.open.apply(ua,e);b&&(f.onupgradeneeded=function(b){var c=f.result;try{c.createObjectStore(a.storeName),b.oldVersion<=1&&c.createObjectStore(wa)}catch(c){if("ConstraintError"!==c.name)throw c;console.warn('The database "'+a.name+'" has been upgraded from version '+b.oldVersion+" to version "+b.newVersion+', but the storage "'+a.storeName+'" already exists.')}}),f.onerror=function(a){a.preventDefault(),d(f.error)},f.onsuccess=function(){c(f.result),p(a)}})}function s(a){return r(a,!1)}function t(a){return r(a,!0)}function u(a,b){if(!a.db)return!0;var c=!a.db.objectStoreNames.contains(a.storeName),d=a.version<a.db.version,e=a.version>a.db.version;if(d&&(a.version!==b&&console.warn('The database "'+a.name+"\" can't be downgraded from version "+a.db.version+" to version "+a.version+"."),a.version=a.db.version),e||c){if(c){var f=a.db.version+1;f>a.version&&(a.version=f)}return!0}return!1}function v(a){return new va(function(b,c){var d=new FileReader;d.onerror=c,d.onloadend=function(c){var d=btoa(c.target.result||"");b({__local_forage_encoded_blob:!0,data:d,type:a.type})},d.readAsBinaryString(a)})}function w(a){return g([l(atob(a.data))],{type:a.type})}function x(a){return a&&a.__local_forage_encoded_blob}function y(a){var b=this,c=b._initReady().then(function(){var a=ya[b._dbInfo.name];if(a&&a.dbReady)return a.dbReady});return i(c,a,a),c}function z(a){o(a);for(var b=ya[a.name],c=b.forages,d=0;d<c.length;d++){var e=c[d];e._dbInfo.db&&(e._dbInfo.db.close(),e._dbInfo.db=null)}return a.db=null,s(a).then(function(b){return a.db=b,u(a)?t(a):b}).then(function(d){a.db=b.db=d;for(var e=0;e<c.length;e++)c[e]._dbInfo.db=d}).catch(function(b){throw q(a,b),b})}function A(a,b,c,d){void 0===d&&(d=1);try{var e=a.db.transaction(a.storeName,b);c(null,e)}catch(e){if(d>0&&(!a.db||"InvalidStateError"===e.name||"NotFoundError"===e.name))return va.resolve().then(function(){if(!a.db||"NotFoundError"===e.name&&!a.db.objectStoreNames.contains(a.storeName)&&a.version<=a.db.version)return a.db&&(a.version=a.db.version+1),t(a)}).then(function(){return z(a).then(function(){A(a,b,c,d-1)})}).catch(c);c(e)}}function B(){return{forages:[],db:null,dbReady:null,deferredOperations:[]}}function C(a){function b(){return va.resolve()}var c=this,d={db:null};if(a)for(var e in a)d[e]=a[e];var f=ya[d.name];f||(f=B(),ya[d.name]=f),f.forages.push(c),c._initReady||(c._initReady=c.ready,c.ready=y);for(var g=[],h=0;h<f.forages.length;h++){var i=f.forages[h];i!==c&&g.push(i._initReady().catch(b))}var j=f.forages.slice(0);return va.all(g).then(function(){return d.db=f.db,s(d)}).then(function(a){return d.db=a,u(d,c._defaultConfig.version)?t(d):a}).then(function(a){d.db=f.db=a,c._dbInfo=d;for(var b=0;b<j.length;b++){var e=j[b];e!==c&&(e._dbInfo.db=d.db,e._dbInfo.version=d.version)}})}function D(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.get(a);h.onsuccess=function(){var a=h.result;void 0===a&&(a=null),x(a)&&(a=w(a)),b(a)},h.onerror=function(){d(h.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function E(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.openCursor(),i=1;h.onsuccess=function(){var c=h.result;if(c){var d=c.value;x(d)&&(d=w(d));var e=a(d,c.key,i++);void 0!==e?b(e):c.continue()}else b()},h.onerror=function(){d(h.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function F(a,b,c){var d=this;a=j(a);var e=new va(function(c,e){var f;d.ready().then(function(){return f=d._dbInfo,"[object Blob]"===za.call(b)?n(f.db).then(function(a){return a?b:v(b)}):b}).then(function(b){A(d._dbInfo,Ba,function(f,g){if(f)return e(f);try{var h=g.objectStore(d._dbInfo.storeName);null===b&&(b=void 0);var i=h.put(b,a);g.oncomplete=function(){void 0===b&&(b=null),c(b)},g.onabort=g.onerror=function(){var a=i.error?i.error:i.transaction.error;e(a)}}catch(a){e(a)}})}).catch(e)});return h(e,c),e}function G(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Ba,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.delete(a);f.oncomplete=function(){b()},f.onerror=function(){d(h.error)},f.onabort=function(){var a=h.error?h.error:h.transaction.error;d(a)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function H(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Ba,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.clear();e.oncomplete=function(){a()},e.onabort=e.onerror=function(){var a=g.error?g.error:g.transaction.error;c(a)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function I(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Aa,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.count();g.onsuccess=function(){a(g.result)},g.onerror=function(){c(g.error)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function J(a,b){var c=this,d=new va(function(b,d){if(a<0)return void b(null);c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=!1,i=g.openCursor();i.onsuccess=function(){var c=i.result;if(!c)return void b(null);0===a?b(c.key):h?b(c.key):(h=!0,c.advance(a))},i.onerror=function(){d(i.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function K(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Aa,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.openCursor(),h=[];g.onsuccess=function(){var b=g.result;if(!b)return void a(h);h.push(b.key),b.continue()},g.onerror=function(){c(g.error)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function L(a,b){b=k.apply(this,arguments);var c=this.config();a="function"!=typeof a&&a||{},a.name||(a.name=a.name||c.name,a.storeName=a.storeName||c.storeName);var d,e=this;if(a.name){var f=a.name===c.name&&e._dbInfo.db,g=f?va.resolve(e._dbInfo.db):s(a).then(function(b){var c=ya[a.name],d=c.forages;c.db=b;for(var e=0;e<d.length;e++)d[e]._dbInfo.db=b;return b});d=a.storeName?g.then(function(b){if(b.objectStoreNames.contains(a.storeName)){var c=b.version+1;o(a);var d=ya[a.name],e=d.forages;b.close();for(var f=0;f<e.length;f++){var g=e[f];g._dbInfo.db=null,g._dbInfo.version=c}return new va(function(b,d){var e=ua.open(a.name,c);e.onerror=function(a){e.result.close(),d(a)},e.onupgradeneeded=function(){e.result.deleteObjectStore(a.storeName)},e.onsuccess=function(){var a=e.result;a.close(),b(a)}}).then(function(a){d.db=a;for(var b=0;b<e.length;b++){var c=e[b];c._dbInfo.db=a,p(c._dbInfo)}}).catch(function(b){throw(q(a,b)||va.resolve()).catch(function(){}),b})}}):g.then(function(b){o(a);var c=ya[a.name],d=c.forages;b.close();for(var e=0;e<d.length;e++){d[e]._dbInfo.db=null}return new va(function(b,c){var d=ua.deleteDatabase(a.name);d.onerror=d.onblocked=function(a){var b=d.result;b&&b.close(),c(a)},d.onsuccess=function(){var a=d.result;a&&a.close(),b(a)}}).then(function(a){c.db=a;for(var b=0;b<d.length;b++)p(d[b]._dbInfo)}).catch(function(b){throw(q(a,b)||va.resolve()).catch(function(){}),b})})}else d=va.reject("Invalid arguments");return h(d,b),d}function M(){return"function"==typeof openDatabase}function N(a){var b,c,d,e,f,g=.75*a.length,h=a.length,i=0;"="===a[a.length-1]&&(g--,"="===a[a.length-2]&&g--);var j=new ArrayBuffer(g),k=new Uint8Array(j);for(b=0;b<h;b+=4)c=Da.indexOf(a[b]),d=Da.indexOf(a[b+1]),e=Da.indexOf(a[b+2]),f=Da.indexOf(a[b+3]),k[i++]=c<<2|d>>4,k[i++]=(15&d)<<4|e>>2,k[i++]=(3&e)<<6|63&f;return j}function O(a){var b,c=new Uint8Array(a),d="";for(b=0;b<c.length;b+=3)d+=Da[c[b]>>2],d+=Da[(3&c[b])<<4|c[b+1]>>4],d+=Da[(15&c[b+1])<<2|c[b+2]>>6],d+=Da[63&c[b+2]];return c.length%3==2?d=d.substring(0,d.length-1)+"=":c.length%3==1&&(d=d.substring(0,d.length-2)+"=="),d}function P(a,b){var c="";if(a&&(c=Ua.call(a)),a&&("[object ArrayBuffer]"===c||a.buffer&&"[object ArrayBuffer]"===Ua.call(a.buffer))){var d,e=Ga;a instanceof ArrayBuffer?(d=a,e+=Ia):(d=a.buffer,"[object Int8Array]"===c?e+=Ka:"[object Uint8Array]"===c?e+=La:"[object Uint8ClampedArray]"===c?e+=Ma:"[object Int16Array]"===c?e+=Na:"[object Uint16Array]"===c?e+=Pa:"[object Int32Array]"===c?e+=Oa:"[object Uint32Array]"===c?e+=Qa:"[object Float32Array]"===c?e+=Ra:"[object Float64Array]"===c?e+=Sa:b(new Error("Failed to get type for BinaryArray"))),b(e+O(d))}else if("[object Blob]"===c){var f=new FileReader;f.onload=function(){var c=Ea+a.type+"~"+O(this.result);b(Ga+Ja+c)},f.readAsArrayBuffer(a)}else try{b(JSON.stringify(a))}catch(c){console.error("Couldn't convert value into a JSON string: ",a),b(null,c)}}function Q(a){if(a.substring(0,Ha)!==Ga)return JSON.parse(a);var b,c=a.substring(Ta),d=a.substring(Ha,Ta);if(d===Ja&&Fa.test(c)){var e=c.match(Fa);b=e[1],c=c.substring(e[0].length)}var f=N(c);switch(d){case Ia:return f;case Ja:return g([f],{type:b});case Ka:return new Int8Array(f);case La:return new Uint8Array(f);case Ma:return new Uint8ClampedArray(f);case Na:return new Int16Array(f);case Pa:return new Uint16Array(f);case Oa:return new Int32Array(f);case Qa:return new Uint32Array(f);case Ra:return new Float32Array(f);case Sa:return new Float64Array(f);default:throw new Error("Unkown type: "+d)}}function R(a,b,c,d){a.executeSql("CREATE TABLE IF NOT EXISTS "+b.storeName+" (id INTEGER PRIMARY KEY, key unique, value)",[],c,d)}function S(a){var b=this,c={db:null};if(a)for(var d in a)c[d]="string"!=typeof a[d]?a[d].toString():a[d];var e=new va(function(a,d){try{c.db=openDatabase(c.name,String(c.version),c.description,c.size)}catch(a){return d(a)}c.db.transaction(function(e){R(e,c,function(){b._dbInfo=c,a()},function(a,b){d(b)})},d)});return c.serializer=Va,e}function T(a,b,c,d,e,f){a.executeSql(c,d,e,function(a,g){g.code===g.SYNTAX_ERR?a.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name = ?",[b.storeName],function(a,h){h.rows.length?f(a,g):R(a,b,function(){a.executeSql(c,d,e,f)},f)},f):f(a,g)},f)}function U(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,"SELECT * FROM "+e.storeName+" WHERE key = ? LIMIT 1",[a],function(a,c){var d=c.rows.length?c.rows.item(0).value:null;d&&(d=e.serializer.deserialize(d)),b(d)},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function V(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,"SELECT * FROM "+e.storeName,[],function(c,d){for(var f=d.rows,g=f.length,h=0;h<g;h++){var i=f.item(h),j=i.value;if(j&&(j=e.serializer.deserialize(j)),void 0!==(j=a(j,i.key,h+1)))return void b(j)}b()},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function W(a,b,c,d){var e=this;a=j(a);var f=new va(function(f,g){e.ready().then(function(){void 0===b&&(b=null);var h=b,i=e._dbInfo;i.serializer.serialize(b,function(b,j){j?g(j):i.db.transaction(function(c){T(c,i,"INSERT OR REPLACE INTO "+i.storeName+" (key, value) VALUES (?, ?)",[a,b],function(){f(h)},function(a,b){g(b)})},function(b){if(b.code===b.QUOTA_ERR){if(d>0)return void f(W.apply(e,[a,h,c,d-1]));g(b)}})})}).catch(g)});return h(f,c),f}function X(a,b,c){return W.apply(this,[a,b,c,1])}function Y(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,"DELETE FROM "+e.storeName+" WHERE key = ?",[a],function(){b()},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function Z(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,"DELETE FROM "+d.storeName,[],function(){a()},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function $(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,"SELECT COUNT(key) as c FROM "+d.storeName,[],function(b,c){var d=c.rows.item(0).c;a(d)},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function _(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,"SELECT key FROM "+e.storeName+" WHERE id = ? LIMIT 1",[a+1],function(a,c){var d=c.rows.length?c.rows.item(0).key:null;b(d)},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function aa(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,"SELECT key FROM "+d.storeName,[],function(b,c){for(var d=[],e=0;e<c.rows.length;e++)d.push(c.rows.item(e).key);a(d)},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function ba(a){return new va(function(b,c){a.transaction(function(d){d.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'",[],function(c,d){for(var e=[],f=0;f<d.rows.length;f++)e.push(d.rows.item(f).name);b({db:a,storeNames:e})},function(a,b){c(b)})},function(a){c(a)})})}function ca(a,b){b=k.apply(this,arguments);var c=this.config();a="function"!=typeof a&&a||{},a.name||(a.name=a.name||c.name,a.storeName=a.storeName||c.storeName);var d,e=this;return d=a.name?new va(function(b){var d;d=a.name===c.name?e._dbInfo.db:openDatabase(a.name,"","",0),b(a.storeName?{db:d,storeNames:[a.storeName]}:ba(d))}).then(function(a){return new va(function(b,c){a.db.transaction(function(d){function e(a){return new va(function(b,c){d.executeSql("DROP TABLE IF EXISTS "+a,[],function(){b()},function(a,b){c(b)})})}for(var f=[],g=0,h=a.storeNames.length;g<h;g++)f.push(e(a.storeNames[g]));va.all(f).then(function(){b()}).catch(function(a){c(a)})},function(a){c(a)})})}):va.reject("Invalid arguments"),h(d,b),d}function da(){try{return"undefined"!=typeof localStorage&&"setItem"in localStorage&&!!localStorage.setItem}catch(a){return!1}}function ea(a,b){var c=a.name+"/";return a.storeName!==b.storeName&&(c+=a.storeName+"/"),c}function fa(){var a="_localforage_support_test";try{return localStorage.setItem(a,!0),localStorage.removeItem(a),!1}catch(a){return!0}}function ga(){return!fa()||localStorage.length>0}function ha(a){var b=this,c={};if(a)for(var d in a)c[d]=a[d];return c.keyPrefix=ea(a,b._defaultConfig),ga()?(b._dbInfo=c,c.serializer=Va,va.resolve()):va.reject()}function ia(a){var b=this,c=b.ready().then(function(){for(var a=b._dbInfo.keyPrefix,c=localStorage.length-1;c>=0;c--){var d=localStorage.key(c);0===d.indexOf(a)&&localStorage.removeItem(d)}});return h(c,a),c}function ja(a,b){var c=this;a=j(a);var d=c.ready().then(function(){var b=c._dbInfo,d=localStorage.getItem(b.keyPrefix+a);return d&&(d=b.serializer.deserialize(d)),d});return h(d,b),d}function ka(a,b){var c=this,d=c.ready().then(function(){for(var b=c._dbInfo,d=b.keyPrefix,e=d.length,f=localStorage.length,g=1,h=0;h<f;h++){var i=localStorage.key(h);if(0===i.indexOf(d)){var j=localStorage.getItem(i);if(j&&(j=b.serializer.deserialize(j)),void 0!==(j=a(j,i.substring(e),g++)))return j}}});return h(d,b),d}function la(a,b){var c=this,d=c.ready().then(function(){var b,d=c._dbInfo;try{b=localStorage.key(a)}catch(a){b=null}return b&&(b=b.substring(d.keyPrefix.length)),b});return h(d,b),d}function ma(a){var b=this,c=b.ready().then(function(){for(var a=b._dbInfo,c=localStorage.length,d=[],e=0;e<c;e++){var f=localStorage.key(e);0===f.indexOf(a.keyPrefix)&&d.push(f.substring(a.keyPrefix.length))}return d});return h(c,a),c}function na(a){var b=this,c=b.keys().then(function(a){return a.length});return h(c,a),c}function oa(a,b){var c=this;a=j(a);var d=c.ready().then(function(){var b=c._dbInfo;localStorage.removeItem(b.keyPrefix+a)});return h(d,b),d}function pa(a,b,c){var d=this;a=j(a);var e=d.ready().then(function(){void 0===b&&(b=null);var c=b;return new va(function(e,f){var g=d._dbInfo;g.serializer.serialize(b,function(b,d){if(d)f(d);else try{localStorage.setItem(g.keyPrefix+a,b),e(c)}catch(a){"QuotaExceededError"!==a.name&&"NS_ERROR_DOM_QUOTA_REACHED"!==a.name||f(a),f(a)}})})});return h(e,c),e}function qa(a,b){if(b=k.apply(this,arguments),a="function"!=typeof a&&a||{},!a.name){var c=this.config();a.name=a.name||c.name,a.storeName=a.storeName||c.storeName}var d,e=this;return d=a.name?new va(function(b){b(a.storeName?ea(a,e._defaultConfig):a.name+"/")}).then(function(a){for(var b=localStorage.length-1;b>=0;b--){var c=localStorage.key(b);0===c.indexOf(a)&&localStorage.removeItem(c)}}):va.reject("Invalid arguments"),h(d,b),d}function ra(a,b){a[b]=function(){var c=arguments;return a.ready().then(function(){return a[b].apply(a,c)})}}function sa(){for(var a=1;a<arguments.length;a++){var b=arguments[a];if(b)for(var c in b)b.hasOwnProperty(c)&&($a(b[c])?arguments[0][c]=b[c].slice():arguments[0][c]=b[c])}return arguments[0]}var ta="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},ua=e();"undefined"==typeof Promise&&a(3);var va=Promise,wa="local-forage-detect-blob-support",xa=void 0,ya={},za=Object.prototype.toString,Aa="readonly",Ba="readwrite",Ca={_driver:"asyncStorage",_initStorage:C,_support:f(),iterate:E,getItem:D,setItem:F,removeItem:G,clear:H,length:I,key:J,keys:K,dropInstance:L},Da="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",Ea="~~local_forage_type~",Fa=/^~~local_forage_type~([^~]+)~/,Ga="__lfsc__:",Ha=Ga.length,Ia="arbf",Ja="blob",Ka="si08",La="ui08",Ma="uic8",Na="si16",Oa="si32",Pa="ur16",Qa="ui32",Ra="fl32",Sa="fl64",Ta=Ha+Ia.length,Ua=Object.prototype.toString,Va={serialize:P,deserialize:Q,stringToBuffer:N,bufferToString:O},Wa={_driver:"webSQLStorage",_initStorage:S,_support:M(),iterate:V,getItem:U,setItem:X,removeItem:Y,clear:Z,length:$,key:_,keys:aa,dropInstance:ca},Xa={_driver:"localStorageWrapper",_initStorage:ha,_support:da(),iterate:ka,getItem:ja,setItem:pa,removeItem:oa,clear:ia,length:na,key:la,keys:ma,dropInstance:qa},Ya=function(a,b){return a===b||"number"==typeof a&&"number"==typeof b&&isNaN(a)&&isNaN(b)},Za=function(a,b){for(var c=a.length,d=0;d<c;){if(Ya(a[d],b))return!0;d++}return!1},$a=Array.isArray||function(a){return"[object Array]"===Object.prototype.toString.call(a)},_a={},ab={},bb={INDEXEDDB:Ca,WEBSQL:Wa,LOCALSTORAGE:Xa},cb=[bb.INDEXEDDB._driver,bb.WEBSQL._driver,bb.LOCALSTORAGE._driver],db=["dropInstance"],eb=["clear","getItem","iterate","key","keys","length","removeItem","setItem"].concat(db),fb={description:"",driver:cb.slice(),name:"localforage",size:4980736,storeName:"keyvaluepairs",version:1},gb=function(){function a(b){d(this,a);for(var c in bb)if(bb.hasOwnProperty(c)){var e=bb[c],f=e._driver;this[c]=f,_a[f]||this.defineDriver(e)}this._defaultConfig=sa({},fb),this._config=sa({},this._defaultConfig,b),this._driverSet=null,this._initDriver=null,this._ready=!1,this._dbInfo=null,this._wrapLibraryMethodsWithReady(),this.setDriver(this._config.driver).catch(function(){})}return a.prototype.config=function(a){if("object"===(void 0===a?"undefined":ta(a))){if(this._ready)return new Error("Can't call config() after localforage has been used.");for(var b in a){if("storeName"===b&&(a[b]=a[b].replace(/\W/g,"_")),"version"===b&&"number"!=typeof a[b])return new Error("Database version must be a number.");this._config[b]=a[b]}return!("driver"in a&&a.driver)||this.setDriver(this._config.driver)}return"string"==typeof a?this._config[a]:this._config},a.prototype.defineDriver=function(a,b,c){var d=new va(function(b,c){try{var d=a._driver,e=new Error("Custom driver not compliant; see https://mozilla.github.io/localForage/#definedriver");if(!a._driver)return void c(e);for(var f=eb.concat("_initStorage"),g=0,i=f.length;g<i;g++){var j=f[g];if((!Za(db,j)||a[j])&&"function"!=typeof a[j])return void c(e)}(function(){for(var b=function(a){return function(){var b=new Error("Method "+a+" is not implemented by the current driver"),c=va.reject(b);return h(c,arguments[arguments.length-1]),c}},c=0,d=db.length;c<d;c++){var e=db[c];a[e]||(a[e]=b(e))}})();var k=function(c){_a[d]&&console.info("Redefining LocalForage driver: "+d),_a[d]=a,ab[d]=c,b()};"_support"in a?a._support&&"function"==typeof a._support?a._support().then(k,c):k(!!a._support):k(!0)}catch(a){c(a)}});return i(d,b,c),d},a.prototype.driver=function(){return this._driver||null},a.prototype.getDriver=function(a,b,c){var d=_a[a]?va.resolve(_a[a]):va.reject(new Error("Driver not found."));return i(d,b,c),d},a.prototype.getSerializer=function(a){var b=va.resolve(Va);return i(b,a),b},a.prototype.ready=function(a){var b=this,c=b._driverSet.then(function(){return null===b._ready&&(b._ready=b._initDriver()),b._ready});return i(c,a,a),c},a.prototype.setDriver=function(a,b,c){function d(){g._config.driver=g.driver()}function e(a){return g._extend(a),d(),g._ready=g._initStorage(g._config),g._ready}function f(a){return function(){function b(){for(;c<a.length;){var f=a[c];return c++,g._dbInfo=null,g._ready=null,g.getDriver(f).then(e).catch(b)}d();var h=new Error("No available storage method found.");return g._driverSet=va.reject(h),g._driverSet}var c=0;return b()}}var g=this;$a(a)||(a=[a]);var h=this._getSupportedDrivers(a),j=null!==this._driverSet?this._driverSet.catch(function(){return va.resolve()}):va.resolve();return this._driverSet=j.then(function(){var a=h[0];return g._dbInfo=null,g._ready=null,g.getDriver(a).then(function(a){g._driver=a._driver,d(),g._wrapLibraryMethodsWithReady(),g._initDriver=f(h)})}).catch(function(){d();var a=new Error("No available storage method found.");return g._driverSet=va.reject(a),g._driverSet}),i(this._driverSet,b,c),this._driverSet},a.prototype.supports=function(a){return!!ab[a]},a.prototype._extend=function(a){sa(this,a)},a.prototype._getSupportedDrivers=function(a){for(var b=[],c=0,d=a.length;c<d;c++){var e=a[c];this.supports(e)&&b.push(e)}return b},a.prototype._wrapLibraryMethodsWithReady=function(){for(var a=0,b=eb.length;a<b;a++)ra(this,eb[a])},a.prototype.createInstance=function(b){return new a(b)},a}(),hb=new gb;b.exports=hb},{3:3}]},{},[4])(4)});
};

murom.installUnicodeBase64 = function()
{
/*
	https://github.com/solderjs/TextEncoderLite
	Apache 2.0
*/
function TextEncoderLite(){}function TextDecoderLite(){}(function(){"use strict";function utf8ToBytes(string,units){units=units||Infinity;var codePoint;var length=string.length;var leadSurrogate=null;var bytes=[];var i=0;for(;i<length;i++){codePoint=string.charCodeAt(i);if(codePoint>55295&&codePoint<57344){if(leadSurrogate){if(codePoint<56320){if((units-=3)>-1)bytes.push(239,191,189);leadSurrogate=codePoint;continue}else{codePoint=leadSurrogate-55296<<10|codePoint-56320|65536;leadSurrogate=null}}else{if(codePoint>56319){if((units-=3)>-1)bytes.push(239,191,189);continue}else if(i+1===length){if((units-=3)>-1)bytes.push(239,191,189);continue}else{leadSurrogate=codePoint;continue}}}else if(leadSurrogate){if((units-=3)>-1)bytes.push(239,191,189);leadSurrogate=null}if(codePoint<128){if((units-=1)<0)break;bytes.push(codePoint)}else if(codePoint<2048){if((units-=2)<0)break;bytes.push(codePoint>>6|192,codePoint&63|128)}else if(codePoint<65536){if((units-=3)<0)break;bytes.push(codePoint>>12|224,codePoint>>6&63|128,codePoint&63|128)}else if(codePoint<2097152){if((units-=4)<0)break;bytes.push(codePoint>>18|240,codePoint>>12&63|128,codePoint>>6&63|128,codePoint&63|128)}else{throw new Error("Invalid code point")}}return bytes}function utf8Slice(buf,start,end){var res="";var tmp="";end=Math.min(buf.length,end||Infinity);start=start||0;for(var i=start;i<end;i++){if(buf[i]<=127){res+=decodeUtf8Char(tmp)+String.fromCharCode(buf[i]);tmp=""}else{tmp+="%"+buf[i].toString(16)}}return res+decodeUtf8Char(tmp)}function decodeUtf8Char(str){try{return decodeURIComponent(str)}catch(err){return String.fromCharCode(65533)}}TextEncoderLite.prototype.encode=function(str){var result;if("undefined"===typeof Uint8Array){result=utf8ToBytes(str)}else{result=new Uint8Array(utf8ToBytes(str))}return result};TextDecoderLite.prototype.decode=function(bytes){return utf8Slice(bytes,0,bytes.length)}})();if(typeof module==="object"&&module){module.exports.TextDecoderLite=TextDecoderLite;module.exports.TextEncoderLite=TextEncoderLite}
/*
	https://github.com/beatgammit/base64-js
 	MIT
*/
(function(r){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=r()}else if(typeof define==="function"&&define.amd){define([],r)}else{var e;if(typeof window!=="undefined"){e=window}else if(typeof global!=="undefined"){e=global}else if(typeof self!=="undefined"){e=self}else{e=this}e.base64js=r()}})(function(){var r,e,n;return function(){function r(e,n,t){function o(f,i){if(!n[f]){if(!e[f]){var u="function"==typeof require&&require;if(!i&&u)return u(f,!0);if(a)return a(f,!0);var v=new Error("Cannot find module '"+f+"'");throw v.code="MODULE_NOT_FOUND",v}var d=n[f]={exports:{}};e[f][0].call(d.exports,function(r){var n=e[f][1][r];return o(n||r)},d,d.exports,r,e,n,t)}return n[f].exports}for(var a="function"==typeof require&&require,f=0;f<t.length;f++)o(t[f]);return o}return r}()({"/":[function(r,e,n){"use strict";n.byteLength=d;n.toByteArray=h;n.fromByteArray=p;var t=[];var o=[];var a=typeof Uint8Array!=="undefined"?Uint8Array:Array;var f="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";for(var i=0,u=f.length;i<u;++i){t[i]=f[i];o[f.charCodeAt(i)]=i}o["-".charCodeAt(0)]=62;o["_".charCodeAt(0)]=63;function v(r){var e=r.length;if(e%4>0){throw new Error("Invalid string. Length must be a multiple of 4")}var n=r.indexOf("=");if(n===-1)n=e;var t=n===e?0:4-n%4;return[n,t]}function d(r){var e=v(r);var n=e[0];var t=e[1];return(n+t)*3/4-t}function c(r,e,n){return(e+n)*3/4-n}function h(r){var e;var n=v(r);var t=n[0];var f=n[1];var i=new a(c(r,t,f));var u=0;var d=f>0?t-4:t;for(var h=0;h<d;h+=4){e=o[r.charCodeAt(h)]<<18|o[r.charCodeAt(h+1)]<<12|o[r.charCodeAt(h+2)]<<6|o[r.charCodeAt(h+3)];i[u++]=e>>16&255;i[u++]=e>>8&255;i[u++]=e&255}if(f===2){e=o[r.charCodeAt(h)]<<2|o[r.charCodeAt(h+1)]>>4;i[u++]=e&255}if(f===1){e=o[r.charCodeAt(h)]<<10|o[r.charCodeAt(h+1)]<<4|o[r.charCodeAt(h+2)]>>2;i[u++]=e>>8&255;i[u++]=e&255}return i}function s(r){return t[r>>18&63]+t[r>>12&63]+t[r>>6&63]+t[r&63]}function l(r,e,n){var t;var o=[];for(var a=e;a<n;a+=3){t=(r[a]<<16&16711680)+(r[a+1]<<8&65280)+(r[a+2]&255);o.push(s(t))}return o.join("")}function p(r){var e;var n=r.length;var o=n%3;var a=[];var f=16383;for(var i=0,u=n-o;i<u;i+=f){a.push(l(r,i,i+f>u?u:i+f))}if(o===1){e=r[n-1];a.push(t[e>>2]+t[e<<4&63]+"==")}else if(o===2){e=(r[n-2]<<8)+r[n-1];a.push(t[e>>10]+t[e>>4&63]+t[e<<2&63]+"=")}return a.join("")}},{}]},{},[])("/")});
/*
    https://developer.mozilla.org/ru/docs/Web/API/WindowBase64/Base64_encoding_and_decoding
*/
    murom.btoa = function(str)
    {
        var bytes = new (typeof TextEncoder === "undefined" ? TextEncoderLite : TextEncoder)("utf-8").encode(str);
        return base64js.fromByteArray(bytes);
    };
    murom.atob = function(str)
    {
        var bytes = base64js.toByteArray(str);
        return new (typeof TextDecoder === "undefined" ? TextDecoderLite : TextDecoder)("utf-8").decode(bytes);
    };
};

murom.moduleProperties = function(id)
{
    var m = murom.modules[id];
    return (typeof m[2] != "undefined") ? m[2] : {};
};

murom.moduleStatus = function(id)
{
    var prop = murom.moduleProperties(id);
    if ("status" in prop)
    {
        return prop["status"];
    }
    // Status == true if explicit record is absent.
    return true;
};

murom.start = function()
{
    console.debug("Override murom.start() function to be notified when all modules were loaded");
}

murom.loadModules = function()
{
    // Skip `0` module because it's us.
    for (var i = 1; i < murom.modules.length; ++i)
    {
        var module = murom.modules[i];
        var name = module[0];
        var code = murom.atob(module[1]);
        if (murom.moduleStatus(i) == false)
        {
            //console.warn("Skip loading '" + name + "' module because it's turned off");
        }
        else
        {
            // NOTE Do not catch error to see error line numbers in debugger console.
            eval(code);
            /*
            try
            {
                eval(code);
            }
            catch (e)
            {
                console.error("Could not load '" + name + "' module: '" + e + "'");
            }
            */
        }
    }
    
    murom.start();
};

murom.loadIndexedDBModules = function(completionHandler)
{
    // See if IndexedDB has modules.
    // IndexedDB modules override those coming from HTML.
    localforage.config({ name: "murom" });
    localforage.getItem("modules", function(error, modules) {
        if (modules)
        {
            murom.modules = modules;
            console.debug("Modules have been loaded from IndexedDB");
        }
        if (error)
        {
            console.error("Could not get modules from IndexedDB: '" + error + "'");
        }
        // Continue.
        completionHandler();
    });
};

murom.installLocalForage();
murom.installUnicodeBase64();
// IndexedDB modules override HTML ones.
murom.loadIndexedDBModules(murom.loadModules);
",
{"status":true}
],

[
"муром.файл_1.2.0",
"0LzRg9GA0L7QvC7RhNCw0LnQuyA9IHt9OwoKLyoKICoKICog0JfQsNCz0L7Qu9C+0LLQvtC6INC4INC+0LrQvtC90YfQsNC90LjQtQogKiBIZWFkZXIgYW5kIGZvb3RlcgogKgogKi8KCtC80YPRgNC+0Lwu0YTQsNC50Lsu0L3QsNGH0LDQu9C+ID0gYAo8IURPQ1RZUEUgaHRtbD4KPGh0bWw+CiAgICA8bWV0YSBjaGFyc2V0PSJ1dGYtOCI+Cgk8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ZGV2aWNlLXdpZHRoLCB1c2VyLXNjYWxhYmxlPW5vLCBtaW5pbXVtLXNjYWxlPTEuMCwgbWF4aW11bS1zY2FsZT0xLjAiPgogICAgPGJvZHk+CiAgICAgICAgPHNjcmlwdD4KdmFyINC80YPRgNC+0LwgPSB7fTsKdmFyIG11cm9tID0g0LzRg9GA0L7QvDsKYDsKCtC80YPRgNC+0Lwu0YTQsNC50Lsu0LrQvtC90LXRhiA9IGAKICAgICAgICA8L3NjcmlwdD4KICAgIDwvYm9keT4KPC9odG1sPgpgOwoKLyoKICoKICog0JzQvtC00YPQu9C4CiAqIE1vZHVsZXMKICoKICovCgrQvNGD0YDQvtC8LtGE0LDQudC7LtC80L7QtNGD0LvQuNCd0LDRh9Cw0LvQviA9IGAK0LzRg9GA0L7QvC7QvNC+0LTRg9C70LggPSBbCmA7CgrQvNGD0YDQvtC8LtGE0LDQudC7LtC80L7QtNGD0LvQuNCa0L7QvdC10YYgPSBgCl07CgpPYmplY3QuZGVmaW5lUHJvcGVydHkobXVyb20sICJtb2R1bGVzIiwgewogICAgZ2V0OiBmdW5jdGlvbigpCiAgICB7CiAgICAgICAgcmV0dXJuINC80YPRgNC+0Lwu0LzQvtC00YPQu9C4OwogICAgfSwKICAgIHNldDogZnVuY3Rpb24o0LfQvdCw0YfQtdC90LjRjykKICAgIHsKICAgICAgICDQvNGD0YDQvtC8LtC80L7QtNGD0LvQuCA9INC30L3QsNGH0LXQvdC40Y87CiAgICB9Cn0pOwoKdmFyINC30LDQs9GA0YPQt9C+0YfQvdGL0LnQnNC+0LTRg9C70YwgPSDQvNGD0YDQvtC8LtC80L7QtNGD0LvQuFswXTsKdmFyINC60L7QtCA9IGF0b2Io0LfQsNCz0YDRg9C30L7Rh9C90YvQudCc0L7QtNGD0LvRjFsxXSk7CmV2YWwo0LrQvtC0KTsKYDsKCi8qCiAqCiAqINCi0LXQvNGLCiAqIFRoZW1lcwogKgogKi8KCtC80YPRgNC+0Lwu0YTQsNC50Lsu0YLQtdC80YvQndCw0YfQsNC70L4gPSBgCtC80YPRgNC+0Lwu0YLQtdC80YsgPSBbCmA7CgrQvNGD0YDQvtC8LtGE0LDQudC7LtGC0LXQvNGL0JrQvtC90LXRhiA9IGAKXTsKCk9iamVjdC5kZWZpbmVQcm9wZXJ0eShtdXJvbSwgInRoZW1lcyIsIHsKICAgIGdldDogZnVuY3Rpb24oKQogICAgewogICAgICAgIHJldHVybiDQvNGD0YDQvtC8LtGC0LXQvNGLOwogICAgfSwKICAgIHNldDogZnVuY3Rpb24o0LfQvdCw0YfQtdC90LjRjykKICAgIHsKICAgICAgICDQvNGD0YDQvtC8LtGC0LXQvNGLID0g0LfQvdCw0YfQtdC90LjRjzsKICAgIH0KfSk7CmA7",
{"status":true}
],

[
"муром.классы_1.0.0",
"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",
{"status":true}
],

[
"муром.функции_1.4.0",
"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",
{"status":true}
],

[
"MOD_1.2.0",
"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",
{"status":true}
],

[
"TEM_1.0.0",
"Ly8g0JDQn9CYINC00LvRjyDRg9C/0YDQsNCy0LvQtdC90LjRjyDRgtC10LzQsNC80LgKLy8gQVBJIHRvIG1hbmFnZSB0aGVtZXMKCmZ1bmN0aW9uIFRoZW1lcyhpdGVtcykKewogICAgdGhpcy5pdGVtcyA9IFtdOwogICAgT2JqZWN0LmRlZmluZVByb3BlcnR5KHRoaXMsICLRgtC10LzRiyIsIHsKICAgICAgICBnZXQ6IGZ1bmN0aW9uKCkKICAgICAgICB7CiAgICAgICAgICAgIHJldHVybiB0aGlzLml0ZW1zOwogICAgICAgIH0KICAgIH0pOwogICAgdGhpcy5wYXJzZVNlcmlhbGl6ZWRUaGVtZXMoaXRlbXMpOwp9CgovKgogKgogKiDQoNCw0LfQvtCx0YDQsNGC0Ywg0YLQtdC80Ysg0LjQtyDRgdC10YDQuNCw0LvQuNC30L7QstCw0L3QvdC+0LPQviDRhNC+0YDQvNCw0YLQsAogKiBQYXJzZSB0aGVtZXMgb2Ygc2VyaWFsaXplZCBmb3JtYXQKICoKICovClRoZW1lcy5wcm90b3R5cGUucGFyc2VTZXJpYWxpemVkVGhlbWVzID0gZnVuY3Rpb24oaXRlbXMpCnsKICAgIGZvciAodmFyIGkgaW4gaXRlbXMpCiAgICB7CiAgICAgICAgdmFyIGl0ZW0gPSBpdGVtc1tpXTsKICAgICAgICB2YXIgbmFtZSA9IGl0ZW1bMF07CiAgICAgICAgdmFyIGZ1bmMgPSBpdGVtWzFdOwogICAgICAgIHZhciB0aGVtZSA9IHsKICAgICAgICAgICAgIm5hbWUiOiBuYW1lLAogICAgICAgICAgICAiY29udGVudHMiOiBmdW5jKCksCiAgICAgICAgfTsKICAgICAgICB0aGlzLml0ZW1zLnB1c2godGhlbWUpOwogICAgfQp9OwoKLyoKICoKICog0J3QsNC50YLQuCDRgtC10LzRgyDQv9C+INC40LzQtdC90LgKICogRmluZCB0aGVtZSBieSBuYW1lCiAqCiAqLwpUaGVtZXMucHJvdG90eXBlLnRoZW1lID0gZnVuY3Rpb24obmFtZSkKewogICAgZm9yICh2YXIgaSBpbiB0aGlzLml0ZW1zKQogICAgewogICAgICAgIHZhciBpdGVtID0gdGhpcy5pdGVtc1tpXTsKICAgICAgICBpZiAoaXRlbS5uYW1lID09IG5hbWUpCiAgICAgICAgewogICAgICAgICAgICByZXR1cm4gaXRlbTsKICAgICAgICB9CiAgICB9CiAgICAKICAgIHJldHVybiBudWxsOwp9OwpUaGVtZXMucHJvdG90eXBlLtGC0LXQvNCwID0gZnVuY3Rpb24o0LjQvNGPKQp7CiAgICByZXR1cm4gdGhpcy50aGVtZSjQuNC80Y8pOwp9Ow==",
{"status":true}
],

[
"jquery.min.js_3.4.1",
"/*! jQuery v3.4.1 | (c) JS Foundation and other contributors | jquery.org/license */
!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],E=C.document,r=Object.getPrototypeOf,s=t.slice,g=t.concat,u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.4.1",k=function(e,t){return new k.fn.init(e,t)},p=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;function d(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}k.fn=k.prototype={jquery:f,constructor:k,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=k.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return k.each(this,e)},map:function(n){return this.pushStack(k.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},k.extend=k.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(k.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||k.isPlainObject(n)?n:{},i=!1,a[t]=k.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},k.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t){b(e,{nonce:t&&t.nonce})},each:function(e,t){var n,r=0;if(d(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},trim:function(e){return null==e?"":(e+"").replace(p,"")},makeArray:function(e,t){var n=t||[];return null!=e&&(d(Object(e))?k.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(d(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g.apply([],a)},guid:1,support:y}),"function"==typeof Symbol&&(k.fn[Symbol.iterator]=t[Symbol.iterator]),k.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var h=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,k="sizzle"+1*new Date,m=n.document,S=0,r=0,p=ue(),x=ue(),N=ue(),A=ue(),D=function(e,t){return e===t&&(l=!0),0},j={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",$=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",F=new RegExp(M+"+","g"),B=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp($),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+$),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\([\\da-f]{1,6}"+M+"?|("+M+")|.)","ig"),ne=function(e,t,n){var r="0x"+t-65536;return r!=r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(m.childNodes),m.childNodes),t[m.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&((e?e.ownerDocument||e:m)!==C&&T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!A[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&U.test(t)){(s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=k),o=(l=h(t)).length;while(o--)l[o]="#"+s+" "+xe(l[o]);c=l.join(","),f=ee.test(t)&&ye(e.parentNode)||e}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){A(t,!0)}finally{s===k&&e.removeAttribute("id")}}}return g(t.replace(B,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[k]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:m;return r!==C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),m!==C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=k,!C.getElementsByName||!C.getElementsByName(k).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){a.appendChild(e).innerHTML="<a id='"+k+"'></a><select id='"+k+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+k+"-]").length||v.push("~="),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+k+"+*").length||v.push(".#.+[+~]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",$)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e===C||e.ownerDocument===m&&y(m,e)?-1:t===C||t.ownerDocument===m&&y(m,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e===C?-1:t===C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]===m?-1:s[r]===m?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if((e.ownerDocument||e)!==C&&T(e),d.matchesSelector&&E&&!A[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){A(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!==C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!==C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&j.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(D),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=p[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&p(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(F," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===S&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[S,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===S&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[S,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[k]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace(B,"$1"));return s[k]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[S,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[k]||(e[k]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===S&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[k]&&(v=Ce(v)),y&&!y[k]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[k]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace(B,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace(B," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=N[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[k]?i.push(a):o.push(a);(a=N(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=S+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t===C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument===C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(S=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(S=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=k.split("").sort(D).join("")===k,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);k.find=h,k.expr=h.selectors,k.expr[":"]=k.expr.pseudos,k.uniqueSort=k.unique=h.uniqueSort,k.text=h.getText,k.isXMLDoc=h.isXML,k.contains=h.contains,k.escapeSelector=h.escape;var T=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&k(e).is(n))break;r.push(e)}return r},S=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},N=k.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var D=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?k.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?k.grep(e,function(e){return e===n!==r}):"string"!=typeof n?k.grep(e,function(e){return-1<i.call(n,e)!==r}):k.filter(n,e,r)}k.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?k.find.matchesSelector(r,e)?[r]:[]:k.find.matches(e,k.grep(t,function(e){return 1===e.nodeType}))},k.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(k(e).filter(function(){for(t=0;t<r;t++)if(k.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)k.find(e,i[t],n);return 1<r?k.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&N.test(e)?k(e):e||[],!1).length}});var q,L=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(k.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||q,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:L.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof k?t[0]:t,k.merge(this,k.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),D.test(r[1])&&k.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(k):k.makeArray(e,this)}).prototype=k.fn,q=k(E);var H=/^(?:parents|prev(?:Until|All))/,O={children:!0,contents:!0,next:!0,prev:!0};function P(e,t){while((e=e[t])&&1!==e.nodeType);return e}k.fn.extend({has:function(e){var t=k(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(k.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&k(e);if(!N.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&k.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?k.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(k(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(k.uniqueSort(k.merge(this.get(),k(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),k.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return T(e,"parentNode")},parentsUntil:function(e,t,n){return T(e,"parentNode",n)},next:function(e){return P(e,"nextSibling")},prev:function(e){return P(e,"previousSibling")},nextAll:function(e){return T(e,"nextSibling")},prevAll:function(e){return T(e,"previousSibling")},nextUntil:function(e,t,n){return T(e,"nextSibling",n)},prevUntil:function(e,t,n){return T(e,"previousSibling",n)},siblings:function(e){return S((e.parentNode||{}).firstChild,e)},children:function(e){return S(e.firstChild)},contents:function(e){return"undefined"!=typeof e.contentDocument?e.contentDocument:(A(e,"template")&&(e=e.content||e),k.merge([],e.childNodes))}},function(r,i){k.fn[r]=function(e,t){var n=k.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=k.filter(t,n)),1<this.length&&(O[r]||k.uniqueSort(n),H.test(r)&&n.reverse()),this.pushStack(n)}});var R=/[^\x20\t\r\n\f]+/g;function M(e){return e}function I(e){throw e}function W(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}k.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},k.each(e.match(R)||[],function(e,t){n[t]=!0}),n):k.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){k.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return k.each(arguments,function(e,t){var n;while(-1<(n=k.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<k.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},k.extend({Deferred:function(e){var o=[["notify","progress",k.Callbacks("memory"),k.Callbacks("memory"),2],["resolve","done",k.Callbacks("once memory"),k.Callbacks("once memory"),0,"resolved"],["reject","fail",k.Callbacks("once memory"),k.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return k.Deferred(function(r){k.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,M,s),l(u,o,I,s)):(u++,t.call(e,l(u,o,M,s),l(u,o,I,s),l(u,o,M,o.notifyWith))):(a!==M&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){k.Deferred.exceptionHook&&k.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==I&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(k.Deferred.getStackHook&&(t.stackTrace=k.Deferred.getStackHook()),C.setTimeout(t))}}return k.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:M,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:M)),o[2][3].add(l(0,e,m(n)?n:I))}).promise()},promise:function(e){return null!=e?k.extend(e,a):a}},s={};return k.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=k.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(W(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)W(i[t],a(t),o.reject);return o.promise()}});var $=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;k.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&$.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},k.readyException=function(e){C.setTimeout(function(){throw e})};var F=k.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),k.ready()}k.fn.ready=function(e){return F.then(e)["catch"](function(e){k.readyException(e)}),this},k.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--k.readyWait:k.isReady)||(k.isReady=!0)!==e&&0<--k.readyWait||F.resolveWith(E,[k])}}),k.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(k.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var _=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)_(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(k(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},z=/^-ms-/,U=/-([a-z])/g;function X(e,t){return t.toUpperCase()}function V(e){return e.replace(z,"ms-").replace(U,X)}var G=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function Y(){this.expando=k.expando+Y.uid++}Y.uid=1,Y.prototype={cache:function(e){var t=e[this.expando];return t||(t={},G(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[V(t)]=n;else for(r in t)i[V(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][V(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(V):(t=V(t))in r?[t]:t.match(R)||[]).length;while(n--)delete r[t[n]]}(void 0===t||k.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!k.isEmptyObject(t)}};var Q=new Y,J=new Y,K=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Z=/[A-Z]/g;function ee(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(Z,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:K.test(i)?JSON.parse(i):i)}catch(e){}J.set(e,t,n)}else n=void 0;return n}k.extend({hasData:function(e){return J.hasData(e)||Q.hasData(e)},data:function(e,t,n){return J.access(e,t,n)},removeData:function(e,t){J.remove(e,t)},_data:function(e,t,n){return Q.access(e,t,n)},_removeData:function(e,t){Q.remove(e,t)}}),k.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=J.get(o),1===o.nodeType&&!Q.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=V(r.slice(5)),ee(o,r,i[r]));Q.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){J.set(this,n)}):_(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=J.get(o,n))?t:void 0!==(t=ee(o,n))?t:void 0;this.each(function(){J.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){J.remove(this,e)})}}),k.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Q.get(e,t),n&&(!r||Array.isArray(n)?r=Q.access(e,t,k.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=k.queue(e,t),r=n.length,i=n.shift(),o=k._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){k.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Q.get(e,n)||Q.access(e,n,{empty:k.Callbacks("once memory").add(function(){Q.remove(e,[t+"queue",n])})})}}),k.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?k.queue(this[0],t):void 0===n?this:this.each(function(){var e=k.queue(this,t,n);k._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&k.dequeue(this,t)})},dequeue:function(e){return this.each(function(){k.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=k.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Q.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var te=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ne=new RegExp("^(?:([+-])=|)("+te+")([a-z%]*)$","i"),re=["Top","Right","Bottom","Left"],ie=E.documentElement,oe=function(e){return k.contains(e.ownerDocument,e)},ae={composed:!0};ie.getRootNode&&(oe=function(e){return k.contains(e.ownerDocument,e)||e.getRootNode(ae)===e.ownerDocument});var se=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&oe(e)&&"none"===k.css(e,"display")},ue=function(e,t,n,r){var i,o,a={};for(o in t)a[o]=e.style[o],e.style[o]=t[o];for(o in i=n.apply(e,r||[]),t)e.style[o]=a[o];return i};function le(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return k.css(e,t,"")},u=s(),l=n&&n[3]||(k.cssNumber[t]?"":"px"),c=e.nodeType&&(k.cssNumber[t]||"px"!==l&&+u)&&ne.exec(k.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)k.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,k.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ce={};function fe(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Q.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&se(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ce[s])||(o=a.body.appendChild(a.createElement(s)),u=k.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ce[s]=u)))):"none"!==n&&(l[c]="none",Q.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}k.fn.extend({show:function(){return fe(this,!0)},hide:function(){return fe(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){se(this)?k(this).show():k(this).hide()})}});var pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i,ge={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?k.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Q.set(e[n],"globalEval",!t||Q.get(t[n],"globalEval"))}ge.optgroup=ge.option,ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td;var me,xe,be=/<|&#?\w+;/;function we(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))k.merge(p,o.nodeType?[o]:o);else if(be.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+k.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;k.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<k.inArray(o,r))i&&i.push(o);else if(l=oe(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}me=E.createDocumentFragment().appendChild(E.createElement("div")),(xe=E.createElement("input")).setAttribute("type","radio"),xe.setAttribute("checked","checked"),xe.setAttribute("name","t"),me.appendChild(xe),y.checkClone=me.cloneNode(!0).cloneNode(!0).lastChild.checked,me.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!me.cloneNode(!0).lastChild.defaultValue;var Te=/^key/,Ce=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ee=/^([^.]*)(?:\.(.+)|)/;function ke(){return!0}function Se(){return!1}function Ne(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ae(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ae(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Se;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return k().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=k.guid++)),e.each(function(){k.event.add(this,t,i,r,n)})}function De(e,i,o){o?(Q.set(e,i,!1),k.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Q.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(k.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Q.set(this,i,r),t=o(this,i),this[i](),r!==(n=Q.get(this,i))||t?Q.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n.value}else r.length&&(Q.set(this,i,{value:k.event.trigger(k.extend(r[0],k.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Q.get(e,i)&&k.event.add(e,i,ke)}k.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.get(t);if(v){n.handler&&(n=(o=n).handler,i=o.selector),i&&k.find.matchesSelector(ie,i),n.guid||(n.guid=k.guid++),(u=v.events)||(u=v.events={}),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof k&&k.event.triggered!==e.type?k.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(R)||[""]).length;while(l--)d=g=(s=Ee.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=k.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=k.event.special[d]||{},c=k.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&k.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),k.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.hasData(e)&&Q.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(R)||[""]).length;while(l--)if(d=g=(s=Ee.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=k.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||k.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)k.event.remove(e,d+t[l],n,r,!0);k.isEmptyObject(u)&&Q.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=k.event.fix(e),u=new Array(arguments.length),l=(Q.get(this,"events")||{})[s.type]||[],c=k.event.special[s.type]||{};for(u[0]=s,t=1;t<arguments.length;t++)u[t]=arguments[t];if(s.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,s)){a=k.event.handlers.call(this,s,l),t=0;while((i=a[t++])&&!s.isPropagationStopped()){s.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!s.isImmediatePropagationStopped())s.rnamespace&&!1!==o.namespace&&!s.rnamespace.test(o.namespace)||(s.handleObj=o,s.data=o.data,void 0!==(r=((k.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,u))&&!1===(s.result=r)&&(s.preventDefault(),s.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,s),s.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<k(i,this).index(l):k.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(k.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[k.expando]?e:new k.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&De(t,"click",ke),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&De(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Q.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},k.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},k.Event=function(e,t){if(!(this instanceof k.Event))return new k.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?ke:Se,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&k.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[k.expando]=!0},k.Event.prototype={constructor:k.Event,isDefaultPrevented:Se,isPropagationStopped:Se,isImmediatePropagationStopped:Se,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=ke,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=ke,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=ke,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},k.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&Te.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&Ce.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},k.event.addProp),k.each({focus:"focusin",blur:"focusout"},function(e,t){k.event.special[e]={setup:function(){return De(this,e,Ne),!1},trigger:function(){return De(this,e),!0},delegateType:t}}),k.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){k.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||k.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),k.fn.extend({on:function(e,t,n,r){return Ae(this,e,t,n,r)},one:function(e,t,n,r){return Ae(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,k(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Se),this.each(function(){k.event.remove(this,e,n,t)})}});var je=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,qe=/<script|<style|<link/i,Le=/checked\s*(?:[^=]|=\s*.checked.)/i,He=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Oe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&k(e).children("tbody")[0]||e}function Pe(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Re(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Me(e,t){var n,r,i,o,a,s,u,l;if(1===t.nodeType){if(Q.hasData(e)&&(o=Q.access(e),a=Q.set(t,o),l=o.events))for(i in delete a.handle,a.events={},l)for(n=0,r=l[i].length;n<r;n++)k.event.add(t,i,l[i][n]);J.hasData(e)&&(s=J.access(e),u=k.extend({},s),J.set(t,u))}}function Ie(n,r,i,o){r=g.apply([],r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&Le.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),Ie(t,r,i,o)});if(f&&(t=(e=we(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=k.map(ve(e,"script"),Pe)).length;c<f;c++)u=e,c!==p&&(u=k.clone(u,!0,!0),s&&k.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,k.map(a,Re),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Q.access(u,"globalEval")&&k.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?k._evalUrl&&!u.noModule&&k._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")}):b(u.textContent.replace(He,""),u,l))}return n}function We(e,t,n){for(var r,i=t?k.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||k.cleanData(ve(r)),r.parentNode&&(n&&oe(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}k.extend({htmlPrefilter:function(e){return e.replace(je,"<$1></$2>")},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=oe(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||k.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Me(o[r],a[r]);else Me(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=k.event.special,o=0;void 0!==(n=e[o]);o++)if(G(n)){if(t=n[Q.expando]){if(t.events)for(r in t.events)i[r]?k.event.remove(n,r):k.removeEvent(n,r,t.handle);n[Q.expando]=void 0}n[J.expando]&&(n[J.expando]=void 0)}}}),k.fn.extend({detach:function(e){return We(this,e,!0)},remove:function(e){return We(this,e)},text:function(e){return _(this,function(e){return void 0===e?k.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return Ie(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||Oe(this,e).appendChild(e)})},prepend:function(){return Ie(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Oe(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return Ie(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return Ie(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(k.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return k.clone(this,e,t)})},html:function(e){return _(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!qe.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=k.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(k.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return Ie(this,arguments,function(e){var t=this.parentNode;k.inArray(this,n)<0&&(k.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),k.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){k.fn[e]=function(e){for(var t,n=[],r=k(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),k(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var $e=new RegExp("^("+te+")(?!px)[a-z%]+$","i"),Fe=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},Be=new RegExp(re.join("|"),"i");function _e(e,t,n){var r,i,o,a,s=e.style;return(n=n||Fe(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||oe(e)||(a=k.style(e,t)),!y.pixelBoxStyles()&&$e.test(a)&&Be.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function ze(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(u){s.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",u.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",ie.appendChild(s).appendChild(u);var e=C.getComputedStyle(u);n="1%"!==e.top,a=12===t(e.marginLeft),u.style.right="60%",o=36===t(e.right),r=36===t(e.width),u.style.position="absolute",i=12===t(u.offsetWidth/3),ie.removeChild(s),u=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s=E.createElement("div"),u=E.createElement("div");u.style&&(u.style.backgroundClip="content-box",u.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===u.style.backgroundClip,k.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),a},scrollboxSize:function(){return e(),i}}))}();var Ue=["Webkit","Moz","ms"],Xe=E.createElement("div").style,Ve={};function Ge(e){var t=k.cssProps[e]||Ve[e];return t||(e in Xe?e:Ve[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Ue.length;while(n--)if((e=Ue[n]+t)in Xe)return e}(e)||e)}var Ye=/^(none|table(?!-c[ea]).+)/,Qe=/^--/,Je={position:"absolute",visibility:"hidden",display:"block"},Ke={letterSpacing:"0",fontWeight:"400"};function Ze(e,t,n){var r=ne.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function et(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=k.css(e,n+re[a],!0,i)),r?("content"===n&&(u-=k.css(e,"padding"+re[a],!0,i)),"margin"!==n&&(u-=k.css(e,"border"+re[a]+"Width",!0,i))):(u+=k.css(e,"padding"+re[a],!0,i),"padding"!==n?u+=k.css(e,"border"+re[a]+"Width",!0,i):s+=k.css(e,"border"+re[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function tt(e,t,n){var r=Fe(e),i=(!y.boxSizingReliable()||n)&&"border-box"===k.css(e,"boxSizing",!1,r),o=i,a=_e(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if($e.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||"auto"===a||!parseFloat(a)&&"inline"===k.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===k.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+et(e,t,n||(i?"border":"content"),o,r,a)+"px"}function nt(e,t,n,r,i){return new nt.prototype.init(e,t,n,r,i)}k.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=_e(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=V(t),u=Qe.test(t),l=e.style;if(u||(t=Ge(s)),a=k.cssHooks[t]||k.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=ne.exec(n))&&i[1]&&(n=le(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(k.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=V(t);return Qe.test(t)||(t=Ge(s)),(a=k.cssHooks[t]||k.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=_e(e,t,r)),"normal"===i&&t in Ke&&(i=Ke[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),k.each(["height","width"],function(e,u){k.cssHooks[u]={get:function(e,t,n){if(t)return!Ye.test(k.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?tt(e,u,n):ue(e,Je,function(){return tt(e,u,n)})},set:function(e,t,n){var r,i=Fe(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===k.css(e,"boxSizing",!1,i),s=n?et(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-et(e,u,"border",!1,i)-.5)),s&&(r=ne.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=k.css(e,u)),Ze(0,t,s)}}}),k.cssHooks.marginLeft=ze(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(_e(e,"marginLeft"))||e.getBoundingClientRect().left-ue(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),k.each({margin:"",padding:"",border:"Width"},function(i,o){k.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+re[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(k.cssHooks[i+o].set=Ze)}),k.fn.extend({css:function(e,t){return _(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Fe(e),i=t.length;a<i;a++)o[t[a]]=k.css(e,t[a],!1,r);return o}return void 0!==n?k.style(e,t,n):k.css(e,t)},e,t,1<arguments.length)}}),((k.Tween=nt).prototype={constructor:nt,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||k.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(k.cssNumber[n]?"":"px")},cur:function(){var e=nt.propHooks[this.prop];return e&&e.get?e.get(this):nt.propHooks._default.get(this)},run:function(e){var t,n=nt.propHooks[this.prop];return this.options.duration?this.pos=t=k.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):nt.propHooks._default.set(this),this}}).init.prototype=nt.prototype,(nt.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=k.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){k.fx.step[e.prop]?k.fx.step[e.prop](e):1!==e.elem.nodeType||!k.cssHooks[e.prop]&&null==e.elem.style[Ge(e.prop)]?e.elem[e.prop]=e.now:k.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=nt.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},k.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},k.fx=nt.prototype.init,k.fx.step={};var rt,it,ot,at,st=/^(?:toggle|show|hide)$/,ut=/queueHooks$/;function lt(){it&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(lt):C.setTimeout(lt,k.fx.interval),k.fx.tick())}function ct(){return C.setTimeout(function(){rt=void 0}),rt=Date.now()}function ft(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=re[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function pt(e,t,n){for(var r,i=(dt.tweeners[t]||[]).concat(dt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function dt(o,e,t){var n,a,r=0,i=dt.prefilters.length,s=k.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=rt||ct(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:k.extend({},e),opts:k.extend(!0,{specialEasing:{},easing:k.easing._default},t),originalProperties:e,originalOptions:t,startTime:rt||ct(),duration:t.duration,tweens:[],createTween:function(e,t){var n=k.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=V(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=k.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=dt.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(k._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return k.map(c,pt,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),k.fx.timer(k.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}k.Animation=k.extend(dt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return le(n.elem,e,ne.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(R);for(var n,r=0,i=e.length;r<i;r++)n=e[r],dt.tweeners[n]=dt.tweeners[n]||[],dt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&se(e),v=Q.get(e,"fxshow");for(r in n.queue||(null==(a=k._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,k.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],st.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||k.style(e,r)}if((u=!k.isEmptyObject(t))||!k.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Q.get(e,"display")),"none"===(c=k.css(e,"display"))&&(l?c=l:(fe([e],!0),l=e.style.display||l,c=k.css(e,"display"),fe([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===k.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Q.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&fe([e],!0),p.done(function(){for(r in g||fe([e]),Q.remove(e,"fxshow"),d)k.style(e,r,d[r])})),u=pt(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?dt.prefilters.unshift(e):dt.prefilters.push(e)}}),k.speed=function(e,t,n){var r=e&&"object"==typeof e?k.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return k.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in k.fx.speeds?r.duration=k.fx.speeds[r.duration]:r.duration=k.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&k.dequeue(this,r.queue)},r},k.fn.extend({fadeTo:function(e,t,n,r){return this.filter(se).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=k.isEmptyObject(t),o=k.speed(e,n,r),a=function(){var e=dt(this,k.extend({},t),o);(i||Q.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&!1!==i&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=k.timers,r=Q.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&ut.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||k.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Q.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=k.timers,o=n?n.length:0;for(t.finish=!0,k.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),k.each(["toggle","show","hide"],function(e,r){var i=k.fn[r];k.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(ft(r,!0),e,t,n)}}),k.each({slideDown:ft("show"),slideUp:ft("hide"),slideToggle:ft("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){k.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),k.timers=[],k.fx.tick=function(){var e,t=0,n=k.timers;for(rt=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||k.fx.stop(),rt=void 0},k.fx.timer=function(e){k.timers.push(e),k.fx.start()},k.fx.interval=13,k.fx.start=function(){it||(it=!0,lt())},k.fx.stop=function(){it=null},k.fx.speeds={slow:600,fast:200,_default:400},k.fn.delay=function(r,e){return r=k.fx&&k.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},ot=E.createElement("input"),at=E.createElement("select").appendChild(E.createElement("option")),ot.type="checkbox",y.checkOn=""!==ot.value,y.optSelected=at.selected,(ot=E.createElement("input")).value="t",ot.type="radio",y.radioValue="t"===ot.value;var ht,gt=k.expr.attrHandle;k.fn.extend({attr:function(e,t){return _(this,k.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){k.removeAttr(this,e)})}}),k.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?k.prop(e,t,n):(1===o&&k.isXMLDoc(e)||(i=k.attrHooks[t.toLowerCase()]||(k.expr.match.bool.test(t)?ht:void 0)),void 0!==n?null===n?void k.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=k.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(R);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),ht={set:function(e,t,n){return!1===t?k.removeAttr(e,n):e.setAttribute(n,n),n}},k.each(k.expr.match.bool.source.match(/\w+/g),function(e,t){var a=gt[t]||k.find.attr;gt[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=gt[o],gt[o]=r,r=null!=a(e,t,n)?o:null,gt[o]=i),r}});var vt=/^(?:input|select|textarea|button)$/i,yt=/^(?:a|area)$/i;function mt(e){return(e.match(R)||[]).join(" ")}function xt(e){return e.getAttribute&&e.getAttribute("class")||""}function bt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(R)||[]}k.fn.extend({prop:function(e,t){return _(this,k.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[k.propFix[e]||e]})}}),k.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&k.isXMLDoc(e)||(t=k.propFix[t]||t,i=k.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=k.find.attr(e,"tabindex");return t?parseInt(t,10):vt.test(e.nodeName)||yt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(k.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),k.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){k.propFix[this.toLowerCase()]=this}),k.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){k(this).addClass(t.call(this,e,xt(this)))});if((e=bt(t)).length)while(n=this[u++])if(i=xt(n),r=1===n.nodeType&&" "+mt(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=mt(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){k(this).removeClass(t.call(this,e,xt(this)))});if(!arguments.length)return this.attr("class","");if((e=bt(t)).length)while(n=this[u++])if(i=xt(n),r=1===n.nodeType&&" "+mt(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=mt(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){k(this).toggleClass(i.call(this,e,xt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=k(this),r=bt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=xt(this))&&Q.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Q.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+mt(xt(n))+" ").indexOf(t))return!0;return!1}});var wt=/\r/g;k.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,k(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=k.map(t,function(e){return null==e?"":e+""})),(r=k.valHooks[this.type]||k.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=k.valHooks[t.type]||k.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(wt,""):null==e?"":e:void 0}}),k.extend({valHooks:{option:{get:function(e){var t=k.find.attr(e,"value");return null!=t?t:mt(k.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=k(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=k.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<k.inArray(k.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),k.each(["radio","checkbox"],function(){k.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<k.inArray(k(e).val(),t)}},y.checkOn||(k.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var Tt=/^(?:focusinfocus|focusoutblur)$/,Ct=function(e){e.stopPropagation()};k.extend(k.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!Tt.test(d+k.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[k.expando]?e:new k.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:k.makeArray(t,[e]),c=k.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,Tt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Q.get(o,"events")||{})[e.type]&&Q.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&G(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!G(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),k.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,Ct),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,Ct),k.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=k.extend(new k.Event,n,{type:e,isSimulated:!0});k.event.trigger(r,null,t)}}),k.fn.extend({trigger:function(e,t){return this.each(function(){k.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return k.event.trigger(e,t,n,!0)}}),y.focusin||k.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){k.event.simulate(r,e.target,k.event.fix(e))};k.event.special[r]={setup:function(){var e=this.ownerDocument||this,t=Q.access(e,r);t||e.addEventListener(n,i,!0),Q.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this,t=Q.access(e,r)-1;t?Q.access(e,r,t):(e.removeEventListener(n,i,!0),Q.remove(e,r))}}});var Et=C.location,kt=Date.now(),St=/\?/;k.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||k.error("Invalid XML: "+e),t};var Nt=/\[\]$/,At=/\r?\n/g,Dt=/^(?:submit|button|image|reset|file)$/i,jt=/^(?:input|select|textarea|keygen)/i;function qt(n,e,r,i){var t;if(Array.isArray(e))k.each(e,function(e,t){r||Nt.test(n)?i(n,t):qt(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)qt(n+"["+t+"]",e[t],r,i)}k.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!k.isPlainObject(e))k.each(e,function(){i(this.name,this.value)});else for(n in e)qt(n,e[n],t,i);return r.join("&")},k.fn.extend({serialize:function(){return k.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=k.prop(this,"elements");return e?k.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!k(this).is(":disabled")&&jt.test(this.nodeName)&&!Dt.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=k(this).val();return null==n?null:Array.isArray(n)?k.map(n,function(e){return{name:t.name,value:e.replace(At,"\r\n")}}):{name:t.name,value:n.replace(At,"\r\n")}}).get()}});var Lt=/%20/g,Ht=/#.*$/,Ot=/([?&])_=[^&]*/,Pt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Rt=/^(?:GET|HEAD)$/,Mt=/^\/\//,It={},Wt={},$t="*/".concat("*"),Ft=E.createElement("a");function Bt(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(R)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function _t(t,i,o,a){var s={},u=t===Wt;function l(e){var r;return s[e]=!0,k.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function zt(e,t){var n,r,i=k.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&k.extend(!0,e,r),e}Ft.href=Et.href,k.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Et.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Et.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":$t,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":k.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?zt(zt(e,k.ajaxSettings),t):zt(k.ajaxSettings,e)},ajaxPrefilter:Bt(It),ajaxTransport:Bt(Wt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=k.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?k(y):k.event,x=k.Deferred(),b=k.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=Pt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||Et.href)+"").replace(Mt,Et.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(R)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Ft.protocol+"//"+Ft.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=k.param(v.data,v.traditional)),_t(It,v,t,T),h)return T;for(i in(g=k.event&&v.global)&&0==k.active++&&k.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Rt.test(v.type),f=v.url.replace(Ht,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Lt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(St.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Ot,"$1"),o=(St.test(f)?"&":"?")+"_="+kt+++o),v.url=f+o),v.ifModified&&(k.lastModified[f]&&T.setRequestHeader("If-Modified-Since",k.lastModified[f]),k.etag[f]&&T.setRequestHeader("If-None-Match",k.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+$t+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=_t(Wt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(k.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(k.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--k.active||k.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return k.get(e,t,n,"json")},getScript:function(e,t){return k.get(e,void 0,t,"script")}}),k.each(["get","post"],function(e,i){k[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),k.ajax(k.extend({url:e,type:i,dataType:r,data:t,success:n},k.isPlainObject(e)&&e))}}),k._evalUrl=function(e,t){return k.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){k.globalEval(e,t)}})},k.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=k(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){k(this).wrapInner(n.call(this,e))}):this.each(function(){var e=k(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){k(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){k(this).replaceWith(this.childNodes)}),this}}),k.expr.pseudos.hidden=function(e){return!k.expr.pseudos.visible(e)},k.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},k.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var Ut={0:200,1223:204},Xt=k.ajaxSettings.xhr();y.cors=!!Xt&&"withCredentials"in Xt,y.ajax=Xt=!!Xt,k.ajaxTransport(function(i){var o,a;if(y.cors||Xt&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Ut[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),k.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),k.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return k.globalEval(e),e}}}),k.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),k.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=k("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Vt,Gt=[],Yt=/(=)\?(?=&|$)|\?\?/;k.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Gt.pop()||k.expando+"_"+kt++;return this[e]=!0,e}}),k.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Yt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Yt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Yt,"$1"+r):!1!==e.jsonp&&(e.url+=(St.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||k.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?k(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Gt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Vt=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Vt.childNodes.length),k.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=D.exec(e))?[t.createElement(i[1])]:(i=we([e],t,o),o&&o.length&&k(o).remove(),k.merge([],i.childNodes)));var r,i,o},k.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=mt(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&k.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?k("<div>").append(k.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},k.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){k.fn[t]=function(e){return this.on(t,e)}}),k.expr.pseudos.animated=function(t){return k.grep(k.timers,function(e){return t===e.elem}).length},k.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=k.css(e,"position"),c=k(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=k.css(e,"top"),u=k.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,k.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},k.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){k.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===k.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===k.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=k(e).offset()).top+=k.css(e,"borderTopWidth",!0),i.left+=k.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-k.css(r,"marginTop",!0),left:t.left-i.left-k.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===k.css(e,"position"))e=e.offsetParent;return e||ie})}}),k.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;k.fn[t]=function(e){return _(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),k.each(["top","left"],function(e,n){k.cssHooks[n]=ze(y.pixelPosition,function(e,t){if(t)return t=_e(e,n),$e.test(t)?k(e).position()[n]+"px":t})}),k.each({Height:"height",Width:"width"},function(a,s){k.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){k.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return _(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?k.css(e,t,i):k.style(e,t,n,i)},s,n?e:void 0,n)}})}),k.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){k.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}}),k.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),k.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)}}),k.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||k.guid++,i},k.holdReady=function(e){e?k.readyWait++:k.ready(!0)},k.isArray=Array.isArray,k.parseJSON=JSON.parse,k.nodeName=A,k.isFunction=m,k.isWindow=x,k.camelCase=V,k.type=w,k.now=Date.now,k.isNumeric=function(e){var t=k.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},"function"==typeof define&&define.amd&&define("jquery",[],function(){return k});var Qt=C.jQuery,Jt=C.$;return k.noConflict=function(e){return C.$===k&&(C.$=Jt),e&&C.jQuery===k&&(C.jQuery=Qt),k},e||(C.jQuery=C.$=k),k});
",
{"status":false}
],

[
"w2ui.min.js_1.5",
"/* w2ui 1.5.x (nightly) (c) http://w2ui.com, vitmalina@gmail.com */

var w2ui=w2ui||{},w2obj=w2obj||{},w2utils=function(g){var e={};return{version:"1.5.x",settings:{locale:"en-us",dateFormat:"m/d/yyyy",timeFormat:"hh:mi pm",datetimeFormat:"m/d/yyyy|hh:mi pm",currencyPrefix:"$",currencySuffix:"",currencyPrecision:2,groupSymbol:",",decimalSymbol:".",shortmonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],fullmonths:["January","February","March","April","May","June","July","August","September","October","November","December"],shortdays:["M","T","W","T","F","S","S"],fulldays:["Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"],weekStarts:"M",dataType:"HTTPJSON",phrases:{},dateStartYear:1950,dateEndYear:2020,macButtonOrder:!1},isBin:function(e){return/^[0-1]+$/.test(e)},isInt:h,isFloat:function(e){"string"==typeof e&&(e=e.replace(/\s+/g,"").replace(w2utils.settings.groupSymbol,"").replace(w2utils.settings.decimalSymbol,"."));return("number"==typeof e||"string"==typeof e&&""!==e)&&!isNaN(Number(e))},isMoney:function(e){var t=w2utils.settings,i=new RegExp("^"+(t.currencyPrefix?"\\"+t.currencyPrefix+"?":"")+"[-+]?"+(t.currencyPrefix?"\\"+t.currencyPrefix+"?":"")+"[0-9]*[\\"+t.decimalSymbol+"]?[0-9]+"+(t.currencySuffix?"\\"+t.currencySuffix+"?":"")+"$","i");"string"==typeof e&&(e=e.replace(new RegExp(t.groupSymbol,"g"),""));return"object"!=typeof e&&""!==e&&i.test(e)},isHex:function(e){return/^(0x)?[0-9a-fA-F]+$/.test(e)},isAlphaNumeric:function(e){return/^[a-zA-Z0-9_-]+$/.test(e)},isEmail:function(e){return/^[a-zA-Z0-9._%\-+]+@[а-яА-Яa-zA-Z0-9.-]+\.[а-яА-Яa-zA-Z]+$/.test(e)},isIpAddress:function(e){return new RegExp("^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$").test(e)},isDate:function(e,t,i){if(!e)return!1;var s,n,a,r="Invalid Date";null==t&&(t=w2utils.settings.dateFormat);if("function"==typeof e.getFullYear)a=e.getFullYear(),s=e.getMonth()+1,n=e.getDate();else if(parseInt(e)==e&&0<parseInt(e))e=new Date(parseInt(e)),a=e.getFullYear(),s=e.getMonth()+1,n=e.getDate();else{if(e=String(e),new RegExp("mon","ig").test(t)){t=t.replace(/month/gi,"m").replace(/mon/gi,"m").replace(/dd/gi,"d").replace(/[, ]/gi,"/").replace(/\/\//g,"/").toLowerCase(),e=e.replace(/[, ]/gi,"/").replace(/\/\//g,"/").toLowerCase();for(var l=0,o=w2utils.settings.fullmonths.length;l<o;l++){var d=w2utils.settings.fullmonths[l];e=e.replace(new RegExp(d,"ig"),parseInt(l)+1).replace(new RegExp(d.substr(0,3),"ig"),parseInt(l)+1)}}var u=e.replace(/-/g,"/").replace(/\./g,"/").toLowerCase().split("/"),c=t.replace(/-/g,"/").replace(/\./g,"/").toLowerCase();"mm/dd/yyyy"===c&&(s=u[0],n=u[1],a=u[2]),"m/d/yyyy"===c&&(s=u[0],n=u[1],a=u[2]),"dd/mm/yyyy"===c&&(s=u[1],n=u[0],a=u[2]),"d/m/yyyy"===c&&(s=u[1],n=u[0],a=u[2]),"yyyy/dd/mm"===c&&(s=u[2],n=u[1],a=u[0]),"yyyy/d/m"===c&&(s=u[2],n=u[1],a=u[0]),"yyyy/mm/dd"===c&&(s=u[1],n=u[2],a=u[0]),"yyyy/m/d"===c&&(s=u[1],n=u[2],a=u[0]),"mm/dd/yy"===c&&(s=u[0],n=u[1],a=u[2]),"m/d/yy"===c&&(s=u[0],n=u[1],a=parseInt(u[2])+1900),"dd/mm/yy"===c&&(s=u[1],n=u[0],a=parseInt(u[2])+1900),"d/m/yy"===c&&(s=u[1],n=u[0],a=parseInt(u[2])+1900),"yy/dd/mm"===c&&(s=u[2],n=u[1],a=parseInt(u[0])+1900),"yy/d/m"===c&&(s=u[2],n=u[1],a=parseInt(u[0])+1900),"yy/mm/dd"===c&&(s=u[1],n=u[2],a=parseInt(u[0])+1900),"yy/m/d"===c&&(s=u[1],n=u[2],a=parseInt(u[0])+1900)}if(!h(a))return!1;if(!h(s))return!1;if(!h(n))return!1;if(a=+a,s=+s,n=+n,r=new Date(a,s-1,n),null==s)return!1;if("Invalid Date"===String(r))return!1;if(r.getMonth()+1!==s||r.getDate()!==n||r.getFullYear()!==a)return!1;return!0!==i||r},isTime:function(e,t){if(null==e)return!1;var i,s,n;e=(e=String(e)).toUpperCase(),s=0<=e.indexOf("AM");var a=(n=0<=e.indexOf("PM"))||s;i=a?12:24;e=e.replace("AM","").replace("PM","");var r=(e=g.trim(e)).split(":"),l=parseInt(r[0]||0),o=parseInt(r[1]||0),d=parseInt(r[2]||0);if((!a||1!==r.length)&&2!==r.length&&3!==r.length)return!1;if(""===r[0]||l<0||i<l||!this.isInt(r[0])||2<r[0].length)return!1;if(1<r.length&&(""===r[1]||o<0||59<o||!this.isInt(r[1])||2!==r[1].length))return!1;if(2<r.length&&(""===r[2]||d<0||59<d||!this.isInt(r[2])||2!==r[2].length))return!1;if(!a&&i===l&&(0!==o||0!==d))return!1;if(a&&1===r.length&&0===l)return!1;if(!0!==t)return!0;n&&12!==l&&(l+=12);s&&12===l&&(l+=12);return{hours:l,minutes:o,seconds:d}},isDateTime:function(e,t,i){null==t&&(t=w2utils.settings.datetimeFormat);var s=t.split("|");{if("function"==typeof e.getFullYear)return!0!==i||e;if(parseInt(e)===e&&0<=parseInt(e))return e=new Date(parseInt(e)),!0!==i||e;if(parseInt(e)===e&&parseInt(e)<0)return!1;var n=String(e).indexOf(" "),a=[e.substr(0,n),e.substr(n).trim()];s[0]=s[0].trim(),s[1]&&(s[1]=s[1].trim());var r=w2utils.isDate(a[0],s[0],!0),l=w2utils.isTime(a[1],!0);return!1!==r&&!1!==l&&(!0!==i||(r.setHours(l.hours),r.setMinutes(l.minutes),r.setSeconds(l.seconds),r))}},age:function(e){var t;if(""===e||null==e)return"";t="function"==typeof e.getFullYear?e:parseInt(e)==e&&0<parseInt(e)?new Date(parseInt(e)):new Date(e);if("Invalid Date"===String(t))return"";var i=((new Date).getTime()-t.getTime())/1e3,s="",n="";i<0?(s=0,n="sec"):i<60?(s=Math.floor(i),n="sec",i<0&&(s=0,n="sec")):i<3600?(s=Math.floor(i/60),n="min"):i<86400?(s=Math.floor(i/60/60),n="hour"):i<2592e3?(s=Math.floor(i/24/60/60),n="day"):i<31536e3?(s=Math.floor(i/30/24/60/60*10)/10,n="month"):i<126144e3?(s=Math.floor(i/365/24/60/60*10)/10,n="year"):126144e3<=i&&(s=Math.floor(i/365.25/24/60/60*10)/10,n="year");return s+" "+n+(1<s?"s":"")},interval:function(e){var t="";t=e<1e3?"< 1 sec":e<6e4?Math.floor(e/1e3)+" secs":e<36e5?Math.floor(e/6e4)+" mins":e<864e5?Math.floor(e/36e5*10)/10+" hours":e<2628e6?Math.floor(e/864e5*10)/10+" days":e<31536e6?Math.floor(e/2628e6*10)/10+" months":Math.floor(e/31536e5)/10+" years";return t},date:function(e){if(""===e||null==e||"object"==typeof e&&!e.getMonth)return"";var t=new Date(e);w2utils.isInt(e)&&(t=new Date(Number(e)));if("Invalid Date"===String(t))return"";var i=w2utils.settings.shortmonths,s=new Date,n=new Date;n.setTime(n.getTime()-864e5);var a=i[t.getMonth()]+" "+t.getDate()+", "+t.getFullYear(),r=i[s.getMonth()]+" "+s.getDate()+", "+s.getFullYear(),l=i[n.getMonth()]+" "+n.getDate()+", "+n.getFullYear(),o=t.getHours()-(12<t.getHours()?12:0)+":"+(t.getMinutes()<10?"0":"")+t.getMinutes()+" "+(12<=t.getHours()?"pm":"am"),d=t.getHours()-(12<t.getHours()?12:0)+":"+(t.getMinutes()<10?"0":"")+t.getMinutes()+":"+(t.getSeconds()<10?"0":"")+t.getSeconds()+" "+(12<=t.getHours()?"pm":"am"),u=a;a==r&&(u=o);a==l&&(u=w2utils.lang("Yesterday"));return'<span title="'+a+" "+d+'">'+u+"</span>"},formatSize:function(e){if(!w2utils.isFloat(e)||""===e)return"";if(0===(e=parseFloat(e)))return 0;var t=parseInt(Math.floor(Math.log(e)/Math.log(1024)));return(Math.floor(e/Math.pow(1024,t)*10)/10).toFixed(0===t?0:1)+" "+(["Bt","KB","MB","GB","TB","PB","EB","ZB"][t]||"??")},formatNumber:function(e,t,i){if(null==e||""===e||"object"==typeof e)return"";var s={minimumFractionDigits:t,maximumFractionDigits:t,useGrouping:i};(null==t||t<0)&&(s.minimumFractionDigits=0,s.maximumFractionDigits=20);return parseFloat(e).toLocaleString(w2utils.settings.locale,s)},formatDate:function(e,t){t=t||this.settings.dateFormat;if(""===e||null==e||"object"==typeof e&&!e.getMonth)return"";var i=new Date(e);w2utils.isInt(e)&&(i=new Date(Number(e)));if("Invalid Date"===String(i))return"";var s=i.getFullYear(),n=i.getMonth(),a=i.getDate();return t.toLowerCase().replace("month",w2utils.settings.fullmonths[n]).replace("mon",w2utils.settings.shortmonths[n]).replace(/yyyy/g,s).replace(/yyy/g,s).replace(/yy/g,2e3<s?100+parseInt(String(s).substr(2)):String(s).substr(2)).replace(/(^|[^a-z$])y/g,"$1"+s).replace(/mm/g,(n+1<10?"0":"")+(n+1)).replace(/dd/g,(a<10?"0":"")+a).replace(/th/g,1==a?"st":"th").replace(/th/g,2==a?"nd":"th").replace(/th/g,3==a?"rd":"th").replace(/(^|[^a-z$])m/g,"$1"+(n+1)).replace(/(^|[^a-z$])d/g,"$1"+a)},formatTime:function(e,t){w2utils.settings.shortmonths,w2utils.settings.fullmonths;t=t||this.settings.timeFormat;if(""===e||null==e||"object"==typeof e&&!e.getMonth)return"";var i=new Date(e);w2utils.isInt(e)&&(i=new Date(Number(e)));if(w2utils.isTime(e)){var s=w2utils.isTime(e,!0);(i=new Date).setHours(s.hours),i.setMinutes(s.minutes)}if("Invalid Date"===String(i))return"";var n="am",a=i.getHours(),r=i.getHours(),l=i.getMinutes(),o=i.getSeconds();l<10&&(l="0"+l);o<10&&(o="0"+o);-1===t.indexOf("am")&&-1===t.indexOf("pm")||(12<=a&&(n="pm"),12<a&&(a-=12),0===a&&(a=12));return t.toLowerCase().replace("am",n).replace("pm",n).replace("hhh",a<10?"0"+a:a).replace("hh24",r<10?"0"+r:r).replace("h24",r).replace("hh",a).replace("mm",l).replace("mi",l).replace("ss",o).replace(/(^|[^a-z$])h/g,"$1"+a).replace(/(^|[^a-z$])m/g,"$1"+l).replace(/(^|[^a-z$])s/g,"$1"+o)},formatDateTime:function(e,t){var i;if(""===e||null==e||"object"==typeof e&&!e.getMonth)return"";"string"!=typeof t?i=[this.settings.dateFormat,this.settings.timeFormat]:((i=t.split("|"))[0]=i[0].trim(),i[1]=1<i.length?i[1].trim():this.settings.timeFormat);"h12"===i[1]&&(i[1]="h:m pm");"h24"===i[1]&&(i[1]="h24:m");return this.formatDate(e,i[0])+" "+this.formatTime(e,i[1])},stripTags:function(e){if(null==e)return e;switch(typeof e){case"number":break;case"string":e=String(e).replace(/<(?:[^>=]|='[^']*'|="[^"]*"|=[^'"][^\s>]*)*>/gi,"");break;case"object":if(Array.isArray(e)){e=g.extend(!0,[],e);for(var t=0;t<e.length;t++)e[t]=this.stripTags(e[t])}else for(var t in e=g.extend(!0,{},e))e[t]=this.stripTags(e[t])}return e},encodeTags:n,decodeTags:function(e){if(null==e)return e;switch(typeof e){case"number":break;case"string":e=String(e).replace(/&gt;/g,">").replace(/&lt;/g,"<").replace(/&quot;/g,'"').replace(/&amp;/g,"&");break;case"object":if(Array.isArray(e)){e=g.extend(!0,[],e);for(var t=0;t<e.length;t++)e[t]=this.decodeTags(e[t])}else for(var t in e=g.extend(!0,{},e))e[t]=this.decodeTags(e[t])}return e},escapeId:function(e){return""===e||null==e?"":String(e).replace(/([;&,\.\+\*\~'`:"\!\^#$%@\[\]\(\)=<>\|\/? {}\\])/g,"\\$1")},base64encode:function(e){var t,i,s,n,a,r,l,o="",d=0,u="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";e=function(e){e=String(e).replace(/\r\n/g,"\n");for(var t="",i=0;i<e.length;i++){var s=e.charCodeAt(i);s<128?t+=String.fromCharCode(s):(127<s&&s<2048?t+=String.fromCharCode(s>>6|192):(t+=String.fromCharCode(s>>12|224),t+=String.fromCharCode(s>>6&63|128)),t+=String.fromCharCode(63&s|128))}return t}(e);for(;d<e.length;)t=e.charCodeAt(d++),i=e.charCodeAt(d++),s=e.charCodeAt(d++),n=t>>2,a=(3&t)<<4|i>>4,r=(15&i)<<2|s>>6,l=63&s,isNaN(i)?r=l=64:isNaN(s)&&(l=64),o=o+u.charAt(n)+u.charAt(a)+u.charAt(r)+u.charAt(l);return o},base64decode:function(e){var t,i,s,n,a,r,l,o="",d=0,u="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";e=e.replace(/[^A-Za-z0-9\+\/\=]/g,"");for(;d<e.length;)n=u.indexOf(e.charAt(d++)),a=u.indexOf(e.charAt(d++)),r=u.indexOf(e.charAt(d++)),l=u.indexOf(e.charAt(d++)),t=n<<2|a>>4,i=(15&a)<<4|r>>2,s=(3&r)<<6|l,o+=String.fromCharCode(t),64!==r&&(o+=String.fromCharCode(i)),64!==l&&(o+=String.fromCharCode(s));return o=function(e){var t,i,s="",n=0,a=0;for(;n<e.length;)(a=e.charCodeAt(n))<128?(s+=String.fromCharCode(a),n++):191<a&&a<224?(t=e.charCodeAt(n+1),s+=String.fromCharCode((31&a)<<6|63&t),n+=2):(t=e.charCodeAt(n+1),i=e.charCodeAt(n+2),s+=String.fromCharCode((15&a)<<12|(63&t)<<6|63&i),n+=3);return s}(o)},md5:function(e){var a=0;function t(e){return r(l(n(e),8*e.length))}function i(e){for(var t,i=a?"0123456789ABCDEF":"0123456789abcdef",s="",n=0;n<e.length;n++)t=e.charCodeAt(n),s+=i.charAt(t>>>4&15)+i.charAt(15&t);return s}function s(e){for(var t,i,s="",n=-1;++n<e.length;)t=e.charCodeAt(n),i=n+1<e.length?e.charCodeAt(n+1):0,55296<=t&&t<=56319&&56320<=i&&i<=57343&&(t=65536+((1023&t)<<10)+(1023&i),n++),t<=127?s+=String.fromCharCode(t):t<=2047?s+=String.fromCharCode(192|t>>>6&31,128|63&t):t<=65535?s+=String.fromCharCode(224|t>>>12&15,128|t>>>6&63,128|63&t):t<=2097151&&(s+=String.fromCharCode(240|t>>>18&7,128|t>>>12&63,128|t>>>6&63,128|63&t));return s}function n(e){for(var t=Array(e.length>>2),i=0;i<t.length;i++)t[i]=0;for(i=0;i<8*e.length;i+=8)t[i>>5]|=(255&e.charCodeAt(i/8))<<i%32;return t}function r(e){for(var t="",i=0;i<32*e.length;i+=8)t+=String.fromCharCode(e[i>>5]>>>i%32&255);return t}function l(e,t){e[t>>5]|=128<<t%32,e[14+(t+64>>>9<<4)]=t;for(var i=1732584193,s=-271733879,n=-1732584194,a=271733878,r=0;r<e.length;r+=16){var l=i,o=s,d=n,u=a;s=f(s=f(s=f(s=f(s=p(s=p(s=p(s=p(s=h(s=h(s=h(s=h(s=c(s=c(s=c(s=c(s,n=c(n,a=c(a,i=c(i,s,n,a,e[r+0],7,-680876936),s,n,e[r+1],12,-389564586),i,s,e[r+2],17,606105819),a,i,e[r+3],22,-1044525330),n=c(n,a=c(a,i=c(i,s,n,a,e[r+4],7,-176418897),s,n,e[r+5],12,1200080426),i,s,e[r+6],17,-1473231341),a,i,e[r+7],22,-45705983),n=c(n,a=c(a,i=c(i,s,n,a,e[r+8],7,1770035416),s,n,e[r+9],12,-1958414417),i,s,e[r+10],17,-42063),a,i,e[r+11],22,-1990404162),n=c(n,a=c(a,i=c(i,s,n,a,e[r+12],7,1804603682),s,n,e[r+13],12,-40341101),i,s,e[r+14],17,-1502002290),a,i,e[r+15],22,1236535329),n=h(n,a=h(a,i=h(i,s,n,a,e[r+1],5,-165796510),s,n,e[r+6],9,-1069501632),i,s,e[r+11],14,643717713),a,i,e[r+0],20,-373897302),n=h(n,a=h(a,i=h(i,s,n,a,e[r+5],5,-701558691),s,n,e[r+10],9,38016083),i,s,e[r+15],14,-660478335),a,i,e[r+4],20,-405537848),n=h(n,a=h(a,i=h(i,s,n,a,e[r+9],5,568446438),s,n,e[r+14],9,-1019803690),i,s,e[r+3],14,-187363961),a,i,e[r+8],20,1163531501),n=h(n,a=h(a,i=h(i,s,n,a,e[r+13],5,-1444681467),s,n,e[r+2],9,-51403784),i,s,e[r+7],14,1735328473),a,i,e[r+12],20,-1926607734),n=p(n,a=p(a,i=p(i,s,n,a,e[r+5],4,-378558),s,n,e[r+8],11,-2022574463),i,s,e[r+11],16,1839030562),a,i,e[r+14],23,-35309556),n=p(n,a=p(a,i=p(i,s,n,a,e[r+1],4,-1530992060),s,n,e[r+4],11,1272893353),i,s,e[r+7],16,-155497632),a,i,e[r+10],23,-1094730640),n=p(n,a=p(a,i=p(i,s,n,a,e[r+13],4,681279174),s,n,e[r+0],11,-358537222),i,s,e[r+3],16,-722521979),a,i,e[r+6],23,76029189),n=p(n,a=p(a,i=p(i,s,n,a,e[r+9],4,-640364487),s,n,e[r+12],11,-421815835),i,s,e[r+15],16,530742520),a,i,e[r+2],23,-995338651),n=f(n,a=f(a,i=f(i,s,n,a,e[r+0],6,-198630844),s,n,e[r+7],10,1126891415),i,s,e[r+14],15,-1416354905),a,i,e[r+5],21,-57434055),n=f(n,a=f(a,i=f(i,s,n,a,e[r+12],6,1700485571),s,n,e[r+3],10,-1894986606),i,s,e[r+10],15,-1051523),a,i,e[r+1],21,-2054922799),n=f(n,a=f(a,i=f(i,s,n,a,e[r+8],6,1873313359),s,n,e[r+15],10,-30611744),i,s,e[r+6],15,-1560198380),a,i,e[r+13],21,1309151649),n=f(n,a=f(a,i=f(i,s,n,a,e[r+4],6,-145523070),s,n,e[r+11],10,-1120210379),i,s,e[r+2],15,718787259),a,i,e[r+9],21,-343485551),i=g(i,l),s=g(s,o),n=g(n,d),a=g(a,u)}return Array(i,s,n,a)}function o(e,t,i,s,n,a){return g(function(e,t){return e<<t|e>>>32-t}(g(g(t,e),g(s,a)),n),i)}function c(e,t,i,s,n,a,r){return o(t&i|~t&s,e,t,n,a,r)}function h(e,t,i,s,n,a,r){return o(t&s|i&~s,e,t,n,a,r)}function p(e,t,i,s,n,a,r){return o(t^i^s,e,t,n,a,r)}function f(e,t,i,s,n,a,r){return o(i^(t|~s),e,t,n,a,r)}function g(e,t){var i=(65535&e)+(65535&t);return(e>>16)+(t>>16)+(i>>16)<<16|65535&i}return function(e){return i(t(s(e)))}(e)},transition:function(e,t,i,s){var n=g(e).width(),a=g(e).height();if(!e||!t)return void console.log("ERROR: Cannot do transition when one of the divs is null");switch(e.parentNode.style.cssText+="perspective: 900px; overflow: hidden;",e.style.cssText+="; position: absolute; z-index: 1019; backface-visibility: hidden",t.style.cssText+="; position: absolute; z-index: 1020; backface-visibility: hidden",i){case"slide-left":e.style.cssText+="overflow: hidden; transform: translate3d(0, 0, 0)",t.style.cssText+="overflow: hidden; transform: translate3d("+n+"px, 0, 0)",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: translate3d(0, 0, 0)",e.style.cssText+="transition: 0.5s; transform: translate3d(-"+n+"px, 0, 0)"},1);break;case"slide-right":e.style.cssText+="overflow: hidden; transform: translate3d(0, 0, 0)",t.style.cssText+="overflow: hidden; transform: translate3d(-"+n+"px, 0, 0)",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: translate3d(0px, 0, 0)",e.style.cssText+="transition: 0.5s; transform: translate3d("+n+"px, 0, 0)"},1);break;case"slide-down":e.style.cssText+="overflow: hidden; z-index: 1; transform: translate3d(0, 0, 0)",t.style.cssText+="overflow: hidden; z-index: 0; transform: translate3d(0, 0, 0)",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: translate3d(0, 0, 0)",e.style.cssText+="transition: 0.5s; transform: translate3d(0, "+a+"px, 0)"},1);break;case"slide-up":e.style.cssText+="overflow: hidden; transform: translate3d(0, 0, 0)",t.style.cssText+="overflow: hidden; transform: translate3d(0, "+a+"px, 0)",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: translate3d(0, 0, 0)",e.style.cssText+="transition: 0.5s; transform: translate3d(0, 0, 0)"},1);break;case"flip-left":e.style.cssText+="overflow: hidden; transform: rotateY(0deg)",t.style.cssText+="overflow: hidden; transform: rotateY(-180deg)",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: rotateY(0deg)",e.style.cssText+="transition: 0.5s; transform: rotateY(180deg)"},1);break;case"flip-right":e.style.cssText+="overflow: hidden; transform: rotateY(0deg)",t.style.cssText+="overflow: hidden; transform: rotateY(180deg)",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: rotateY(0deg)",e.style.cssText+="transition: 0.5s; transform: rotateY(-180deg)"},1);break;case"flip-down":e.style.cssText+="overflow: hidden; transform: rotateX(0deg)",t.style.cssText+="overflow: hidden; transform: rotateX(180deg)",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: rotateX(0deg)",e.style.cssText+="transition: 0.5s; transform: rotateX(-180deg)"},1);break;case"flip-up":e.style.cssText+="overflow: hidden; transform: rotateX(0deg)",t.style.cssText+="overflow: hidden; transform: rotateX(-180deg)",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: rotateX(0deg)",e.style.cssText+="transition: 0.5s; transform: rotateX(180deg)"},1);break;case"pop-in":e.style.cssText+="overflow: hidden; transform: translate3d(0, 0, 0)",t.style.cssText+="overflow: hidden; transform: translate3d(0, 0, 0); transform: scale(.8); opacity: 0;",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; transform: scale(1); opacity: 1;",e.style.cssText+="transition: 0.5s;"},1);break;case"pop-out":e.style.cssText+="overflow: hidden; transform: translate3d(0, 0, 0); transform: scale(1); opacity: 1;",t.style.cssText+="overflow: hidden; transform: translate3d(0, 0, 0); opacity: 0;",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; opacity: 1;",e.style.cssText+="transition: 0.5s; transform: scale(1.7); opacity: 0;"},1);break;default:e.style.cssText+="overflow: hidden; transform: translate3d(0, 0, 0)",t.style.cssText+="overflow: hidden; translate3d(0, 0, 0); opacity: 0;",g(t).show(),window.setTimeout(function(){t.style.cssText+="transition: 0.5s; opacity: 1;",e.style.cssText+="transition: 0.5s"},1)}setTimeout(function(){"slide-down"===i&&(g(e).css("z-index","1019"),g(t).css("z-index","1020")),t&&g(t).css({opacity:"1"}).css(w2utils.cssPrefix({transition:"",transform:""})),e&&g(e).css({opacity:"1"}).css(w2utils.cssPrefix({transition:"",transform:""})),"function"==typeof s&&s()},500)},lock:function(e,t,i){var s={};"object"==typeof t?s=t:(s.msg=t,s.spinner=i);s.msg||0===s.msg||(s.msg="");w2utils.unlock(e),g(e).prepend('<div class="w2ui-lock"></div><div class="w2ui-lock-msg"></div>');var n=g(e).find(".w2ui-lock"),a=g(e).find(".w2ui-lock-msg");s.msg||a.css({"background-color":"transparent",border:"0px"});!0===s.spinner&&(s.msg='<div class="w2ui-spinner" '+(s.msg?"":'style="width: 35px; height: 35px"')+"></div>"+s.msg);null!=s.opacity&&n.css("opacity",s.opacity);"function"==typeof n.fadeIn?(n.fadeIn(200),a.html(s.msg).fadeIn(200)):(n.show(),a.html(s.msg).show(0))},unlock:function(e,t){h(t)?(g(e).find(".w2ui-lock").fadeOut(t),setTimeout(function(){g(e).find(".w2ui-lock").remove(),g(e).find(".w2ui-lock-msg").remove()},t)):(g(e).find(".w2ui-lock").remove(),g(e).find(".w2ui-lock-msg").remove())},message:function(s,e){var t,n,a=this;g().w2tag(),e=e||{width:200,height:100};null==e.on&&g.extend(e,w2utils.event);null==e.width&&(e.width=200);null==e.height&&(e.height=100);var i=parseInt(g(s.box).width()),r=parseInt(g(s.box).height()),l=parseInt(g(s.box).find(s.title).css("height")||0);e.width>i&&(e.width=i-10);e.height>r-l&&(e.height=r-10-l);e.originalWidth=e.width,e.originalHeight=e.height,parseInt(e.width)<0&&(e.width=i+e.width);parseInt(e.width)<10&&(e.width=10);parseInt(e.height)<0&&(e.height=r+e.height-l);parseInt(e.height)<10&&(e.height=10);null==e.hideOnClick&&(e.hideOnClick=!1);var o=g(s.box).data("options")||{};(null==e.width||e.width>o.width-10)&&(e.width=o.width-10);(null==e.height||e.height>o.height-l-5)&&(e.height=o.height-l-5);e.originalHeight<0&&(e.height=r+e.originalHeight-l);e.originalWidth<0&&(e.width=i+2*e.originalWidth);var d=g(s.box).find(s.title),u=g(s.box).find(".w2ui-message.w2ui-closing");0<g(s.box).find(".w2ui-message.w2ui-closing").length&&(clearTimeout(t),f(u,u.data("options")||{}));var c=g(s.box).find(".w2ui-message").length;if(""===g.trim(e.html)&&""===g.trim(e.body)&&""===g.trim(e.buttons)){if(0===c)return;var h=g(s.box).find("#w2ui-message"+(c-1));e=h.data("options")||{};if(!0===(n=e.trigger({phase:"before",type:"close",target:"self"})).isCancelled)return;h.css(w2utils.cssPrefix({transition:"0.15s",transform:"translateY(-"+e.height+"px)"})).addClass("w2ui-closing"),1===c?this.unlock&&(s.param?this.unlock(s.param,150):this.unlock(150)):g(s.box).find("#w2ui-message"+(c-2)).css("z-index",1500),t=setTimeout(function(){f(h,e)},150)}else{""===g.trim(e.body)&&""===g.trim(e.buttons)||(e.html='<div class="w2ui-message-body">'+(e.body||"")+'</div><div class="w2ui-message-buttons">'+(e.buttons||"")+"</div>"),g(s.box).find(".w2ui-message").css("z-index",1390),d.data("old-z-index",d.css("z-index")),d.css("z-index",1501),g(s.box).find(s.body).before('<div id="w2ui-message'+c+'" onmousedown="event.stopPropagation();"    class="w2ui-message" style="display: none; z-index: 1500; '+(0===d.length?"top: 0px;":"top: "+w2utils.getSize(d,"height")+"px;")+(null!=e.width?"width: "+e.width+"px; left: "+(i-e.width)/2+"px;":"left: 10px; right: 10px;")+(null!=e.height?"height: "+e.height+"px;":"bottom: 6px;")+w2utils.cssPrefix("transition",".3s",!0)+'"'+(!0===e.hideOnClick?s.param?'onclick="'+s.path+".message('"+s.param+"');\"":'onclick="'+s.path+'.message();"':"")+"></div>"),g(s.box).find("#w2ui-message"+c).data("options",e).data("prev_focus",g(":focus"));var p=g(s.box).find("#w2ui-message"+c).css("display");if(g(s.box).find("#w2ui-message"+c).css(w2utils.cssPrefix({transform:"none"===p?"translateY(-"+e.height+"px)":"translateY(0px)"})),"none"===p){if(g(s.box).find("#w2ui-message"+c).show().html(e.html),e.box=g(s.box).find("#w2ui-message"+c),!0===(n=e.trigger({phase:"before",type:"open",target:"self"})).isCancelled)return d.css("z-index",d.data("old-z-index")),void g(s.box).find("#w2ui-message"+c).remove();setTimeout(function(){g(s.box).find("#w2ui-message"+c).css(w2utils.cssPrefix({transform:"none"===p?"translateY(0px)":"translateY(-"+e.height+"px)"}))},1),0===c&&this.lock&&(s.param?this.lock(s.param):this.lock()),setTimeout(function(){g(s.box).find("#w2ui-message"+c).css(w2utils.cssPrefix({transition:"0s"})),e.trigger(g.extend(n,{phase:"after"}))},350)}}function f(e,t){if(null==n&&!0===(n=t.trigger({phase:"before",type:"open",target:"self"})).isCancelled)return d.css("z-index",d.data("old-z-index")),void g(s.box).find("#w2ui-message"+c).remove();var i=e.data("prev_focus");e.remove(),i&&0<i.length?i.focus():a&&a.focus&&a.focus(),d.css("z-index",d.data("old-z-index")),t.trigger(g.extend(n,{phase:"after"}))}},naturalCompare:function(e,t){var s,i,n=1,a=0,r=0,l=String.alphabet;function o(e,t,i){if(i){for(s=t;(i=o(e,s))<76&&65<i;)++s;return+e.slice(t-1,s)}return-1<(i=l&&l.indexOf(e.charAt(t)))?i+76:(i=e.charCodeAt(t)||0)<45||127<i?i:i<46?65:i<48?i-1:i<58?i+18:i<65?i-11:i<91?i+11:i<97?i-37:i<123?i+5:i-63}if((e+="")!=(t+=""))for(;n;)if(i=o(e,a++),n=o(t,r++),i<76&&n<76&&66<i&&66<n&&(i=o(e,a,a),n=o(t,r,a=s),r=s),i!=n)return i<n?-1:1;return 0},lang:function(e){var t=this.settings.phrases[e];return null==t?e:t},locale:function(s,n){s=s||"en-us";if("string"!=typeof s)return void(w2utils.settings=g.extend(!0,w2utils.settings,s));5===s.length&&(s="locale/"+s+".json");w2utils.settings.phrases={},g.ajax({url:s,type:"GET",dataType:"JSON",success:function(e,t,i){w2utils.settings=g.extend(!0,w2utils.settings,e),"function"==typeof n&&n()},error:function(e,t,i){console.log("ERROR: Cannot load locale "+s)}})},getSize:function(e,t){var i=g(e),s={left:parseInt(i.css("border-left-width"))||0,right:parseInt(i.css("border-right-width"))||0,top:parseInt(i.css("border-top-width"))||0,bottom:parseInt(i.css("border-bottom-width"))||0},n={left:parseInt(i.css("margin-left"))||0,right:parseInt(i.css("margin-right"))||0,top:parseInt(i.css("margin-top"))||0,bottom:parseInt(i.css("margin-bottom"))||0},a={left:parseInt(i.css("padding-left"))||0,right:parseInt(i.css("padding-right"))||0,top:parseInt(i.css("padding-top"))||0,bottom:parseInt(i.css("padding-bottom"))||0};switch(t){case"top":return s.top+n.top+a.top;case"bottom":return s.bottom+n.bottom+a.bottom;case"left":return s.left+n.left+a.left;case"right":return s.right+n.right+a.right;case"width":return s.left+s.right+n.left+n.right+a.left+a.right+parseInt(i.width());case"height":return s.top+s.bottom+n.top+n.bottom+a.top+a.bottom+parseInt(i.height());case"+width":return s.left+s.right+n.left+n.right+a.left+a.right;case"+height":return s.top+s.bottom+n.top+n.bottom+a.top+a.bottom}return 0},getStrWidth:function(e,t){var i,s='<div id="_tmp_width" style="position: absolute; top: -900px;'+(t||"")+'">'+n(e)+"</div>";return g("body").append(s),i=g("#_tmp_width").width(),g("#_tmp_width").remove(),i},scrollBarSize:function(){if(e.scrollBarSize)return e.scrollBarSize;g("body").append('<div id="_scrollbar_width" style="position: absolute; top: -300px; width: 100px; height: 100px; overflow-y: scroll;">    <div style="height: 120px">1</div></div>'),e.scrollBarSize=100-g("#_scrollbar_width > div").width(),g("#_scrollbar_width").remove(),0<=String(navigator.userAgent).indexOf("MSIE")&&(e.scrollBarSize=e.scrollBarSize/2);return e.scrollBarSize},checkName:function(e,t){return e&&null!=e.name?null==w2ui[e.name]?!!w2utils.isAlphaNumeric(e.name)||(console.log('ERROR: The parameter "name" has to be alpha-numeric (a-z, 0-9, dash and underscore). '),!1):(console.log('ERROR: The parameter "name" is not unique. There are other objects already created with the same name (obj: '+e.name+")."),!1):(console.log('ERROR: The parameter "name" is required but not supplied in $().'+t+"()."),!1)},checkUniqueId:function(e,t,i,s){g.isArray(t)||(t=[t]);for(var n=0;n<t.length;n++)if(t[n].id===e)return console.log('ERROR: The parameter "id='+e+'" is not unique within the current '+i+". (obj: "+s+")"),!1;return!0},parseRoute:function(e){var r=[],t=e.replace(/\/\(/g,"(?:/").replace(/\+/g,"__plus__").replace(/(\/)?(\.)?:(\w+)(?:(\(.*?\)))?(\?)?/g,function(e,t,i,s,n,a){return r.push({name:s,optional:!!a}),t=t||"",(a?"":t)+"(?:"+(a?t:"")+(i||"")+(n||(i?"([^/.]+?)":"([^/]+?)"))+")"+(a||"")}).replace(/([\/.])/g,"\\$1").replace(/__plus__/g,"(.+)").replace(/\*/g,"(.*)");return{path:new RegExp("^"+t+"$","i"),keys:r}},cssPrefix:function(e,t,i){var s={},n={},a="";g.isPlainObject(e)?(s=e,!0===t&&(i=!0)):s[e]=t;for(var r in s)n[r]=s[r],n["-webkit-"+r]=s[r],n["-moz-"+r]=s[r].replace("-webkit-","-moz-"),n["-ms-"+r]=s[r].replace("-webkit-","-ms-"),n["-o-"+r]=s[r].replace("-webkit-","-o-");if(!0===i)for(var r in n)a+=r+": "+n[r]+"; ";else a=n;return a},parseColor:function(e){{if("string"!=typeof e)return null;e=e.trim().toUpperCase()}"#"===e[0]&&(e=e.substr(1));var t={};if(3===e.length)t={r:parseInt(e[0]+e[0],16),g:parseInt(e[1]+e[1],16),b:parseInt(e[2]+e[2],16),a:1};else if(6===e.length)t={r:parseInt(e.substr(0,2),16),g:parseInt(e.substr(2,2),16),b:parseInt(e.substr(4,2),16),a:1};else if(4<e.length&&"RGB("===e.substr(0,4)){var i=e.replace("RGB","").replace(/\(/g,"").replace(/\)/g,"").split(",");t={r:parseInt(i[0],10),g:parseInt(i[1],10),b:parseInt(i[2],10),a:1}}else{if(!(5<e.length&&"RGBA("===e.substr(0,5)))return null;i=e.replace("RGBA","").replace(/\(/g,"").replace(/\)/g,"").split(",");t={r:parseInt(i[0],10),g:parseInt(i[1],10),b:parseInt(i[2],10),a:parseFloat(i[3])}}return t},hsv2rgb:function(e,t,i,s){var n,a,r,l,o,d,u,c;1===arguments.length&&(t=e.s,i=e.v,s=e.a,e=e.h);switch(e/=360,t/=100,i/=100,l=Math.floor(6*e),d=i*(1-t),u=i*(1-(o=6*e-l)*t),c=i*(1-(1-o)*t),l%6){case 0:n=i,a=c,r=d;break;case 1:n=u,a=i,r=d;break;case 2:n=d,a=i,r=c;break;case 3:n=d,a=u,r=i;break;case 4:n=c,a=d,r=i;break;case 5:n=i,a=d,r=u}return{r:Math.round(255*n),g:Math.round(255*a),b:Math.round(255*r),a:null!=s?s:1}},rgb2hsv:function(e,t,i,s){1===arguments.length&&(t=e.g,i=e.b,s=e.a,e=e.r);var n,a=Math.max(e,t,i),r=Math.min(e,t,i),l=a-r,o=0===a?0:l/a,d=a/255;switch(a){case r:n=0;break;case e:n=t-i+l*(t<i?6:0),n/=6*l;break;case t:n=i-e+2*l,n/=6*l;break;case i:n=e-t+4*l,n/=6*l}return{h:Math.round(360*n),s:Math.round(100*o),v:Math.round(100*d),a:null!=s?s:1}},getCursorPosition:function(e){if(null==e)return null;var t,i=0,s=e.ownerDocument||e.document,n=s.defaultView||s.parentWindow;if(e.tagName&&"INPUT"===e.tagName.toUpperCase()&&e.selectionStart)i=e.selectionStart;else if(n.getSelection){if(0<(t=n.getSelection()).rangeCount){var a=t.getRangeAt(0),r=a.cloneRange();r.selectNodeContents(e),r.setEnd(a.endContainer,a.endOffset),i=r.toString().length}}else if((t=s.selection)&&"Control"!==t.type){var l=t.createRange(),o=s.body.createTextRange();o.moveToElementText(e),o.setEndPoint("EndToEnd",l),i=o.text.length}return i},setCursorPosition:function(e,t,i){var s,n=document.createRange(),a=window.getSelection();if(null==e)return;for(var r=0;r<e.childNodes.length;r++){var l=g(e.childNodes[r]).text();if(e.childNodes[r].tagName&&(l=(l=g(e.childNodes[r]).html()).replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&amp;/g,"&").replace(/&quot;/g,'"').replace(/&nbsp;/g," ")),t<=l.length){(s=e.childNodes[r]).childNodes&&0<s.childNodes.length&&(s=s.childNodes[0]),s.childNodes&&0<s.childNodes.length&&(s=s.childNodes[0]);break}t-=l.length}if(null==s)return;t>s.length&&(t=s.length);n.setStart(s,t),i?n.setEnd(s,i):n.collapse(!0);a.removeAllRanges(),a.addRange(n)},testLocalStorage:t,hasLocalStorage:t(),isIOS:-1!==navigator.userAgent.toLowerCase().indexOf("iphone")||-1!==navigator.userAgent.toLowerCase().indexOf("ipod")||-1!==navigator.userAgent.toLowerCase().indexOf("ipad")||-1!==navigator.userAgent.toLowerCase().indexOf("mobile")||-1!==navigator.userAgent.toLowerCase().indexOf("android"),isIE:-1!==navigator.userAgent.toLowerCase().indexOf("msie")||-1!==navigator.userAgent.toLowerCase().indexOf("trident")};function h(e){return/^[-+]?[0-9]+$/.test(e)}function n(e){if(null==e)return e;switch(typeof e){case"number":break;case"string":e=String(e).replace(/&/g,"&amp;").replace(/>/g,"&gt;").replace(/</g,"&lt;").replace(/"/g,"&quot;");break;case"object":if(Array.isArray(e)){e=g.extend(!0,[],e);for(var t=0;t<e.length;t++)e[t]=this.encodeTags(e[t])}else for(var t in e=g.extend(!0,{},e))e[t]=this.encodeTags(e[t])}return e}function t(){var e="w2ui_test";try{return localStorage.setItem(e,e),localStorage.removeItem(e),!0}catch(e){return!1}}}(jQuery);w2utils.formatters={number:function(e,t){return 20<parseInt(t)&&(t=20),parseInt(t)<0&&(t=0),null==e||""===e?"":w2utils.formatNumber(parseFloat(e),t,!0)},float:function(e,t){return w2utils.formatters.number(e,t)},int:function(e,t){return w2utils.formatters.number(e,0)},money:function(e,t){if(null==e||""===e)return"";var i=w2utils.formatNumber(Number(e),w2utils.settings.currencyPrecision||2);return(w2utils.settings.currencyPrefix||"")+i+(w2utils.settings.currencySuffix||"")},currency:function(e,t){return w2utils.formatters.money(e,t)},percent:function(e,t){return null==e||""===e?"":w2utils.formatNumber(e,t||1)+"%"},size:function(e,t){return null==e||""===e?"":w2utils.formatSize(parseInt(e))},date:function(e,t){if(""===t&&(t=w2utils.settings.dateFormat),null==e||0===e||""===e)return"";var i=w2utils.isDateTime(e,t,!0);return!1===i&&(i=w2utils.isDate(e,t,!0)),'<span title="'+i+'">'+w2utils.formatDate(i,t)+"</span>"},datetime:function(e,t){if(""===t&&(t=w2utils.settings.datetimeFormat),null==e||0===e||""===e)return"";var i=w2utils.isDateTime(e,t,!0);return!1===i&&(i=w2utils.isDate(e,t,!0)),'<span title="'+i+'">'+w2utils.formatDateTime(i,t)+"</span>"},time:function(e,t){if(""===t&&(t=w2utils.settings.timeFormat),"h12"===t&&(t="hh:mi pm"),"h24"===t&&(t="h24:mi"),null==e||0===e||""===e)return"";var i=w2utils.isDateTime(e,t,!0);return!1===i&&(i=w2utils.isDate(e,t,!0)),'<span title="'+i+'">'+w2utils.formatTime(e,t)+"</span>"},timestamp:function(e,t){if(""===t&&(t=w2utils.settings.datetimeFormat),null==e||0===e||""===e)return"";var i=w2utils.isDateTime(e,t,!0);return!1===i&&(i=w2utils.isDate(e,t,!0)),i.toString?i.toString():""},gmt:function(e,t){if(""===t&&(t=w2utils.settings.datetimeFormat),null==e||0===e||""===e)return"";var i=w2utils.isDateTime(e,t,!0);return!1===i&&(i=w2utils.isDate(e,t,!0)),i.toUTCString?i.toUTCString():""},age:function(e,t){if(null==e||0===e||""===e)return"";var i=w2utils.isDateTime(e,null,!0);return!1===i&&(i=w2utils.isDate(e,null,!0)),'<span title="'+i+'">'+w2utils.age(e)+(t?" "+t:"")+"</span>"},interval:function(e,t){return null==e||0===e||""===e?"":w2utils.interval(e)+(t?" "+t:"")},toggle:function(e,t){return e?"Yes":""},password:function(e,t){for(var i="",s=0;s<e.length;s++)i+="*";return i}},w2utils.event={on:function(e,t){var i,s=jQuery;"string"==typeof e&&-1!==e.indexOf(".")&&(e=(n=e.split("."))[0],i=n[1]);if("string"==typeof e&&-1!==e.indexOf(":")){var n=e.split(":");-1!==["complete","done"].indexOf(e[1])&&(e[1]="after"),e={type:n[0],execute:n[1]}}s.isPlainObject(e)||(e={type:e,scope:i}),(e=s.extend({type:null,execute:"before",target:null,onComplete:null},e)).type?t?(s.isArray(this.handlers)||(this.handlers=[]),this.handlers.push({edata:e,handler:t})):console.log("ERROR: You must specify event handler function when calling .on() method of "+this.name):console.log("ERROR: You must specify event type when calling .on() method of "+this.name)},off:function(e,t){var i,s=jQuery;"string"==typeof e&&-1!==e.indexOf(".")&&(e=(n=e.split("."))[0],i=n[1]);if("string"==typeof e&&-1!==e.indexOf(":")){var n=e.split(":");-1!==["complete","done"].indexOf(e[1])&&(e[1]="after"),e={type:n[0],execute:n[1]}}if(s.isPlainObject(e)||(e={type:e}),(e=s.extend({},{type:null,execute:"before",target:null,onComplete:null},e)).type||i){t=t||null;for(var a=[],r=0,l=this.handlers.length;r<l;r++){var o=this.handlers[r];(o.edata.type!==e.type&&"*"!==e.type&&(null==o.edata.scope||""!=e.type)||o.edata.target!==e.target&&null!=e.target||o.edata.execute!==e.execute&&null!=e.execute||!(o.handler===t&&null!=t||null!=i&&o.edata.scope==i))&&a.push(o)}this.handlers=a}else console.log("ERROR: You must specify event type when calling .off() method of "+this.name)},trigger:function(e){var t,i,s,n=jQuery;"before"===(e=n.extend({type:null,phase:"before",target:null,doneHandlers:[]},e,{isStopped:!1,isCancelled:!1,done:function(e){this.doneHandlers.push(e)},preventDefault:function(){this.isCancelled=!0},stopPropagation:function(){this.isStopped=!0}})).phase&&(e.onComplete=null),null==e.target&&(e.target=null),n.isArray(this.handlers)||(this.handlers=[]);for(var a=this.handlers.length-1;0<=a;a--){var r=this.handlers[a];if(!(r.edata.type!==e.type&&"*"!==r.edata.type||r.edata.target!==e.target&&null!=r.edata.target||r.edata.execute!==e.phase&&"*"!==r.edata.execute&&"*"!==r.edata.phase)&&(e=n.extend({},r.edata,e),t=[],(s=new RegExp(/\((.*?)\)/).exec(r.handler))&&(t=s[1].split(/\s*,\s*/)),2===t.length?r.handler.call(this,e.target,e):r.handler.call(this,e),!0===e.isStopped||!0===e.stop))return e}var l="on"+e.type.substr(0,1).toUpperCase()+e.type.substr(1);if("before"===e.phase&&"function"==typeof this[l]&&(i=this[l],t=[],(s=new RegExp(/\((.*?)\)/).exec(i))&&(t=s[1].split(/\s*,\s*/)),2===t.length?i.call(this,e.target,e):i.call(this,e),!0===e.isStopped||!0===e.stop))return e;if(null!=e.object&&"before"===e.phase&&"function"==typeof e.object[l]&&(i=e.object[l],t=[],(s=new RegExp(/\((.*?)\)/).exec(i))&&(t=s[1].split(/\s*,\s*/)),2===t.length?i.call(this,e.target,e):i.call(this,e),!0===e.isStopped||!0===e.stop))return e;if("after"===e.phase){"function"==typeof e.onComplete&&e.onComplete.call(this,e);for(var o=0;o<e.doneHandlers.length;o++)"function"==typeof e.doneHandlers[o]&&e.doneHandlers[o].call(this,e)}return e}},function(_){_.fn.w2render=function(e){0<_(this).length&&("string"==typeof e&&w2ui[e]&&w2ui[e].render(_(this)[0]),"object"==typeof e&&e.render(_(this)[0]))},_.fn.w2destroy=function(e){!e&&0<this.length&&(e=this.attr("name")),"string"==typeof e&&w2ui[e]&&w2ui[e].destroy(),"object"==typeof e&&e.destroy()},_.fn.w2marker=function(){var r=Array.prototype.slice.call(arguments,0);return Array.isArray(r[0])&&(r=r[0]),0!==r.length&&r[0]?_(this).each(function(e,t){l(e,t);for(var i=0;i<r.length;i++){var s=r[i];"string"!=typeof s&&(s=String(s)),s=s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&").replace(/&/g,"&amp;").replace(/</g,"&gt;").replace(/>/g,"&lt;");var n=new RegExp(s+"(?!([^<]+)?>)","gi");t.innerHTML=t.innerHTML.replace(n,a)}function a(e){return'<span class="w2ui-marker">'+e+"</span>"}}):_(this).each(l);function l(e,t){for(;-1!==t.innerHTML.indexOf('<span class="w2ui-marker">');)t.innerHTML=t.innerHTML.replace(/\<span class=\"w2ui\-marker\"\>((.|\n|\r)*)\<\/span\>/gi,"$1")}},_.fn.w2tag=function(l,o){if(1===arguments.length&&"object"==typeof l&&null!=(o=l).html&&(l=o.html),null!=(o=_.extend({id:null,html:l,position:"right|top",align:"none",left:0,top:0,style:"",css:{},className:"",inputClass:"",onShow:null,onHide:null,hideOnKeyPress:!0,hideOnFocus:!1,hideOnBlur:!1,hideOnClick:!1,hideOnChange:!0},o)).name&&null==o.id&&(o.id=o.name),""!==o.class&&""===o.inputClass&&(o.inputClass=o.class),0!==_(this).length)return _(this).each(function(e,t){var c,i=o.id?o.id:t.id;""==i&&(i=_(t).find("input").attr("id")),i=i||"noid";var s=w2utils.escapeId(i);return null!=_(this).data("w2tag")?(c=_(this).data("w2tag"),_.extend(c.options,o)):c={id:i,attachedTo:t,box:_("#w2ui-tag-"+s),options:_.extend({},o),init:n,hide:function(){if(c.box.length<=0)return;c.tmp.timer&&clearTimeout(c.tmp.timer);c.box.remove(),c.options.hideOnClick&&_("body").off(".w2tag"+(c.id||""));_(c.attachedTo).off(".w2tag").removeClass(c.options.inputClass).removeData("w2tag"),0<_(c.attachedTo).length&&(_(c.attachedTo)[0].style.cssText=c.tmp.originalCSS);"function"==typeof c.options.onHide&&c.options.onHide()},getPos:r,isMoved:a,tmp:{}},void(""===l||null==l?c.hide():0!==c.box.length?c.box.find(".w2ui-tag-body").css(c.options.css).attr("style",c.options.style).addClass(c.options.className).html(c.options.html):(c.tmp.originalCSS="",0<_(c.attachedTo).length&&(c.tmp.originalCSS=_(c.attachedTo)[0].style.cssText),_("body").append('<div onclick="event.stopPropagation()" style="display: none;" id="w2ui-tag-'+c.id+'"        class="w2ui-tag '+(0<_(c.attachedTo).parents(".w2ui-popup, .w2ui-overlay-popup, .w2ui-message").length?"w2ui-tag-popup":"")+'">   <div style="margin: -2px 0px 0px -2px; white-space: nowrap;">      <div class="w2ui-tag-body '+c.options.className+'" style="'+(c.options.style||"")+'">'+l+"</div>   </div></div>"),c.box=_("#w2ui-tag-"+s),_(c.attachedTo).data("w2tag",c),setTimeout(n,1)));function n(){if(c.box.css("display","block"),c&&c.box&&_(c.attachedTo).offset()){var e=c.getPos();c.box.css({opacity:"1",left:e.left+"px",top:e.top+"px"}).data("w2tag",c).find(".w2ui-tag-body").addClass(e.posClass),c.tmp.pos=e.left+"x"+e.top,_(c.attachedTo).off(".w2tag").css(c.options.css).addClass(c.options.inputClass),c.options.hideOnKeyPress&&_(c.attachedTo).on("keypress.w2tag",c.hide),c.options.hideOnFocus&&_(c.attachedTo).on("focus.w2tag",c.hide),o.hideOnChange&&("INPUT"===t.nodeName?_(t).on("change.w2tag",c.hide):_(t).find("input").on("change.w2tag",c.hide)),c.options.hideOnBlur&&_(c.attachedTo).on("blur.w2tag",c.hide),c.options.hideOnClick&&_("body").on("click.w2tag"+(c.id||""),c.hide),"function"==typeof c.options.onShow&&c.options.onShow(),a()}}function a(e){var t=_(c.attachedTo).offset();if(0===_(c.attachedTo).length||0===t.left&&0===t.top||0===c.box.find(".w2ui-tag-body").length)c.hide();else{var i=r();c.tmp.pos!==i.left+"x"+i.top&&(c.box.css(w2utils.cssPrefix({transition:e?"0s":".2s"})).css({left:i.left+"px",top:i.top+"px"}),c.tmp.pos=i.left+"x"+i.top),c.tmp.timer&&clearTimeout(c.tmp.timer),c.tmp.timer=setTimeout(a,100)}}function r(){var e=_(c.attachedTo).offset(),t="w2ui-tag-right",i=parseInt(e.left+c.attachedTo.offsetWidth+(c.options.left?c.options.left:0)),s=parseInt(e.top+(c.options.top?c.options.top:0)),n=c.box.find(".w2ui-tag-body"),a=n[0].offsetWidth,r=n[0].offsetHeight;if("string"==typeof c.options.position&&-1!==c.options.position.indexOf("|")&&(c.options.position=c.options.position.split("|")),"top"===c.options.position)t="w2ui-tag-top",i=parseInt(e.left+(c.options.left?c.options.left:0))-14,s=parseInt(e.top+(c.options.top?c.options.top:0))-r-10;else if("bottom"===c.options.position)t="w2ui-tag-bottom",i=parseInt(e.left+(c.options.left?c.options.left:0))-14,s=parseInt(e.top+c.attachedTo.offsetHeight+(c.options.top?c.options.top:0))+10;else if("left"===c.options.position)t="w2ui-tag-left",i=parseInt(e.left+(c.options.left?c.options.left:0))-a-20,s=parseInt(e.top+(c.options.top?c.options.top:0));else if(Array.isArray(c.options.position)){for(var l=window.innerWidth,o=window.innerHeight,d=0;d<c.options.position.length;d++){var u=c.options.position[d];if("right"===u){if(t="w2ui-tag-right",i=parseInt(e.left+c.attachedTo.offsetWidth+(c.options.left?c.options.left:0)),s=parseInt(e.top+(c.options.top?c.options.top:0)),i+a<=l)break}else if("left"===u){if(t="w2ui-tag-left",i=parseInt(e.left+(c.options.left?c.options.left:0))-a-20,s=parseInt(e.top+(c.options.top?c.options.top:0)),0<=i)break}else if("top"===u){if(t="w2ui-tag-top",i=parseInt(e.left+(c.options.left?c.options.left:0))-14,s=parseInt(e.top+(c.options.top?c.options.top:0))-r-10,i+a<=l&&0<=s)break}else if("bottom"===u&&(t="w2ui-tag-bottom",i=parseInt(e.left+(c.options.left?c.options.left:0))-14,s=parseInt(e.top+c.attachedTo.offsetHeight+(c.options.top?c.options.top:0))+10,i+a<=l&&s+r<=o))break}n.data("posClass")!==t&&n.removeClass("w2ui-tag-right w2ui-tag-left w2ui-tag-top w2ui-tag-bottom").addClass(t).data("posClass",t)}return{left:i,top:s,posClass:t}}});_(".w2ui-tag").each(function(e,t){var i=_(t).data("w2tag");i&&i.hide()})},_.fn.w2overlay=function(e,v){var t,y=this,b="";if(1===arguments.length&&(v="object"==typeof e?e:{html:e}),2===arguments.length&&(v.html=e),_.isPlainObject(v)||(v={}),(v=_.extend({},{name:null,html:"",align:"none",left:0,top:0,tipLeft:30,noTip:!1,selectable:!1,width:0,height:0,maxWidth:null,maxHeight:null,contextMenu:!1,pageX:null,pageY:null,originalEvent:null,style:"",class:"",overlayStyle:"",onShow:null,onHide:null,openAbove:!1,tmp:{}},v)).name&&(b="-"+v.name),0===this.length||""===v.html||null==v.html)return 0<_("#w2ui-overlay"+b).length?"function"==typeof(t=_("#w2ui-overlay"+b)[0].hide)&&t():_("#w2ui-overlay"+b).remove(),_(this);0<_("#w2ui-overlay"+b).length&&(t=_("#w2ui-overlay"+b)[0].hide,_(document).off(".w2overlay"+b),"function"==typeof t&&t()),0<y.length&&(null==y[0].tagName||"BODY"===y[0].tagName.toUpperCase())&&(v.contextMenu=!0),v.contextMenu&&v.originalEvent&&(v.pageX=v.originalEvent.pageX,v.pageY=v.originalEvent.pageY),!v.contextMenu||null!=v.pageX&&null!=v.pageY||console.log("ERROR: to display menu at mouse location, pass options.pageX and options.pageY."),_("body").append('<div id="w2ui-overlay'+b+'" style="display: none; left: 0px; top: 0px; '+v.overlayStyle+'"        class="w2ui-reset w2ui-overlay '+(0<_(this).parents(".w2ui-popup, .w2ui-overlay-popup, .w2ui-message").length?"w2ui-overlay-popup":"")+'">    <style></style>    <div style="min-width: 100%; '+v.style+'" class="'+v.class+'"></div></div>');var i=_("#w2ui-overlay"+b),s=i.find(" > div");s.html(v.html);var n=s.css("background-color");null!=n&&"rgba(0, 0, 0, 0)"!==n&&"transparent"!==n&&i.css({"background-color":n,"border-color":n});var a=_(y).offset()||{};return i.data("element",0<y.length?y[0]:null).data("options",v).data("position",a.left+"x"+a.top).fadeIn("fast").on("click",function(e){_("#w2ui-overlay"+b).data("keepOpen",!0),"LABEL"===e.target.tagName.toUpperCase()&&e.stopPropagation()}).on("mousedown",function(e){var t=e.target.tagName.toUpperCase();-1!==["INPUT","TEXTAREA","SELECT"].indexOf(t)||v.selectable||e.preventDefault()}),i[0].hide=r,i[0].resize=x,setTimeout(function(){_(document).off(".w2overlay"+b).on("click.w2overlay"+b,r),"function"==typeof v.onShow&&v.onShow(),x()},10),function e(){var t=_("#w2ui-overlay"+b);if(t.data("element")!==y[0])return;if(0===t.length)return;var i=_(y).offset()||{};var s=i.left+"x"+i.top;t.data("position")!==s?r():setTimeout(e,250)}(),_(this);function r(e){if(!e||0===e.button){var t,i=_("#w2ui-overlay"+b);if(!e||_(_(e.target).closest(".w2ui-overlay").data("element")).closest(".w2ui-overlay")[0]!==i[0])if(!0!==i.data("keepOpen"))"function"==typeof v.onHide&&(t=v.onHide()),!1!==t&&(i.remove(),_(document).off(".w2overlay"+b),clearInterval(i.data("timer")));else i.removeData("keepOpen")}}function x(){var e=_("#w2ui-overlay"+b),t=e.find(" > div"),i=_("#w2ui-overlay"+b+" div.w2ui-menu"),s={};if(0<i.length&&(i.css("overflow-y","hidden"),s.scrollTop=i.scrollTop(),s.scrollLeft=i.scrollLeft()),0<e.length){t.height("auto").width("auto");var n=!1,a=t.height(),r=t.width();v.width&&v.width<r&&(r=v.width),r<30&&(r=30),v.tmp.contentHeight&&(a=parseInt(v.tmp.contentHeight),t.height(a),setTimeout(function(){var e=t.find("div.w2ui-menu");a>e.height()&&t.find("div.w2ui-menu").css("overflow-y","hidden")},1),setTimeout(function(){var e=t.find("div.w2ui-menu");"auto"!==e.css("overflow-y")&&e.css("overflow-y","auto")},10)),v.tmp.contentWidth&&"both"!==v.align?(r=parseInt(v.tmp.contentWidth),t.width(r),setTimeout(function(){r>t.find("div.w2ui-menu > table").width()&&t.find("div.w2ui-menu > table").css("overflow-x","hidden")},1),setTimeout(function(){t.find("div.w2ui-menu > table").css("overflow-x","auto")},10)):t.find("div.w2ui-menu").css("width","100%");var l=v.left,o=v.width,d=v.tipLeft;switch(v.align){case"both":l=17,0===v.width&&(v.width=w2utils.getSize(_(y),"width")),v.maxWidth&&v.width>v.maxWidth&&(v.width=v.maxWidth);break;case"left":l=17;break;case"right":l=w2utils.getSize(_(y),"width")-r+10,d=r-40}o=30!==r||o?v.width?v.width:"auto":30;var u,c,h,p=(r-17)/2;if("auto"!==o&&(p=(o-17)/2),p<25&&(l=25-p,d=Math.floor(p)),v.contextMenu)u=v.pageX+8,c=v.pageY-0,h=v.pageY;else u=(25<(g=y.offset()||{}).left?g.left:25)+l,c=g.top+w2utils.getSize(y,"height")+v.top+7,h=g.top;e.css({left:u+"px",top:c+"px","min-width":o,"min-height":v.height?v.height:"auto"});var f,g=t.offset()||{},m=window.innerHeight+_(document).scrollTop()-g.top-7,w=window.innerWidth+_(document).scrollLeft()-g.left-7;if(v.contextMenu&&(m=window.innerHeight+_(document).scrollTop()-v.pageY-15,w=window.innerWidth+_(document).scrollLeft()-v.pageX),-50<m&&m<210||!0===v.openAbove)f=v.contextMenu?(m=v.pageY-7,5):(m=g.top-_(document).scrollTop()-7,24),v.maxHeight&&m>v.maxHeight&&(m=v.maxHeight),m<a&&(n=!0,t.height(m).width(r).css({"overflow-y":"auto"}),a=m),e.addClass("bottom-arrow"),e.css("top",h-a-f+v.top+"px"),e.find(">style").html("#w2ui-overlay"+b+":before { margin-left: "+parseInt(d)+"px; }#w2ui-overlay"+b+":after { margin-left: "+parseInt(d)+"px; }");else v.maxHeight&&m>v.maxHeight&&(m=v.maxHeight),m<a&&(n=!0,t.height(m).width(r).css({"overflow-y":"auto"})),e.addClass("top-arrow"),e.find(">style").html("#w2ui-overlay"+b+":before { margin-left: "+parseInt(d)+"px; }#w2ui-overlay"+b+":after { margin-left: "+parseInt(d)+"px; }");r=t.width(),w=window.innerWidth+_(document).scrollLeft()-g.left-7,v.maxWidth&&w>v.maxWidth&&(w=v.maxWidth),w<r&&"both"!==v.align&&(v.align="right",setTimeout(function(){x()},1)),(v.contextMenu||v.noTip)&&e.find(">style").html("#w2ui-overlay"+b+":before { display: none; }#w2ui-overlay"+b+":after { display: none; }"),n&&"both"!==v.align&&t.width(r+w2utils.scrollBarSize()+2)}0<i.length&&(i.css("overflow-y","auto"),i.scrollTop(s.scrollTop),i.scrollLeft(s.scrollLeft))}},_.fn.w2menu=function(e,w){w&&"function"==typeof w.items&&(w.items=w.items());var o=this,d="";if("refresh"===e)if(0<_("#w2ui-overlay"+d).length){w=_.extend(_.fn.w2menuOptions,w);var t=_("#w2ui-overlay"+d+" div.w2ui-menu").scrollTop();_("#w2ui-overlay"+d+" div.w2ui-menu").html(v()),_("#w2ui-overlay"+d+" div.w2ui-menu").scrollTop(t),c()}else _(this).w2menu(w);else{if("refresh-index"!==e){1===arguments.length?w=e:w.items=e,"object"!=typeof w&&(w={}),w=_.extend({},{type:"normal",index:null,items:[],render:null,msgNoItems:"No items",onSelect:null,hideOnRemove:!1,tmp:{}},w),(_.fn.w2menuOptions=w).name&&(d="-"+w.name),"function"==typeof w.select&&"function"!=typeof w.onSelect&&(w.onSelect=w.select),"function"==typeof w.remove&&"function"!=typeof w.onRemove&&(w.onRemove=w.remove),"function"==typeof w.onRender&&"function"!=typeof w.render&&(w.render=w.onRender),_.fn.w2menuClick=function(e,t,i){var s=!1,n=_(e.target).closest("tr");-1!==["radio","check"].indexOf(w.type)&&(e.shiftKey||e.metaKey||e.ctrlKey)&&(s=!0),items=null==i?w.items:w.items[i].items,_(e.target).hasClass("remove")?("function"==typeof w.onRemove&&w.onRemove({index:t,parentIndex:i,item:items[t],keepOpen:s,originalEvent:e}),s=!w.hideOnRemove,_(e.target).closest("tr").remove(),c()):n.hasClass("has-sub-menu")?(s=!0,n.hasClass("expanded")?(items[t].expanded=!1,n.removeClass("expanded").addClass("collapsed").next().hide()):(items[t].expanded=!0,n.addClass("expanded").removeClass("collapsed").next().show()),c()):"function"==typeof w.onSelect&&w.onSelect({index:t,parentIndex:i,item:items[t],keepOpen:s,originalEvent:e});var a=_("#w2ui-overlay"+d);a.removeData("keepOpen"),0<a.length&&"function"==typeof a[0].hide&&!s&&a[0].hide()},_.fn.w2menuDown=function(e,t,i){var s,n,a=_(e.target).closest("tr"),r=_(a.get(0)).find(".w2ui-icon");s=null==i?w.items:w.items[i].items,"check"!==w.type&&"radio"!==w.type||_(e.target).hasClass("remove")||_(e.target).closest("tr").hasClass("has-sub-menu")||((n=s[t]).checked=!n.checked,n.checked?("radio"===w.type&&r.parents("table").find(".w2ui-icon").removeClass("w2ui-icon-check").addClass("w2ui-icon-empty"),"check"===w.type&&null!=n.group&&s.forEach(function(e,t){e.id!=n.id&&e.group===n.group&&e.checked&&(r.closest("table").find("tr[index="+t+"] .w2ui-icon").removeClass("w2ui-icon-check").addClass("w2ui-icon-empty"),s[t].checked=!1)}),r.removeClass("w2ui-icon-empty").addClass("w2ui-icon-check")):"check"===w.type&&null==n.group&&r.removeClass("w2ui-icon-check").addClass("w2ui-icon-empty")),a.parent().find("tr").removeClass("w2ui-selected"),a.addClass("w2ui-selected")};var i="";if(w.search){i+='<div style="position: absolute; top: 0px; height: 40px; left: 0px; right: 0px; border-bottom: 1px solid silver; background-color: #ECECEC; padding: 8px 5px;">    <div class="w2ui-icon icon-search" style="position: absolute; margin-top: 4px; margin-left: 6px; width: 11px; background-position: left !important;"></div>    <input id="menu-search" type="text" style="width: 100%; outline: none; padding-left: 20px;" onclick="event.stopPropagation();"/></div>',w.style+=";background-color: #ECECEC";for(var s=w.index=0;s<w.items.length;s++)w.items[s].hidden=!1}i+='<div class="w2ui-menu" style="top: '+(w.search?40:0)+'px">'+v()+"</div>";var n=_(this).w2overlay(i,w);return setTimeout(function(){if(_("#w2ui-overlay"+d+" #menu-search").on("keyup",h).on("keydown",function(e){9===e.keyCode&&(e.stopPropagation(),e.preventDefault())}),w.search){if(-1!==["text","password"].indexOf(_(o)[0].type)||"TEXTAREA"===_(o)[0].tagName.toUpperCase())return;_("#w2ui-overlay"+d+" #menu-search").focus()}c()},250),c(),n}var a=_("#w2ui-overlay"+d+" div.w2ui-menu"),r=a.find("tr[index="+w.index+"]");t=a.scrollTop();if(a.find("tr.w2ui-selected").removeClass("w2ui-selected"),r.addClass("w2ui-selected"),0<r.length){var l=r[0].offsetTop-5,u=a.height();a.scrollTop(t),(l<t||l+r.height()>t+u)&&a.animate({scrollTop:l-(u-2*r.height())/2},200,"linear")}c()}return;function c(){setTimeout(function(){_("#w2ui-overlay"+d+" tr.w2ui-selected").removeClass("w2ui-selected");var e=_("#w2ui-overlay"+d+" tr[index="+w.index+"]"),t=_("#w2ui-overlay"+d+" div.w2ui-menu").scrollTop();if(e.addClass("w2ui-selected"),w.tmp&&(w.tmp.contentHeight=_("#w2ui-overlay"+d+" table").height()+(w.search?50:10),w.tmp.contentWidth=_("#w2ui-overlay"+d+" table").width()),0<_("#w2ui-overlay"+d).length&&_("#w2ui-overlay"+d)[0].resize(),0<e.length){var i=e[0].offsetTop-5,s=_("#w2ui-overlay"+d+" div.w2ui-menu").height();_("#w2ui-overlay"+d+" div.w2ui-menu").scrollTop(t),(i<t||i+e.height()>t+s)&&_("#w2ui-overlay"+d+" div.w2ui-menu").animate({scrollTop:i-(s-2*e.height())/2},200,"linear")}},1)}function h(e){var t=this.value,i=!1;switch(e.keyCode){case 13:_("#w2ui-overlay"+d).remove(),_.fn.w2menuClick(e,w.index);break;case 9:case 27:_("#w2ui-overlay"+d).remove(),_.fn.w2menuClick(e,-1);break;case 38:for(w.index=w2utils.isInt(w.index)?parseInt(w.index):0,w.index--;0<w.index&&w.items[w.index].hidden;)w.index--;if(0===w.index&&w.items[w.index].hidden)for(;w.items[w.index]&&w.items[w.index].hidden;)w.index++;w.index<0&&(w.index=0),i=!0;break;case 40:for(w.index=w2utils.isInt(w.index)?parseInt(w.index):0,w.index++;w.index<w.items.length-1&&w.items[w.index].hidden;)w.index++;if(w.index===w.items.length-1&&w.items[w.index].hidden)for(;w.items[w.index]&&w.items[w.index].hidden;)w.index--;w.index>=w.items.length&&(w.index=w.items.length-1),i=!0}if(!i){for(var s=0,n=0;n<w.items.length;n++){var a=w.items[n],r="",l="";-1!==["is","begins with"].indexOf(w.match)&&(r="^"),-1!==["is","ends with"].indexOf(w.match)&&(l="$");try{new RegExp(r+t+l,"i").test(a.text)||"..."===a.text?a.hidden=!1:a.hidden=!0}catch(e){}"enum"===o.type&&-1!==_.inArray(a.id,ids)&&(a.hidden=!0),!0!==a.hidden&&s++}for(w.index=0;w.index<w.items.length-1&&w.items[w.index].hidden;)w.index++;s<=0&&(w.index=-1)}_(o).w2menu("refresh",w),c()}function v(e,t,i,s){if(w.spinner)return'<table><tbody><tr><td style="padding: 5px 10px 10px 10px; text-align: center">    <div class="w2ui-spinner" style="width: 18px; height: 18px; position: relative; top: 5px;"></div>     <div style="display: inline-block; padding: 3px; color: #999;">'+w2utils.lang("Loading...")+"</div></td></tr></tbody></table>";var n=0,a='<table cellspacing="0" cellpadding="0" class="'+(t?" sub-menu":"")+'"><tbody>',r=null,l=null;null==e&&(e=w.items);for(var o=0;o<e.length;o++){var d=e[o];if("string"==typeof d?d={id:d,text:d}:(null!=d.text&&null==d.id&&(d.id=d.text),null==d.text&&null!=d.id&&(d.text=d.id),null!=d.caption&&(d.text=d.caption),null==(r=d.img)&&(r=null),null==(l=d.icon)&&(l=null)),-1==["radio","check"].indexOf(w.type)||Array.isArray(d.items)||(l=!0===d.checked?"w2ui-icon-check":"w2ui-icon-empty"),!0!==d.hidden){var u="",c=d.text,h="";if("function"==typeof w.render&&(c=w.render(d,w)),r&&(u='<td class="menu-icon"><div class="w2ui-tb-image w2ui-icon '+r+'"></div></td>'),l&&(u='<td class="menu-icon" align="center"><span class="w2ui-icon '+l+'"></span></td>'),"break"!==d.type&&null!=c&&""!==c&&"--"!=String(c).substr(0,2)){var p=n%2==0?"w2ui-item-even":"w2ui-item-odd";!0!==w.altRows&&(p="");var f=1;""===u&&f++,null!=d.count||null!=d.hotkey||!0===d.remove||Array.isArray(d.items)||f++,null==d.tooltip&&null!=d.hint&&(d.tooltip=d.hint);var g="";!0===d.remove?g='<span class="remove">X</span>':Array.isArray(d.items)?(g="<span></span>",h='<tr style="'+(d.expanded?"":"display: none")+'">     <td colspan="3">'+v(d.items,!0,!d.expanded,o)+"</td><tr>"):(null!=d.count&&(g+="<span>"+d.count+"</span>"),null!=d.hotkey&&(g+='<span class="hotkey">'+d.hotkey+"</span>")),a+='<tr index="'+o+'" style="'+(d.style?d.style:"")+'" '+(d.tooltip?'title="'+w2utils.lang(d.tooltip)+'"':"")+' class="'+p+(w.index===o?" w2ui-selected":"")+(!0===d.disabled?" w2ui-disabled":"")+(""!==h?" has-sub-menu"+(d.expanded?" expanded":" collapsed"):"")+'"        onmousedown="if ('+(!0===d.disabled?"true":"false")+") return;               jQuery.fn.w2menuDown(event, "+o+",  "+s+');"        onclick="event.stopPropagation();                if ('+(!0===d.disabled?"true":"false")+") return;               jQuery.fn.w2menuClick(event, "+o+",  "+s+');">'+(t?"<td></td>":"")+u+'   <td class="menu-text" colspan="'+f+'">'+w2utils.lang(c)+'</td>   <td class="menu-count">'+g+"</td></tr>"+h,n++}else{var m=c.replace(/^-+/g,"");a+='<tr><td colspan="3" class="menu-divider '+(""!=m?"divider-text":"")+'">   <div class="line">'+m+'</div>   <div class="text">'+m+"</div></td></tr>"}}e[o]=d}return 0===n&&(a+='<tr><td style="padding: 13px; color: #999; text-align: center">'+w.msgNoItems+"</div></td></tr>"),a+="</tbody></table>"}},_.fn.w2color=function(n,e){var t=_(this),a=t[0];if(t.data("skipInit"))t.removeData("skipInit");else{var r=[-1,-1];null==_.fn.w2colorPalette&&(_.fn.w2colorPalette=[["000000","333333","555555","777777","888888","999999","AAAAAA","CCCCCC","DDDDDD","EEEEEE","F7F7F7","FFFFFF"],["FF011B","FF9838","FFC300","FFFD59","86FF14","14FF7A","2EFFFC","2693FF","006CE7","9B24F4","FF21F5","FF0099"],["FFEAEA","FCEFE1","FCF4DC","FFFECF","EBFFD9","D9FFE9","E0FFFF","E8F4FF","ECF4FC","EAE6F4","FFF5FE","FCF0F7"],["F4CCCC","FCE5CD","FFF1C2","FFFDA1","D5FCB1","B5F7D0","BFFFFF","D6ECFF","CFE2F3","D9D1E9","FFE3FD","FFD9F0"],["EA9899","F9CB9C","FFE48C","F7F56F","B9F77E","84F0B1","83F7F7","B5DAFF","9FC5E8","B4A7D6","FAB9F6","FFADDE"],["E06666","F6B26B","DEB737","E0DE51","8FDB48","52D189","4EDEDB","76ACE3","6FA8DC","8E7CC3","E07EDA","F26DBD"],["CC0814","E69138","AB8816","B5B20E","6BAB30","27A85F","1BA8A6","3C81C7","3D85C6","674EA7","A14F9D","BF4990"],["99050C","B45F17","80650E","737103","395E14","10783D","13615E","094785","0A5394","351C75","780172","782C5A"]]);var c,l=_.fn.w2colorPalette;"string"==typeof n&&(n={color:n,transparent:!0}),null==n.onSelect&&null!=e&&(n.onSelect=e),n.transparent&&"333333"==l[0][1]&&(l[0].splice(1,1),l[0].push("")),n.transparent||"333333"==l[0][1]||(l[0].splice(1,0,"333333"),l[0].pop()),n.color&&(n.color=String(n.color).toUpperCase()),"string"==typeof n.color&&"#"===n.color.substr(0,1)&&(n.color=n.color.substr(1)),null==n.fireChange&&(n.fireChange=!0),0===_("#w2ui-overlay").length?_(a).w2overlay(w(n),n):(_("#w2ui-overlay .w2ui-color").parent().html(w(n)),_("#w2ui-overlay").show()),_("#w2ui-overlay .color").off(".w2color").on("mousedown.w2color",function(e){var t=_(e.originalEvent.target).attr("name");r=_(e.originalEvent.target).attr("index").split(":"),"INPUT"===a.tagName.toUpperCase()?(n.fireChange&&_(a).change(),_(a).next().find(">div").css("background-color",t)):_(a).data("_color",t),"function"==typeof n.onSelect&&n.onSelect(t)}).on("mouseup.w2color",function(){setTimeout(function(){0<_("#w2ui-overlay").length&&_("#w2ui-overlay").removeData("keepOpen")[0].hide()},10)}),_("#w2ui-overlay .color-original").off(".w2color").on("click.w2color",function(e){var t=w2utils.parseColor(_(e.target).css("background-color"));null!=t&&(d=t,o=w2utils.rgb2hsv(d),h(o),u(),p())}),_("#w2ui-overlay input").off(".w2color").on("mousedown.w2color",function(e){_("#w2ui-overlay").data("keepOpen",!0),setTimeout(function(){_("#w2ui-overlay").data("keepOpen",!0)},10),e.stopPropagation()}).on("change.w2color",function(){var e=_(this),t=parseFloat(e.val()),i=parseFloat(e.attr("max"));isNaN(t)&&(t=0),1<i&&(t=parseInt(t)),0<i&&i<t&&(e.val(i),t=i),t<0&&(e.val(0),t=0);var s=e.attr("name"),n={};-1!==["r","g","b","a"].indexOf(s)?(d[s]=t,o=w2utils.rgb2hsv(d)):-1!==["h","s","v"].indexOf(s)&&(n[s]=t),h(n),u(),p()});var o,d=w2utils.parseColor(n.color);null==d&&(d={r:140,g:150,b:160,a:1},o=w2utils.rgb2hsv(d)),o=w2utils.rgb2hsv(d);function i(e){var t=_(this).find(".value1, .value2"),i=parseInt(t.width())/2;t.hasClass("move-x")&&t.css({left:e.offsetX-i+"px"}),t.hasClass("move-y")&&t.css({top:e.offsetY-i+"px"}),c={$el:t,x:e.pageX,y:e.pageY,width:t.parent().width(),height:t.parent().height(),left:parseInt(t.css("left")),top:parseInt(t.css("top"))},f(e),_("body").off(".w2color").on(m,f).on(g,s)}var h=function(e,t){null!=e.h&&(o.h=e.h),null!=e.s&&(o.s=e.s),null!=e.v&&(o.v=e.v),null!=e.a&&(d.a=e.a,o.a=e.a);var i="rgba("+(d=w2utils.hsv2rgb(o)).r+","+d.g+","+d.b+","+d.a+")",s=[Number(d.r).toString(16).toUpperCase(),Number(d.g).toString(16).toUpperCase(),Number(d.b).toString(16).toUpperCase()];s.forEach(function(e,t){1===e.length&&(s[t]="0"+e)}),1===d.a&&(i=s[0]+s[1]+s[2]),_("#w2ui-overlay .color-preview").css("background-color",i),_("#w2ui-overlay input").each(function(e,t){t.name&&(null!=d[t.name]&&(t.value=d[t.name]),null!=o[t.name]&&(t.value=o[t.name]),"a"===t.name&&(t.value=d.a))}),t?_("#w2ui-overlay .color-original").css("background-color",i):("INPUT"===a.tagName.toUpperCase()?(_(a).val(i).data("skipInit",!0),n.fireChange&&_(a).change(),_(a).next().find(">div").css("background-color",i)):_(a).data("_color",i),"function"==typeof n.onSelect&&n.onSelect(i))},u=function(){var e=_("#w2ui-overlay .palette .value1"),t=_("#w2ui-overlay .rainbow .value2"),i=_("#w2ui-overlay .alpha .value2"),s=parseInt(e.width())/2,n=parseInt(t.width())/2;e.css({left:150*o.s/100-s,top:125*(100-o.v)/100-s}),t.css("left",o.h/2.4-n),i.css("left",150*d.a-n)},p=function(){var e=w2utils.hsv2rgb(o.h,100,100),t=e.r+","+e.g+","+e.b;_("#w2ui-overlay .palette").css("background-image","linear-gradient(90deg, rgba("+t+",0) 0%, rgba("+t+",1) 100%)")},s=function(e){_("body").off(".w2color")},f=function(e){var t=c.$el,i=e.pageX-c.x,s=e.pageY-c.y,n=c.left+i,a=c.top+s,r=parseInt(t.width())/2;n<-r&&(n=-r),a<-r&&(a=-r),n>c.width-r&&(n=c.width-r),a>c.height-r&&(a=c.height-r),t.hasClass("move-x")&&t.css({left:n+"px"}),t.hasClass("move-y")&&t.css({top:a+"px"});var l=t.parent().attr("name"),o=parseInt(t.css("left"))+r,d=parseInt(t.css("top"))+r;if("palette"===l&&h({s:Math.round(o/c.width*100),v:Math.round(100-d/c.height*100)}),"rainbow"===l){var u=Math.round(2.4*o);h({h:u}),p()}"alpha"===l&&h({a:parseFloat(Number(o/150).toFixed(2))})};!0!==_.fn._colorAdvanced&&!0!==n.advanced||(_("#w2ui-overlay .w2ui-color-tabs :nth-child(2)").click(),_("#w2ui-overlay").removeData("keepOpen")),h({},!0),p(),u();var g="mouseup.w2color",m="mousemove.w2color";w2utils.isIOS&&("touchstart.w2color",g="touchend.w2color",m="touchmove.w2color  "),_("#w2ui-overlay .palette").off(".w2color").on("mousedown.w2color",i),_("#w2ui-overlay .rainbow").off(".w2color").on("mousedown.w2color",i),_("#w2ui-overlay .alpha").off(".w2color").on("mousedown.w2color",i),a.nav=function(e){switch(e){case"up":r[0]--;break;case"down":r[0]++;break;case"right":r[1]++;break;case"left":r[1]--}return r[0]<0&&(r[0]=0),r[0]>l.length-2&&(r[0]=l.length-2),r[1]<0&&(r[1]=0),r[1]>l[0].length-1&&(r[1]=l[0].length-1),color=l[r[0]][r[1]],_(a).data("_color",color),color}}function w(e){e.color;for(var t,i='<div class="w2ui-color" onmousedown="jQuery(this).parents(\'.w2ui-overlay\').data(\'keepOpen\', true)"><div class="w2ui-color-palette"><table cellspacing="5"><tbody>',s=0;s<l.length;s++){i+="<tr>";for(var n=0;n<l[s].length;n++)t="FFFFFF"===l[s][n]?";border: 1px solid #efefef":"",i+='<td>    <div class="color '+(""===l[s][n]?"no-color":"")+'" style="background-color: #'+l[s][n]+t+';"        name="'+l[s][n]+'" index="'+s+":"+n+'">'+(e.color==l[s][n]?"&#149;":"&#160;")+"    </div></td>",e.color==l[s][n]&&(r=[s,n]);i+="</tr>",s<2&&(i+='<tr><td style="height: 8px" colspan="8"></td></tr>')}return i+="</tbody></table></div>",i+='<div class="w2ui-color-advanced" style="display: none">   <div class="color-info">       <div class="color-preview-bg"><div class="color-preview"></div><div class="color-original"></div></div>       <div class="color-part">           <span>H</span> <input name="h" maxlength="3" max="360" tabindex="101">           <span>R</span> <input name="r" maxlength="3" max="255" tabindex="104">       </div>       <div class="color-part">           <span>S</span> <input name="s" maxlength="3" max="100" tabindex="102">           <span>G</span> <input name="g" maxlength="3" max="255" tabindex="105">       </div>       <div class="color-part">           <span>V</span> <input name="v" maxlength="3" max="100" tabindex="103">           <span>B</span> <input name="b" maxlength="3" max="255" tabindex="106">       </div>       <div class="color-part" style="margin: 30px 0px 0px 2px">           <span style="width: 40px">Opacity</span>            <input name="a" maxlength="5" max="1" style="width: 32px !important" tabindex="107">       </div>   </div>   <div class="palette" name="palette">       <div class="palette-bg"></div>       <div class="value1 move-x move-y"></div>   </div>   <div class="rainbow" name="rainbow">       <div class="value2 move-x"></div>   </div>   <div class="alpha" name="alpha">       <div class="alpha-bg"></div>       <div class="value2 move-x"></div>   </div></div>',i+="<div class=\"w2ui-color-tabs\">   <div class=\"w2ui-color-tab selected\" onclick=\"jQuery(this).addClass('selected').next().removeClass('selected').parents('.w2ui-overlay').find('.w2ui-color-advanced').hide().parent().find('.w2ui-color-palette').show(); jQuery.fn._colorAdvanced = false; jQuery('#w2ui-overlay')[0].resize()\"><span class=\"w2ui-icon w2ui-icon-colors\"></span></div>   <div class=\"w2ui-color-tab\" onclick=\"jQuery(this).addClass('selected').prev().removeClass('selected').parents('.w2ui-overlay').find('.w2ui-color-advanced').show().parent().find('.w2ui-color-palette').hide(); jQuery.fn._colorAdvanced = true; jQuery('#w2ui-overlay')[0].resize()\"><span class=\"w2ui-icon w2ui-icon-settings\"></span></div>   <div style=\"padding: 8px; text-align: right;\">"+("string"==typeof e.html?e.html:"")+'</div></div></div><div style="clear: both; height: 0"></div>'}}}(jQuery),function($){var w2grid=function(e){this.name=null,this.box=null,this.columns=[],this.columnGroups=[],this.records=[],this.summary=[],this.searches=[],this.sortMap={},this.toolbar={},this.total=0,this.recid=null,this.last={field:"",label:"",logic:"OR",search:"",searchIds:[],selection:{indexes:[],columns:{}},multi:!1,scrollTop:0,scrollLeft:0,colStart:0,colEnd:0,sortData:null,sortCount:0,xhr:null,range_start:null,range_end:null,sel_ind:null,sel_col:null,sel_type:null,edit_col:null,isSafari:/^((?!chrome|android).)*safari/i.test(navigator.userAgent)},$.extend(!0,this,w2obj.grid),this.show=$.extend(!0,{},w2grid.prototype.show),this.postData=$.extend(!0,{},w2grid.prototype.postData),this.httpHeaders=$.extend(!0,{},w2grid.prototype.httpHeaders),this.buttons=$.extend(!0,{},w2grid.prototype.buttons),this.operators=$.extend(!0,{},w2grid.prototype.operators),this.operatorsMap=$.extend(!0,{},w2grid.prototype.operatorsMap),this.stateColProps=$.extend(!0,{},w2grid.prototype.stateColProps),this.stateColDefaults=$.extend(!0,{},w2grid.prototype.stateColDefaults),$.extend(!0,this,e)};$.fn.w2grid=function(e){if($.isPlainObject(e)){if(!w2utils.checkName(e,"w2grid"))return;var t,i=e.columns,s=e.columnGroups,n=e.records,a=e.searches,r=e.searchData,l=e.sortData,o=new w2grid(e);if($.extend(o,{records:[],columns:[],searches:[],sortData:[],searchData:[],handlers:[]}),i)for(t=0;t<i.length;t++)o.columns[t]=$.extend(!0,{},i[t]);if(s)for(t=0;t<s.length;t++)o.columnGroups[t]=$.extend(!0,{},s[t]);if(a)for(t=0;t<a.length;t++)o.searches[t]=$.extend(!0,{},a[t]);if(r)for(t=0;t<r.length;t++)o.searchData[t]=$.extend(!0,{},r[t]);if(l)for(t=0;t<l.length;t++)o.sortData[t]=$.extend(!0,{},l[t]);if(n)for(var d=0;d<n.length;d++){if(null!=n[d][o.recid]&&(n[d].recid=n[d][o.recid]),null==n[d].recid)return void console.log("ERROR: Cannot add records without recid. (obj: "+o.name+")");o.records[d]=$.extend(!0,{},n[d])}for(var u=0;u<o.columns.length;u++){var c=o.columns[u],h=c.searchable;if(null!=h&&!1!==h&&null==o.getSearch(c.field))if($.isPlainObject(h))o.addSearch($.extend({field:c.field,label:c.text,type:"text"},h));else{var p=c.searchable,f="";!0===c.searchable&&(p="text",f='size="20"'),o.addSearch({field:c.field,label:c.text,type:p,attr:f})}}return o.initToolbar(),o.updateToolbar(),0!==$(this).length&&o.render($(this)[0]),w2ui[o.name]=o}var g=w2ui[$(this).attr("name")];return g?0<arguments.length?(g[e]&&g[e].apply(g,Array.prototype.slice.call(arguments,1)),this):g:null},w2grid.prototype={header:"",url:"",limit:100,offset:0,searchData:[],sortData:[],routeData:{},postData:{},httpHeaders:{},show:{header:!1,toolbar:!1,footer:!1,columnHeaders:!0,lineNumbers:!1,orderColumn:!1,expandColumn:!1,selectColumn:!1,emptyRecords:!0,toolbarReload:!0,toolbarColumns:!0,toolbarSearch:!0,toolbarInput:!0,toolbarAdd:!1,toolbarEdit:!1,toolbarDelete:!1,toolbarSave:!1,searchAll:!0,searchHiddenMsg:!1,statusRange:!0,statusBuffered:!1,statusRecordID:!0,statusSelection:!0,statusResponse:!0,statusSort:!1,statusSearch:!1,recordTitles:!0,selectionBorder:!0,skipRecords:!0,saveRestoreState:!0},stateId:null,hasFocus:!1,autoLoad:!0,fixedBody:!0,recordHeight:24,lineNumberWidth:null,keyboard:!0,selectType:"row",multiSearch:!0,multiSelect:!0,multiSort:!0,reorderColumns:!1,reorderRows:!1,showExtraOnSearch:0,markSearch:!0,columnTooltip:"normal",disableCVS:!1,textSearch:"begins",nestedFields:!0,vs_start:150,vs_extra:15,style:"",ranges:[],menu:[],method:null,dataType:null,parser:null,stateColProps:{text:!1,field:!0,size:!0,min:!1,max:!1,gridMinWidth:!1,sizeCorrected:!1,sizeCalculated:!0,sizeOriginal:!0,sizeType:!0,hidden:!0,sortable:!1,searchable:!1,resizable:!1,hideable:!1,attr:!1,style:!1,render:!1,title:!1,editable:!1,frozen:!0,info:!1},stateColDefaults:{text:"",field:"",size:null,min:20,max:null,gridMinWidth:null,sizeCorrected:null,sizeCalculated:null,sizeOriginal:null,sizeType:null,hidden:!1,sortable:!1,searchable:!1,resizable:!0,hideable:!0,attr:"",style:"",render:null,title:null,editable:{},frozen:!1,info:null},msgDelete:"Are you sure you want to delete NN records?",msgDeleteBtn:"Delete",msgNotJSON:"Returned data is not in valid JSON format.",msgAJAXerror:"AJAX error. See console for more details.",msgRefresh:"Refreshing...",msgNeedReload:"Your remote data source record count has changed, reloading from the first record.",msgEmpty:"",buttons:{reload:{type:"button",id:"w2ui-reload",icon:"w2ui-icon-reload",tooltip:"Reload data in the list"},columns:{type:"drop",id:"w2ui-column-on-off",icon:"w2ui-icon-columns",tooltip:"Show/hide columns",arrow:!1,html:""},search:{type:"html",id:"w2ui-search",html:"<div class=\"w2ui-icon icon-search-down w2ui-search-down\" onclick=\"var grid = w2ui[jQuery(this).parents('div.w2ui-grid').attr('name')]; grid.searchShowFields()\"></div>"},"search-go":{type:"drop",id:"w2ui-search-advanced",icon:"w2ui-icon-search",text:"Search",tooltip:"Open Search Fields"},add:{type:"button",id:"w2ui-add",text:"Add New",tooltip:"Add new record",icon:"w2ui-icon-plus"},edit:{type:"button",id:"w2ui-edit",text:"Edit",tooltip:"Edit selected record",icon:"w2ui-icon-pencil",disabled:!0},delete:{type:"button",id:"w2ui-delete",text:"Delete",tooltip:"Delete selected records",icon:"w2ui-icon-cross",disabled:!0},save:{type:"button",id:"w2ui-save",text:"Save",tooltip:"Save changed records",icon:"w2ui-icon-check"}},operators:{text:["is","begins","contains","ends"],number:["=","between",">","<",">=","<="],date:["is","between",{oper:"less",text:"before"},{oper:"more",text:"after"}],list:["is"],hex:["is","between"],color:["is","begins","contains","ends"],enum:["in","not in"]},operatorsMap:{text:"text",int:"number",float:"number",money:"number",currency:"number",percent:"number",hex:"hex",alphanumeric:"text",color:"color",date:"date",time:"date",datetime:"date",list:"list",combo:"text",enum:"enum",file:"enum",select:"list",radio:"list",checkbox:"list",toggle:"list"},onAdd:null,onEdit:null,onRequest:null,onLoad:null,onDelete:null,onSave:null,onSelect:null,onUnselect:null,onClick:null,onDblClick:null,onContextMenu:null,onMenuClick:null,onColumnClick:null,onColumnDblClick:null,onColumnResize:null,onColumnAutoResize:null,onSort:null,onSearch:null,onSearchOpen:null,onChange:null,onRestore:null,onExpand:null,onCollapse:null,onError:null,onKeydown:null,onToolbar:null,onColumnOnOff:null,onCopy:null,onPaste:null,onSelectionExtend:null,onEditField:null,onRender:null,onRefresh:null,onReload:null,onResize:null,onDestroy:null,onStateSave:null,onStateRestore:null,onFocus:null,onBlur:null,onReorderRow:null,add:function(e,t){$.isArray(e)||(e=[e]);for(var i=0,s=0;s<e.length;s++){var n=e[s];null!=n[this.recid]&&(n.recid=n[this.recid]),null!=n.recid?(n.w2ui&&!0===n.w2ui.summary?t?this.summary.unshift(n):this.summary.push(n):t?this.records.unshift(n):this.records.push(n),i++):console.log("ERROR: Cannot add record without recid. (obj: "+this.name+")")}return("object"!=typeof this.url?this.url:this.url.get)?this.refresh():(this.total=this.records.length,this.localSort(!1,!0),this.localSearch(),this.refreshBody(),this.resizeRecords()),i},find:function(e,t){null==e&&(e={});var i=[],s=!1;for(var n in e)-1!=String(n).indexOf(".")&&(s=!0);for(var a=0;a<this.records.length;a++){var r=!0;for(var n in e){var l=this.records[a][n];s&&-1!=String(n).indexOf(".")&&(l=this.parseField(this.records[a],n)),"not-null"==e[n]?null!=l&&""!==l||(r=!1):e[n]!=l&&(r=!1)}r&&!0!==t&&i.push(this.records[a].recid),r&&!0===t&&i.push(a)}return i},set:function(e,t,i){if("object"==typeof e&&null!==e&&(i=t,t=e,e=null),null==e){for(var s=0;s<this.records.length;s++)$.extend(!0,this.records[s],t);!0!==i&&this.refresh()}else{var n=this.get(e,!0);if(null==n)return!1;!this.records[n]||this.records[n].recid!=e?$.extend(!0,this.summary[n],t):$.extend(!0,this.records[n],t),!0!==i&&this.refreshRow(e,n)}return!0},get:function(e,t){if($.isArray(e)){for(var i=[],s=0;s<e.length;s++){var n=this.get(e[s],t);null!==n&&i.push(n)}return i}var a=this.last.idCache;if(a||(this.last.idCache=a={}),"number"==typeof(s=a[e])){if(0<=s&&s<this.records.length&&this.records[s].recid==e)return!0===t?s:this.records[s];if(0<=(s=~s)&&s<this.summary.length&&this.summary[s].recid==e)return!0===t?s:this.summary[s];this.last.idCache=a={}}for(s=0;s<this.records.length;s++)if(this.records[s].recid==e)return a[e]=s,!0===t?s:this.records[s];for(s=0;s<this.summary.length;s++)if(this.summary[s].recid==e)return a[e]=~s,!0===t?s:this.summary[s];return null},getFirst:function(){if(0==this.records.length)return null;var e=this.records[0].recid,t=this.last.searchIds;return 0<this.searchData.length&&(e=Array.isArray(t)&&0<t.length?this.records[t[0]].recid:null),e},remove:function(){for(var e=0,t=0;t<arguments.length;t++){for(var i=this.records.length-1;0<=i;i--)this.records[i].recid==arguments[t]&&(this.records.splice(i,1),e++);for(i=this.summary.length-1;0<=i;i--)this.summary[i].recid==arguments[t]&&(this.summary.splice(i,1),e++)}return("object"!=typeof this.url?this.url:this.url.get)||(this.localSort(!1,!0),this.localSearch()),this.refresh(),e},addColumn:function(e,t){var i=0;1==arguments.length?(t=e,e=this.columns.length):("string"==typeof e&&(e=this.getColumn(e,!0)),null==e&&(e=this.columns.length)),$.isArray(t)||(t=[t]);for(var s=0;s<t.length;s++){if(this.columns.splice(e,0,t[s]),t[s].searchable){var n=t[s].searchable,a="";!0===t[s].searchable&&(n="text",a='size="20"'),this.addSearch({field:t[s].field,label:t[s].label,type:n,attr:a})}e++,i++}return this.refresh(),i},removeColumn:function(){for(var e=0,t=0;t<arguments.length;t++)for(var i=this.columns.length-1;0<=i;i--)this.columns[i].field==arguments[t]&&(this.columns[i].searchable&&this.removeSearch(arguments[t]),this.columns.splice(i,1),e++);return this.refresh(),e},getColumn:function(e,t){if(0===arguments.length){for(var i=[],s=0;s<this.columns.length;s++)i.push(this.columns[s].field);return i}for(s=0;s<this.columns.length;s++)if(this.columns[s].field==e)return!0===t?s:this.columns[s];return null},updateColumn:function(e,s){var t=this,n=0;return(e=Array.isArray(e)?e:[e]).forEach(function(e){t.columns.forEach(function(t){if(t.field==e){var i=$.extend(!0,{},s);Object.keys(i).forEach(function(e){"function"==typeof i[e]&&(i[e]=i[e](t)),t[e]!=i[e]&&n++}),$.extend(!0,t,i)}})}),this.refreshBody(),this.resizeRecords(),n},toggleColumn:function(){return this.updateColumn(Array.from(arguments),{hidden:function(e){return!e.hidden}})},showColumn:function(){return this.updateColumn(Array.from(arguments),{hidden:!1})},hideColumn:function(){return this.updateColumn(Array.from(arguments),{hidden:!0})},addSearch:function(e,t){var i=0;1==arguments.length?(t=e,e=this.searches.length):("string"==typeof e&&(e=this.getSearch(e,!0)),null==e&&(e=this.searches.length)),$.isArray(t)||(t=[t]);for(var s=0;s<t.length;s++)this.searches.splice(e,0,t[s]),e++,i++;return this.searchClose(),i},removeSearch:function(){for(var e=0,t=0;t<arguments.length;t++)for(var i=this.searches.length-1;0<=i;i--)this.searches[i].field==arguments[t]&&(this.searches.splice(i,1),e++);return this.searchClose(),e},getSearch:function(e,t){if(0===arguments.length){for(var i=[],s=0;s<this.searches.length;s++)i.push(this.searches[s].field);return i}for(s=0;s<this.searches.length;s++)if(this.searches[s].field==e)return!0===t?s:this.searches[s];return null},toggleSearch:function(){for(var e=0,t=0;t<arguments.length;t++)for(var i=this.searches.length-1;0<=i;i--)this.searches[i].field==arguments[t]&&(this.searches[i].hidden=!this.searches[i].hidden,e++);return this.searchClose(),e},showSearch:function(){for(var e=0,t=0;t<arguments.length;t++)for(var i=this.searches.length-1;0<=i;i--)this.searches[i].field==arguments[t]&&!1!==this.searches[i].hidden&&(this.searches[i].hidden=!1,e++);return this.searchClose(),e},hideSearch:function(){for(var e=0,t=0;t<arguments.length;t++)for(var i=this.searches.length-1;0<=i;i--)this.searches[i].field==arguments[t]&&!0!==this.searches[i].hidden&&(this.searches[i].hidden=!0,e++);return this.searchClose(),e},getSearchData:function(e){for(var t=0;t<this.searchData.length;t++)if(this.searchData[t].field==e)return this.searchData[t];return null},localSort:function(e,t){if("object"!=typeof this.url?this.url:this.url.get)console.log("ERROR: grid.localSort can only be used on local data source, grid.url should be empty.");else if(!$.isEmptyObject(this.sortData)){var i=(new Date).getTime(),d=this;d.selectionSave(),d.prepareData(),t||d.reset();for(var s=0;s<this.sortData.length;s++){var n=this.getColumn(this.sortData[s].field);if(!n)return;"string"==typeof n.render&&(-1!=["date","age"].indexOf(n.render.split(":")[0])&&(this.sortData[s].field_=n.field+"_"),-1!=["time"].indexOf(n.render.split(":")[0])&&(this.sortData[s].field_=n.field+"_"))}return function(){for(var e=0;e<d.records.length;e++){var t=d.records[e];t.w2ui&&null!=t.w2ui.parent_recid&&(t.w2ui._path=r(t))}}(),this.records.sort(function(e,t){return function(e,t){if(!(e.w2ui&&null!=e.w2ui.parent_recid||t.w2ui&&null!=t.w2ui.parent_recid))return l(e,t);for(var i=r(e),s=r(t),n=0;n<Math.min(i.length,s.length);n++){var a=l(i[n],s[n]);if(0!==a)return a}return i.length>s.length?1:i.length<s.length?-1:(console.log("ERROR: two paths should not be equal."),0)}(e,t)}),function(){for(var e=0;e<d.records.length;e++){var t=d.records[e];t.w2ui&&null!=t.w2ui.parent_recid&&(t.w2ui._path=null)}}(),d.selectionRestore(t),i=(new Date).getTime()-i,!0!==e&&d.show.statusSort&&setTimeout(function(){d.status(w2utils.lang("Sorting took")+" "+i/1e3+" "+w2utils.lang("sec"))},10),i}function r(e){if(!e.w2ui||null==e.w2ui.parent_recid)return[e];if(e.w2ui._path)return e.w2ui._path;var t=d.get(e.w2ui.parent_recid);return t?r(t).concat(e):(console.log("ERROR: no parent record: "+e.w2ui.parent_recid),[e])}function l(e,t){if(e===t)return 0;for(var i=0;i<d.sortData.length;i++){var s=d.sortData[i].field,n=d.sortData[i].field_?d.sortData[i].field_:s,a=e[n],r=t[n];-1!=String(s).indexOf(".")&&(a=d.parseField(e,n),r=d.parseField(t,n));var l=d.getColumn(s);if(l&&null!=l.editable&&($.isPlainObject(a)&&a.text&&(a=a.text),$.isPlainObject(r)&&r.text&&(r=r.text)),0!==(o=u(a,r,i,d.sortData[i].direction,l.sortMode||"default")))return o}var o;return o=u(e.recid,t.recid,-1,"asc")}function u(e,t,i,s,n){if(e===t)return 0;if((null==e||""===e)&&null!=t&&""!==t)return 1;if(null!=e&&""!==e&&(null==t||""===t))return-1;var a="asc"===s.toLowerCase()?1:-1;if(typeof e!=typeof t)return typeof t<typeof e?a:-a;if(e.constructor.name!=t.constructor.name)return e.constructor.name>t.constructor.name?a:-a;e&&"object"==typeof e&&(e=e.valueOf()),t&&"object"==typeof t&&(t=t.valueOf());var r={}.toString;switch(e&&"object"==typeof e&&e.toString!=r&&(e=String(e)),t&&"object"==typeof t&&t.toString!=r&&(t=String(t)),"string"==typeof e&&(e=$.trim(e.toLowerCase())),"string"==typeof t&&(t=$.trim(t.toLowerCase())),n){case"natural":n=w2utils.naturalCompare}return"function"==typeof n?n(e,t)*a:t<e?a:e<t?-a:0}},localSearch:function(e){var t="object"!=typeof this.url?this.url:this.url.get;if(!t){var i=(new Date).getTime(),p=this,f={}.toString,s={};if(this.total=this.records.length,this.last.searchIds=[],this.prepareData(),0<this.searchData.length&&!t){for(var n=this.total=0;n<this.records.length;n++){var a=this.records[n];if(g(a))if(a&&a.w2ui&&d(a.w2ui.parent_recid),0<this.showExtraOnSearch){var r=this.showExtraOnSearch,l=this.showExtraOnSearch;if(n<r&&(r=n),n+l>this.records.length&&(l=this.records.length-n),0<r)for(var o=n-r;o<n;o++)this.last.searchIds.indexOf(o)<0&&this.last.searchIds.push(o);if(this.last.searchIds.indexOf(n)<0&&this.last.searchIds.push(n),0<l)for(o=n+1;o<=n+l;o++)this.last.searchIds.indexOf(o)<0&&this.last.searchIds.push(o)}else this.last.searchIds.push(n)}this.total=this.last.searchIds.length}return i=(new Date).getTime()-i,!0!==e&&p.show.statusSearch&&setTimeout(function(){p.status(w2utils.lang("Search took")+" "+i/1e3+" "+w2utils.lang("sec"))},10),i}function g(e){for(var t=0,i=!1,s=0;s<p.searchData.length;s++){var n=p.searchData[s],a=p.getSearch(n.field);if(null!=n){null==a&&(a={field:n.field,type:n.type});var r=p.parseField(e,a.field),l=null==r||"object"==typeof r&&r.toString==f?"":String(r).toLowerCase();if(null!=n.value)if($.isArray(n.value)){d=n.value[0];var o=n.value[1]}else var d=String(n.value).toLowerCase();switch(n.operator){case"=":case"is":if(p.parseField(e,a.field)==n.value)t++;else if("date"==a.type){var u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field);(l=w2utils.formatDate(u,"yyyy-mm-dd"))==(d=w2utils.formatDate(w2utils.isDate(d,w2utils.settings.dateFormat,!0),"yyyy-mm-dd"))&&t++}else if("time"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field);(l=w2utils.formatTime(u,"hh24:mi"))==(d=w2utils.formatTime(d,"hh24:mi"))&&t++}else if("datetime"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field);(l=w2utils.formatDateTime(u,"yyyy-mm-dd|hh24:mm:ss"))==(d=w2utils.formatDateTime(w2utils.isDateTime(d,w2utils.settings.datetimeFormat,!0),"yyyy-mm-dd|hh24:mm:ss"))&&t++}break;case"between":if(-1!=["int","float","money","currency","percent"].indexOf(a.type))parseFloat(p.parseField(e,a.field))>=parseFloat(d)&&parseFloat(p.parseField(e,a.field))<=parseFloat(o)&&t++;else if("date"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field),l=w2utils.isDate(u,w2utils.settings.dateFormat,!0),d=w2utils.isDate(d,w2utils.settings.dateFormat,!0);null!=(o=w2utils.isDate(o,w2utils.settings.dateFormat,!0))&&(o=new Date(o.getTime()+864e5)),d<=l&&l<o&&t++}else if("time"==a.type){l=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field),d=w2utils.isTime(d,!0),o=w2utils.isTime(o,!0);d=(new Date).setHours(d.hours,d.minutes,d.seconds?d.seconds:0,0),o=(new Date).setHours(o.hours,o.minutes,o.seconds?o.seconds:0,0),d<=l&&l<o&&t++}else if("datetime"==a.type){l=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field),d=w2utils.isDateTime(d,w2utils.settings.datetimeFormat,!0);o=(o=w2utils.isDateTime(o,w2utils.settings.datetimeFormat,!0))&&new Date(o.getTime()+864e5),d<=l&&l<o&&t++}break;case"<=":i=!0;case"<":case"less":if(-1!=["int","float","money","currency","percent"].indexOf(a.type))((l=parseFloat(p.parseField(e,a.field)))<(d=parseFloat(n.value))||i&&l===d)&&t++;else if("date"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field);((l=w2utils.isDate(u,w2utils.settings.dateFormat,!0))<(d=w2utils.isDate(d,w2utils.settings.dateFormat,!0))||i&&l===d)&&t++}else if("time"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field);((l=w2utils.formatTime(u,"hh24:mi"))<(d=w2utils.formatTime(d,"hh24:mi"))||i&&l===d)&&t++}else if("datetime"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field),l=w2utils.formatDateTime(u,"yyyy-mm-dd|hh24:mm:ss"),d=w2utils.formatDateTime(w2utils.isDateTime(d,w2utils.settings.datetimeFormat,!0),"yyyy-mm-dd|hh24:mm:ss");l.length==d.length&&(l<d||i&&l===d)&&t++}break;case">=":i=!0;case">":case"more":if(-1!=["int","float","money","currency","percent"].indexOf(a.type)){l=parseFloat(p.parseField(e,a.field));((d=parseFloat(n.value))<l||i&&l===d)&&t++}else if("date"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field),l=w2utils.isDate(u,w2utils.settings.dateFormat,!0);((d=w2utils.isDate(d,w2utils.settings.dateFormat,!0))<l||i&&l===d)&&t++}else if("time"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field),l=w2utils.formatTime(u,"hh24:mi");((d=w2utils.formatTime(d,"hh24:mi"))<l||i&&l===d)&&t++}else if("datetime"==a.type){u=p.parseField(e,a.field+"_")instanceof Date?p.parseField(e,a.field+"_"):p.parseField(e,a.field),l=w2utils.formatDateTime(u,"yyyy-mm-dd|hh24:mm:ss"),d=w2utils.formatDateTime(w2utils.isDateTime(d,w2utils.settings.datetimeFormat,!0),"yyyy-mm-dd|hh24:mm:ss");l.length==d.length&&(d<l||i&&l===d)&&t++}break;case"in":u=n.value;n.svalue&&(u=n.svalue),-1===u.indexOf(w2utils.isFloat(r)?parseFloat(r):r)&&-1===u.indexOf(l)||t++;break;case"not in":u=n.value;n.svalue&&(u=n.svalue),-1===u.indexOf(w2utils.isFloat(r)?parseFloat(r):r)&&-1===u.indexOf(l)&&t++;break;case"begins":case"begins with":0===l.indexOf(d)&&t++;break;case"contains":0<=l.indexOf(d)&&t++;break;case"null":null==p.parseField(e,a.field)&&t++;break;case"not null":null!=p.parseField(e,a.field)&&t++;break;case"ends":case"ends with":var c=l.lastIndexOf(d);-1!==c&&c==l.length-d.length&&t++}}}if("OR"==p.last.logic&&0!==t||"AND"==p.last.logic&&t==p.searchData.length)return!0;if(e.w2ui&&e.w2ui.children&&!0!==e.w2ui.expanded)for(var h=0;h<e.w2ui.children.length;h++){if(g(e.w2ui.children[h]))return!0}return!1}function d(e){if(void 0!==e&&!s[e]){s[e]=!0;var t=p.get(e,!0);if(null!=t&&-1==$.inArray(t,p.last.searchIds)){var i=p.records[t];i&&i.w2ui&&d(i.w2ui.parent_recid),p.last.searchIds.push(t)}}}console.log("ERROR: grid.localSearch can only be used on local data source, grid.url should be empty.")},getRangeData:function(e,t){var i=this.get(e[0].recid,!0),s=this.get(e[1].recid,!0),n=e[0].column,a=e[1].column,r=[];if(n==a)for(var l=i;l<=s;l++){var o=(d=this.records[l])[this.columns[n].field]||null;!0!==t?r.push(o):r.push({data:o,column:n,index:l,record:d})}else if(i==s)for(var d=this.records[i],u=n;u<=a;u++){o=d[this.columns[u].field]||null;!0!==t?r.push(o):r.push({data:o,column:u,index:i,record:d})}else for(l=i;l<=s;l++){d=this.records[l];r.push([]);for(u=n;u<=a;u++){o=d[this.columns[u].field];!0!==t?r[r.length-1].push(o):r[r.length-1].push({data:o,column:u,index:l,record:d})}}return r},addRange:function(e){var t=0;if("row"==this.selectType)return t;$.isArray(e)||(e=[e]);for(var i=0;i<e.length;i++){if("object"!=typeof e[i]&&(e[i]={name:"selection"}),"selection"==e[i].name){if(!1===this.show.selectionBorder)continue;var s=this.getSelection();if(0===s.length){this.removeRange("selection");continue}var n=s[0],a=s[s.length-1]}else n=e[i].range[0],a=e[i].range[1];if(n){for(var r={name:e[i].name,range:[{recid:n.recid,column:n.column},{recid:a.recid,column:a.column}],style:e[i].style||""},l=!1,o=0;o<this.ranges.length;o++)if(this.ranges[o].name==e[i].name){l=o;break}!1!==l?this.ranges[l]=r:this.ranges.push(r),t++}}return this.refreshRanges(),t},removeRange:function(){for(var e=0,t=0;t<arguments.length;t++){var i=arguments[t];$("#grid_"+this.name+"_"+i).remove(),$("#grid_"+this.name+"_f"+i).remove();for(var s=this.ranges.length-1;0<=s;s--)this.ranges[s].name==i&&(this.ranges.splice(s,1),e++)}return e},refreshRanges:function(){if(0!==this.ranges.length){for(var r=this,e=(new Date).getTime(),t=$("#grid_"+this.name+"_frecords"),i=$("#grid_"+this.name+"_records"),s=0;s<this.ranges.length;s++){var n=this.ranges[s],a=n.range[0],l=n.range[1];null==a.index&&(a.index=this.get(a.recid,!0)),null==l.index&&(l.index=this.get(l.recid,!0));var o=$("#grid_"+this.name+"_rec_"+w2utils.escapeId(a.recid)+' td[col="'+a.column+'"]'),d=$("#grid_"+this.name+"_rec_"+w2utils.escapeId(l.recid)+' td[col="'+l.column+'"]'),u=$("#grid_"+this.name+"_frec_"+w2utils.escapeId(a.recid)+' td[col="'+a.column+'"]'),c=$("#grid_"+this.name+"_frec_"+w2utils.escapeId(l.recid)+' td[col="'+l.column+'"]'),h=l.column;a.column<this.last.colStart&&l.column>this.last.colStart&&(o=$("#grid_"+this.name+"_rec_"+w2utils.escapeId(a.recid)+' td[col="start"]')),a.column<this.last.colEnd&&l.column>this.last.colEnd&&(h='"end"',d=$("#grid_"+this.name+"_rec_"+w2utils.escapeId(l.recid)+' td[col="end"]'));var p=parseInt($("#grid_"+this.name+"_rec_top").next().attr("index")),f=parseInt($("#grid_"+this.name+"_rec_bottom").prev().attr("index")),g=parseInt($("#grid_"+this.name+"_frec_top").next().attr("index")),m=parseInt($("#grid_"+this.name+"_frec_bottom").prev().attr("index"));0===o.length&&a.index<p&&l.index>p&&(o=$("#grid_"+this.name+"_rec_top").next().find("td[col="+a.column+"]")),0===d.length&&l.index>f&&a.index<f&&(d=$("#grid_"+this.name+"_rec_bottom").prev().find("td[col="+h+"]")),0===u.length&&a.index<g&&l.index>g&&(u=$("#grid_"+this.name+"_frec_top").next().find("td[col="+a.column+"]")),0===c.length&&l.index>m&&a.index<m&&(c=$("#grid_"+this.name+"_frec_bottom").prev().find("td[col="+l.column+"]"));var w=$(this.box).find("#grid_"+this.name+"_editable").find(".w2ui-input"),v=w.attr("recid"),y=w.attr("column");if("selection"!=n.name||n.range[0].recid!=v||n.range[0].column!=y){var b=$("#grid_"+this.name+"_f"+n.name);if(0<u.length||0<c.length)if(0===b.length?(t.append('<div id="grid_'+this.name+"_f"+n.name+'" class="w2ui-selection" style="'+n.style+'">'+("selection"==n.name?'<div id="grid_'+this.name+'_resizer" class="w2ui-selection-resizer"></div>':"")+"</div>"),b=$("#grid_"+this.name+"_f"+n.name)):(b.attr("style",n.style),b.find(".w2ui-selection-resizer").show()),0===c.length&&(0===(c=$("#grid_"+this.name+"_frec_"+w2utils.escapeId(l.recid)+" td:last-child")).length&&(c=$("#grid_"+this.name+"_frec_bottom td:first-child")),b.css("border-right","0px"),b.find(".w2ui-selection-resizer").hide()),null!=a.recid&&null!=l.recid&&0<u.length&&0<c.length){var x=u.position().left-0+t.scrollLeft(),_=u.position().top-0+t.scrollTop();b.show().css({left:(0<x?x:0)+"px",top:(0<_?_:0)+"px",width:c.position().left-u.position().left+c.width()+2+"px",height:c.position().top-u.position().top+c.height()+1+"px"})}else b.hide();else b.hide();b=$("#grid_"+this.name+"_"+n.name);if(0<o.length||0<d.length)if(0===b.length?(i.append('<div id="grid_'+this.name+"_"+n.name+'" class="w2ui-selection" style="'+n.style+'">'+("selection"==n.name?'<div id="grid_'+this.name+'_resizer" class="w2ui-selection-resizer"></div>':"")+"</div>"),b=$("#grid_"+this.name+"_"+n.name)):b.attr("style",n.style),0===o.length&&0===(o=$("#grid_"+this.name+"_rec_"+w2utils.escapeId(a.recid)+" td:first-child")).length&&(o=$("#grid_"+this.name+"_rec_top td:first-child")),0!==c.length&&b.css("border-left","0px"),null!=a.recid&&null!=l.recid&&0<o.length&&0<d.length){x=o.position().left-0+i.scrollLeft(),_=o.position().top-0+i.scrollTop();b.show().css({left:(0<x?x:0)+"px",top:(0<_?_:0)+"px",width:d.position().left-o.position().left+d.width()+2+"px",height:d.position().top-o.position().top+d.height()+1+"px"})}else b.hide();else b.hide()}}$(this.box).find(".w2ui-selection-resizer").off("mousedown").on("mousedown",function(e){var t=r.getSelection();r.last.move={type:"expand",x:e.screenX,y:e.screenY,divX:0,divY:0,recid:t[0].recid,column:t[0].column,originalRange:[{recid:t[0].recid,column:t[0].column},{recid:t[t.length-1].recid,column:t[t.length-1].column}],newRange:[{recid:t[0].recid,column:t[0].column},{recid:t[t.length-1].recid,column:t[t.length-1].column}]},$(document).off(".w2ui-"+r.name).on("mousemove.w2ui-"+r.name,C).on("mouseup.w2ui-"+r.name,T),e.preventDefault()}).off("dblclick").on("dblclick",function(e){var t=r.trigger({phase:"before",type:"resizerDblClick",target:r.name,originalEvent:e});!0!==t.isCancelled&&r.trigger($.extend(t,{phase:"after"}))});var k={phase:"before",type:"selectionExtend",target:r.name,originalRange:null,newRange:null};return(new Date).getTime()-e}function C(e){var t=r.last.move;if(t&&"expand"==t.type){var i,s;t.divX=e.screenX-t.x,t.divY=e.screenY-t.y;var n=e.originalEvent.target;if("TD"!=n.tagName.toUpperCase()&&(n=$(n).parents("td")[0]),null!=$(n).attr("col")&&(s=parseInt($(n).attr("col"))),n=$(n).parents("tr")[0],i=$(n).attr("recid"),t.newRange[1].recid!=i||t.newRange[1].column!=s){var a=$.extend({},t.newRange);if(t.newRange=[{recid:t.recid,column:t.column},{recid:i,column:s}],!0===(k=r.trigger($.extend(k,{originalRange:t.originalRange,newRange:t.newRange}))).isCancelled)return t.newRange=a,void(k.newRange=a);r.removeRange("grid-selection-expand"),r.addRange({name:"grid-selection-expand",range:k.newRange,style:"background-color: rgba(100,100,100,0.1); border: 2px dotted rgba(100,100,100,0.5);"})}}}function T(e){r.removeRange("grid-selection-expand"),delete r.last.move,$(document).off(".w2ui-"+r.name),r.trigger($.extend(k,{phase:"after"}))}},select:function(){if(0===arguments.length)return 0;(new Date).getTime();var e=0,t=this.last.selection;this.multiSelect||this.selectNone();var i={phase:"before",type:"select",target:this.name};1==arguments.length?(i.multiple=!1,$.isPlainObject(arguments[0])?(i.recid=arguments[0].recid,i.column=arguments[0].column):i.recid=arguments[0]):(i.multiple=!0,i.recids=Array.prototype.slice.call(arguments,0));var s=this.trigger(i);if(!0===s.isCancelled)return 0;if("row"==this.selectType)for(var n=0;n<arguments.length;n++){var a="object"==typeof arguments[n]?arguments[n].recid:arguments[n];if(null!=(h=this.get(a,!0))){var r=null,l=null;if((0!==this.searchData.length||h+1>=this.last.range_start&&h+1<=this.last.range_end)&&(r=$("#grid_"+this.name+"_frec_"+w2utils.escapeId(a)),l=$("#grid_"+this.name+"_rec_"+w2utils.escapeId(a))),"row"==this.selectType){if(-1!=t.indexes.indexOf(h))continue;t.indexes.push(h),r&&l&&(r.addClass("w2ui-selected").data("selected","yes").find(".w2ui-col-number").addClass("w2ui-row-selected"),l.addClass("w2ui-selected").data("selected","yes").find(".w2ui-col-number").addClass("w2ui-row-selected"),r.find(".w2ui-grid-select-check").prop("checked",!0)),e++}}}else{var o={};for(n=0;n<arguments.length;n++){a="object"==typeof arguments[n]?arguments[n].recid:arguments[n];var d="object"==typeof arguments[n]?arguments[n].column:null;if(o[a]=o[a]||[],$.isArray(d))o[a]=d;else if(w2utils.isInt(d))o[a].push(d);else for(var u=0;u<this.columns.length;u++)this.columns[u].hidden||o[a].push(parseInt(u))}var c=[];for(var a in o){var h;if(null!=(h=this.get(a,!0))){r=null,l=null;h+1>=this.last.range_start&&h+1<=this.last.range_end&&(r=$("#grid_"+this.name+"_rec_"+w2utils.escapeId(a)),l=$("#grid_"+this.name+"_frec_"+w2utils.escapeId(a)));var p=t.columns[h]||[];-1==t.indexes.indexOf(h)&&t.indexes.push(h);for(var f=0;f<o[a].length;f++)-1==p.indexOf(o[a][f])&&p.push(o[a][f]);p.sort(function(e,t){return e-t});for(f=0;f<o[a].length;f++){var g=o[a][f];-1==c.indexOf(g)&&c.push(g),r&&(r.find("#grid_"+this.name+"_data_"+h+"_"+g).addClass("w2ui-selected"),r.find(".w2ui-col-number").addClass("w2ui-row-selected"),r.data("selected","yes"),r.find(".w2ui-grid-select-check").prop("checked",!0)),l&&(l.find("#grid_"+this.name+"_data_"+h+"_"+g).addClass("w2ui-selected"),l.find(".w2ui-col-number").addClass("w2ui-row-selected"),l.data("selected","yes"),l.find(".w2ui-grid-select-check").prop("checked",!0)),e++}t.columns[h]=p}}for(var m=0;m<c.length;m++)$(this.box).find("#grid_"+this.name+"_column_"+c[m]+" .w2ui-col-header").addClass("w2ui-col-selected")}t.indexes.sort(function(e,t){return e-t});var w=0<this.records.length&&t.indexes.length==this.records.length,v=0<t.indexes.length&&0!==this.searchData.length&&t.indexes.length==this.last.searchIds.length;return w||v?$("#grid_"+this.name+"_check_all").prop("checked",!0):$("#grid_"+this.name+"_check_all").prop("checked",!1),this.status(),this.addRange("selection"),this.updateToolbar(t,w),this.trigger($.extend(s,{phase:"after"})),e},unselect:function(){for(var e=0,t=this.last.selection,i=0;i<arguments.length;i++){var s="object"==typeof arguments[i]?arguments[i].recid:arguments[i],n=this.get(s);if(null!=n){var a=this.get(n.recid,!0),r=$("#grid_"+this.name+"_frec_"+w2utils.escapeId(s)),l=$("#grid_"+this.name+"_rec_"+w2utils.escapeId(s));if("row"==this.selectType){if(-1==t.indexes.indexOf(a))continue;if(!0===(c=this.trigger({phase:"before",type:"unselect",target:this.name,recid:s,index:a})).isCancelled)continue;t.indexes.splice(t.indexes.indexOf(a),1),r.removeClass("w2ui-selected w2ui-inactive").removeData("selected").find(".w2ui-col-number").removeClass("w2ui-row-selected"),l.removeClass("w2ui-selected w2ui-inactive").removeData("selected").find(".w2ui-col-number").removeClass("w2ui-row-selected"),0!=r.length&&(r[0].style.cssText="height: "+this.recordHeight+"px; "+r.attr("custom_style"),l[0].style.cssText="height: "+this.recordHeight+"px; "+l.attr("custom_style")),r.find(".w2ui-grid-select-check").prop("checked",!1),e++}else{var o=arguments[i].column;if(!w2utils.isInt(o)){for(var d=[],u=0;u<this.columns.length;u++)this.columns[u].hidden||d.push({recid:s,column:u});return this.unselect.apply(this,d)}var c,h=t.columns[a];if(!$.isArray(h)||-1==h.indexOf(o))continue;if(!0===(c=this.trigger({phase:"before",type:"unselect",target:this.name,recid:s,column:o})).isCancelled)continue;h.splice(h.indexOf(o),1),$("#grid_"+this.name+"_rec_"+w2utils.escapeId(s)).find(" > td[col="+o+"]").removeClass("w2ui-selected w2ui-inactive"),$("#grid_"+this.name+"_frec_"+w2utils.escapeId(s)).find(" > td[col="+o+"]").removeClass("w2ui-selected w2ui-inactive");var p=!1,f=!1,g=this.getSelection();for(u=0;u<g.length;u++)g[u].column==o&&(p=!0),g[u].recid==s&&(f=!0);p||$(this.box).find(".w2ui-grid-columns td[col="+o+"] .w2ui-col-header, .w2ui-grid-fcolumns td[col="+o+"] .w2ui-col-header").removeClass("w2ui-col-selected"),f||$("#grid_"+this.name+"_frec_"+w2utils.escapeId(s)).find(".w2ui-col-number").removeClass("w2ui-row-selected"),e++,0===h.length&&(delete t.columns[a],t.indexes.splice(t.indexes.indexOf(a),1),r.removeData("selected"),r.find(".w2ui-grid-select-check").prop("checked",!1),l.removeData("selected"))}this.trigger($.extend(c,{phase:"after"}))}}var m=0<this.records.length&&t.indexes.length==this.records.length,w=0<t.indexes.length&&0!==this.searchData.length&&t.indexes.length==this.last.searchIds.length;return m||w?$("#grid_"+this.name+"_check_all").prop("checked",!0):$("#grid_"+this.name+"_check_all").prop("checked",!1),this.status(),this.addRange("selection"),this.updateToolbar(t,m),e},selectAll:function(){var e=(new Date).getTime();if(!1!==this.multiSelect){var t=this.trigger({phase:"before",type:"select",target:this.name,all:!0});if(!0!==t.isCancelled){for(var i="object"!=typeof this.url?this.url:this.url.get,s=this.last.selection,n=[],a=0;a<this.columns.length;a++)n.push(a);if(s.indexes=[],i||0===this.searchData.length){var r=this.records.length;0==this.searchData.length||i||(r=this.last.searchIds.length);for(a=0;a<r;a++)s.indexes.push(a),"row"!=this.selectType&&(s.columns[a]=n.slice())}else for(var a=0;a<this.last.searchIds.length;a++)s.indexes.push(this.last.searchIds[a]),"row"!=this.selectType&&(s.columns[this.last.searchIds[a]]=n.slice());return"row"==this.selectType?($(this.box).find(".w2ui-grid-records tr").not(".w2ui-empty-record").addClass("w2ui-selected").data("selected","yes").find(".w2ui-col-number").addClass("w2ui-row-selected"),$(this.box).find(".w2ui-grid-frecords tr").not(".w2ui-empty-record").addClass("w2ui-selected").data("selected","yes").find(".w2ui-col-number").addClass("w2ui-row-selected")):($(this.box).find(".w2ui-grid-columns td .w2ui-col-header, .w2ui-grid-fcolumns td .w2ui-col-header").addClass("w2ui-col-selected"),$(this.box).find(".w2ui-grid-records tr .w2ui-col-number").addClass("w2ui-row-selected"),$(this.box).find(".w2ui-grid-records tr").not(".w2ui-empty-record").find(".w2ui-grid-data").not(".w2ui-col-select").addClass("w2ui-selected").data("selected","yes"),$(this.box).find(".w2ui-grid-frecords tr .w2ui-col-number").addClass("w2ui-row-selected"),$(this.box).find(".w2ui-grid-frecords tr").not(".w2ui-empty-record").find(".w2ui-grid-data").not(".w2ui-col-select").addClass("w2ui-selected").data("selected","yes")),$(this.box).find("input.w2ui-grid-select-check").prop("checked",!0),1==(s=this.getSelection(!0)).length?this.toolbar.enable("w2ui-edit"):this.toolbar.disable("w2ui-edit"),1<=s.length?this.toolbar.enable("w2ui-delete"):this.toolbar.disable("w2ui-delete"),this.addRange("selection"),$("#grid_"+this.name+"_check_all").prop("checked",!0),this.status(),this.updateToolbar({indexes:s},!0),this.trigger($.extend(t,{phase:"after"})),(new Date).getTime()-e}}},selectNone:function(){var e=(new Date).getTime(),t=this.trigger({phase:"before",type:"unselect",target:this.name,all:!0});if(!0!==t.isCancelled){var i=this.last.selection;return"row"==this.selectType?($(this.box).find(".w2ui-grid-records tr.w2ui-selected").removeClass("w2ui-selected w2ui-inactive").removeData("selected").find(".w2ui-col-number").removeClass("w2ui-row-selected"),$(this.box).find(".w2ui-grid-frecords tr.w2ui-selected").removeClass("w2ui-selected w2ui-inactive").removeData("selected").find(".w2ui-col-number").removeClass("w2ui-row-selected")):($(this.box).find(".w2ui-grid-columns td .w2ui-col-header, .w2ui-grid-fcolumns td .w2ui-col-header").removeClass("w2ui-col-selected"),$(this.box).find(".w2ui-grid-records tr .w2ui-col-number").removeClass("w2ui-row-selected"),$(this.box).find(".w2ui-grid-frecords tr .w2ui-col-number").removeClass("w2ui-row-selected"),$(this.box).find(".w2ui-grid-data.w2ui-selected").removeClass("w2ui-selected w2ui-inactive").removeData("selected")),$(this.box).find("input.w2ui-grid-select-check").prop("checked",!1),i.indexes=[],i.columns={},this.toolbar.disable("w2ui-edit","w2ui-delete"),this.removeRange("selection"),$("#grid_"+this.name+"_check_all").prop("checked",!1),this.status(),this.updateToolbar(i,!1),this.trigger($.extend(t,{phase:"after"})),(new Date).getTime()-e}},updateToolbar:function(i,e){var s=this,n=i&&i.indexes?i.indexes.length:0;function a(e,t){0===e.batch&&(0<n?s.toolbar.enable(t+e.id):s.toolbar.disable(t+e.id)),null!=e.batch&&!isNaN(e.batch)&&0<e.batch&&(n==e.batch?s.toolbar.enable(t+e.id):s.toolbar.disable(t+e.id)),"function"==typeof e.batch&&e.batch("cell"==s.selectType?i:i?i.indexes:null)}this.toolbar.items.forEach(function(t){a(t,""),Array.isArray(t.items)&&t.items.forEach(function(e){a(e,t.id+":")})})},getSelection:function(e){var t=[],i=this.last.selection;if("row"==this.selectType){for(var s=0;s<i.indexes.length;s++)this.records[i.indexes[s]]&&(!0===e?t.push(i.indexes[s]):t.push(this.records[i.indexes[s]].recid));return t}for(s=0;s<i.indexes.length;s++){var n=i.columns[i.indexes[s]];if(this.records[i.indexes[s]])for(var a=0;a<n.length;a++)t.push({recid:this.records[i.indexes[s]].recid,index:parseInt(i.indexes[s]),column:n[a]})}return t},search:function(e,t){for(var i="object"!=typeof this.url?this.url:this.url.get,s=[],n=this.last.multi,a=this.last.logic,r=this.last.field,l=this.last.search,o=!1,d=0;d<this.searches.length;d++)this.searches[d].hidden&&null!=this.searches[d].value&&(s.push({field:this.searches[d].field,operator:this.searches[d].operator||"is",type:this.searches[d].type,value:this.searches[d].value||""}),o=!0);if(0===arguments.length){l="";for(d=0;d<this.searches.length;d++){var u=this.searches[d],c=$("#grid_"+this.name+"_operator_"+d).val(),h=$("#grid_"+this.name+"_field_"+d),p=$("#grid_"+this.name+"_field2_"+d),f=h.val(),g=p.val(),m=null,w=null;if(-1!=["int","float","money","currency","percent"].indexOf(u.type)){var v=h.data("w2field"),y=p.data("w2field");v&&(f=v.clean(f)),y&&(g=y.clean(g))}if(-1!=["list","enum"].indexOf(u.type))if(f=h.data("selected")||{},$.isArray(f)){m=[];for(var b=0;b<f.length;b++)m.push(w2utils.isFloat(f[b].id)?parseFloat(f[b].id):String(f[b].id).toLowerCase()),delete f[b].hidden;$.isEmptyObject(f)&&(f="")}else w=f.text||"",f=f.id||"";if(""!==f&&null!=f||null!=g&&""!==g){var x={field:u.field,type:u.type,operator:c};"between"==c?$.extend(x,{value:[f,g]}):"in"==c&&"string"==typeof f?$.extend(x,{value:f.split(",")}):"not in"==c&&"string"==typeof f?$.extend(x,{value:f.split(",")}):$.extend(x,{value:f}),m&&$.extend(x,{svalue:m}),w&&$.extend(x,{text:w});try{"date"==u.type&&"between"==c&&(x.value[0]=f,x.value[1]=g),"date"==u.type&&"is"==c&&(x.value=f)}catch(e){}s.push(x),n=!0}}a="AND"}if("string"==typeof e&&(1==arguments.length&&(t=e,e="all"),r=e,n=!1,a=o?"AND":"OR",null!=(l=t)))if("all"==e.toLowerCase())if(0<this.searches.length)for(d=0;d<this.searches.length;d++){if("text"==(u=this.searches[d]).type||"alphanumeric"==u.type&&w2utils.isAlphaNumeric(t)||"int"==u.type&&w2utils.isInt(t)||"float"==u.type&&w2utils.isFloat(t)||"percent"==u.type&&w2utils.isFloat(t)||("hex"==u.type||"color"==u.type)&&w2utils.isHex(t)||"currency"==u.type&&w2utils.isMoney(t)||"money"==u.type&&w2utils.isMoney(t)||"date"==u.type&&w2utils.isDate(t)||"time"==u.type&&w2utils.isTime(t)||"datetime"==u.type&&w2utils.isDateTime(t)||"datetime"==u.type&&w2utils.isDate(t)||"enum"==u.type&&w2utils.isAlphaNumeric(t)||"list"==u.type&&w2utils.isAlphaNumeric(t)){x={field:u.field,type:u.type,operator:null!=u.operator?u.operator:"text"==u.type?this.textSearch:"is",value:t};""!=$.trim(t)&&s.push(x)}if(-1!=["int","float","money","currency","percent"].indexOf(u.type)&&2==$.trim(String(t)).split("-").length){var _=$.trim(String(t)).split("-");x={field:u.field,type:u.type,operator:null!=u.operator?u.operator:"between",value:[_[0],_[1]]};s.push(x)}if(-1!=["list","enum"].indexOf(u.type)){var k=[];null==u.options&&(u.options={}),Array.isArray(u.options.items)||(u.options.items=[]);for(b=0;b<u.options.items;b++){x=u.options.items[b];try{var C=new RegExp(t,"i");C.test(x)&&k.push(b),x.text&&C.test(x.text)&&k.push(x.id)}catch(e){}}if(0<k.length){x={field:u.field,type:u.type,operator:null!=u.operator?u.operator:"in",value:k};s.push(x)}}}else for(d=0;d<this.columns.length;d++){x={field:this.columns[d].field,type:"text",operator:this.textSearch,value:t};s.push(x)}else{var T=$("#grid_"+this.name+"_search_all");if(null==(u=this.getSearch(e))&&(u={field:e,type:"text"}),u.field==e&&(this.last.label=u.label),""!==t){var S=this.textSearch,O=t;if(-1!=["date","time","datetime"].indexOf(u.type)&&(S="is"),-1!=["list","enum"].indexOf(u.type))S="is",O=(x=T.data("selected"))&&!$.isEmptyObject(x)?x.id:"";if("int"==u.type&&""!==t){if(S="is",-1!=String(t).indexOf("-"))2==(x=t.split("-")).length&&(S="between",O=[parseInt(x[0]),parseInt(x[1])]);if(-1!=String(t).indexOf(",")){x=t.split(",");S="in",O=[];for(d=0;d<x.length;d++)O.push(x[d])}}null!=u.operator&&(S=u.operator);x={field:u.field,type:u.type,operator:S,value:O};s.push(x)}}if($.isArray(e)){var D="AND";"string"==typeof t&&"OR"!=(D=t.toUpperCase())&&"AND"!=D&&(D="AND"),n=!(l=""),a=D;for(d=0;d<e.length;d++){var z=e[d];if(null==(u=this.getSearch(z.field))&&(u={type:"text",operator:this.textSearch}),$.isArray(z.value))for(b=0;b<z.value.length;b++)"string"==typeof z.value[b]&&(z.value[b]=z.value[b].toLowerCase());s.push($.extend(!0,{},u,z))}}var I=this.trigger({phase:"before",type:"search",target:this.name,multi:0===arguments.length,searchField:e||"multi",searchValue:e?t:"multi",searchData:s,searchLogic:a});!0!==I.isCancelled&&(this.searchData=I.searchData,this.last.field=r,this.last.search=l,this.last.multi=n,this.last.logic=I.searchLogic,this.last.scrollTop=0,this.last.scrollLeft=0,this.last.selection.indexes=[],this.last.selection.columns={},this.searchClose(),i?(this.last.xhr_offset=0,this.reload()):(this.localSearch(),this.refresh()),this.trigger($.extend(I,{phase:"after"})))},searchOpen:function(){if(this.box&&0!==this.searches.length){var t=this,i=t.toolbar.get("w2ui-search-advanced"),s="#tb_"+t.toolbar.name+"_item_"+w2utils.escapeId(i.id)+" table.w2ui-button",n=this.trigger({phase:"before",type:"searchOpen",target:this.name});!0!==n.isCancelled?$("#tb_"+this.name+"_toolbar_item_w2ui-search-advanced").w2overlay({html:this.getSearchesHTML(),name:this.name+"-searchOverlay",left:-10,class:"w2ui-grid-searches",onShow:function(){t.initSearches(),$("#w2ui-overlay-"+t.name+"-searchOverlay .w2ui-grid-searches").data("grid-name",t.name);var e=$("#w2ui-overlay-"+this.name+"-searchOverlay .w2ui-grid-searches *[rel=search]");0<e.length&&e[0].focus(),i.checked||(i.checked=!0,$(s).addClass("checked")),t.trigger($.extend(n,{phase:"after"}))},onHide:function(){i.checked=!1,$(s).removeClass("checked")}}):setTimeout(function(){t.toolbar.uncheck("w2ui-search-advanced")},1)}},searchClose:function(){this.box&&0!==this.searches.length&&(this.toolbar&&this.toolbar.uncheck("w2ui-search-advanced","w2ui-column-on-off"),$().w2overlay({name:this.name+"-searchOverlay"}))},searchReset:function(e){for(var t=[],i=!1,s=0;s<this.searches.length;s++)this.searches[s].hidden&&null!=this.searches[s].value&&(t.push({field:this.searches[s].field,operator:this.searches[s].operator||"is",type:this.searches[s].type,value:this.searches[s].value||""}),i=!0);var n=this.trigger({phase:"before",type:"search",reset:!0,target:this.name,searchData:t});if(!0!==n.isCancelled){if(this.searchData=n.searchData,this.last.search="",this.last.logic=i?"AND":"OR",0<this.searches.length)if(this.multiSearch&&this.show.searchAll)this.last.field="all",this.last.label=w2utils.lang("All Fields");else{for(var a=0;a<this.searches.length&&(this.searches[a].hidden||!1===this.searches[a].simple);)a++;a>=this.searches.length?(this.last.field="",this.last.label=""):(this.last.field=this.searches[a].field,this.last.label=this.searches[a].label)}this.last.multi=!1,this.last.xhr_offset=0,this.last.scrollTop=0,this.last.scrollLeft=0,this.last.selection.indexes=[],this.last.selection.columns={},this.searchClose(),$("#grid_"+this.name+"_search_all").val("").removeData("selected"),e||this.reload(),this.trigger($.extend(n,{phase:"after"}))}},searchShowFields:function(e){var t=$("#grid_"+this.name+"_search_all");if(!0!==e){for(var i='<div class="w2ui-select-field"><table><tbody>',s=-1;s<this.searches.length;s++){var n=this.searches[s],a=n?n.field:null,r=this.getColumn(a),l=!1,o="This column is hidden";if(1==this.show.searchHiddenMsg&&-1!=s&&(null==r||!0===r.hidden&&!1!==r.hideable)&&(l=!0,null==r&&(o="This column does not exist")),-1==s){if(!this.multiSearch||!this.show.searchAll)continue;n={field:"all",label:w2utils.lang("All Fields")}}else{if(null!=r&&!1===r.hideable)continue;if(!0===this.searches[s].hidden||!1===this.searches[s].simple)continue}null==n.label&&null!=n.caption&&(console.log("NOTICE: grid search.caption property is deprecated, please use search.label. Search ->",n),n.label=n.caption),i+='<tr style="'+(l?"color: silver":"")+'" '+(l?"onmouseenter=\"jQuery(this).w2tag({ top: 4, html: '"+o+'\' })" onmouseleave="jQuery(this).w2tag()"':"")+(w2utils.isIOS?"onTouchStart":"onClick")+"=\"w2ui['"+this.name+"'].initAllField('"+n.field+"');      event.stopPropagation(); jQuery('#grid_"+this.name+"_search_all').w2overlay({ name: '"+this.name+'-searchFields\' });">   <td>       <span class="w2ui-column-check w2ui-icon-'+(n.field==this.last.field?"check":"empty")+'"></span>   </td>   <td>'+n.label+"</td></tr>"}i+="</tbody></table></div>";var d=this.name+"-searchFields";1==$("#w2ui-overlay-"+d).length&&(i=""),setTimeout(function(){$(t).w2overlay({html:i,name:d,left:-10})},1)}else $(t).w2overlay({name:this.name+"-searchFields"})},initAllField:function(e,t){var i=$("#grid_"+this.name+"_search_all");if("all"==e){var s={field:"all",label:w2utils.lang("All Fields")};i.w2field("clear"),i.change()}else{if(null==(s=this.getSearch(e)))return;var n=s.type;-1!=["enum","select"].indexOf(n)&&(n="list"),i.w2field(n,$.extend({},s.options,{suffix:"",autoFormat:!1,selected:t})),-1!=["list","enum","date","time","datetime"].indexOf(s.type)&&(this.last.search="",this.last.item="",i.val(""),$("#grid_"+this.name+"_searchClear").hide())}""!=this.last.search?(this.last.label=s.label,this.search(s.field,this.last.search)):(this.last.field=s.field,this.last.label=s.label),i.attr("placeholder",w2utils.lang(s.label||s.caption||s.field)),$().w2overlay({name:this.name+"-searchFields"})},clear:function(e){this.total=0,this.records=[],this.summary=[],this.last.xhr_offset=0,this.last.idCache={},this.reset(!0),e||this.refresh()},reset:function(e){this.last.scrollTop=0,this.last.scrollLeft=0,this.last.selection={indexes:[],columns:{}},this.last.range_start=null,this.last.range_end=null,$("#grid_"+this.name+"_records").prop("scrollTop",0),e||this.refresh()},skip:function(e,t){("object"!=typeof this.url?this.url:this.url.get)?(this.offset=parseInt(e),this.offset>this.total&&(this.offset=this.total-this.limit),(this.offset<0||!w2utils.isInt(this.offset))&&(this.offset=0),this.clear(!0),this.reload(t)):console.log("ERROR: grid.skip() can only be called when you have remote data source.")},load:function(e,t){null!=e?(this.clear(!0),this.request("get",{},e,t)):console.log('ERROR: You need to provide url argument when calling .load() method of "'+this.name+'" object.')},reload:function(e){var t=this,i="object"!=typeof this.url?this.url:this.url.get;t.selectionSave(),i?this.load(i,function(){t.selectionRestore(),"function"==typeof e&&e()}):(this.reset(!0),this.localSearch(),this.selectionRestore(),"function"==typeof e&&e({status:"success"}))},request:function(r,e,t,l){if(null==e&&(e={}),""!=t&&null!=t||(t=this.url),""!=t&&null!=t){w2utils.isInt(this.offset)||(this.offset=0),w2utils.isInt(this.last.xhr_offset)||(this.last.xhr_offset=0);var i={limit:this.limit,offset:parseInt(this.offset)+parseInt(this.last.xhr_offset),searchLogic:this.last.logic,search:this.searchData.map(function(e){var t=$.extend({},e);return this.searchMap&&this.searchMap[t.field]&&(t.field=this.searchMap[t.field]),t}.bind(this)),sort:this.sortData.map(function(e){var t=$.extend({},e);return this.sortMap&&this.sortMap[t.field]&&(t.field=this.sortMap[t.field]),t}.bind(this))};if(0===this.searchData.length&&(delete i.search,delete i.searchLogic),0===this.sortData.length&&delete i.sort,$.extend(i,this.postData),$.extend(i,e),"delete"!=r&&"save"!=r||(delete i.limit,delete i.offset,"delete"==(i.action=r)&&(i[this.recid||"recid"]=this.getSelection())),"get"==r){if(!0===(s=this.trigger({phase:"before",type:"request",target:this.name,url:t,postData:i,httpHeaders:this.httpHeaders})).isCancelled)return void("function"==typeof l&&l({status:"error",message:"Request aborted."}))}else var s={url:t,postData:i,httpHeaders:this.httpHeaders};var o=this;if(0===this.last.xhr_offset)o.lock(w2utils.lang(o.msgRefresh),!0);else{var n=$("#grid_"+this.name+"_rec_more, #grid_"+this.name+"_frec_more");!0===this.autoLoad?n.show().find("td").html('<div><div style="width: 20px; height: 20px;" class="w2ui-spinner"></div></div>'):n.find("td").html("<div>"+w2utils.lang("Load")+" "+o.limit+" "+w2utils.lang("More")+"...</div>")}if(this.last.xhr)try{this.last.xhr.abort()}catch(e){}if(t="object"!=typeof s.url?s.url:s.url.get,"save"==r&&"object"==typeof s.url&&(t=s.url.save),"delete"==r&&"object"==typeof s.url&&(t=s.url.remove),!$.isEmptyObject(o.routeData)){var a=w2utils.parseRoute(t);if(0<a.keys.length)for(var d=0;d<a.keys.length;d++)null!=o.routeData[a.keys[d].name]&&(t=t.replace(new RegExp(":"+a.keys[d].name,"g"),o.routeData[a.keys[d].name]))}var u={type:"POST",url:t,data:s.postData,headers:s.httpHeaders,dataType:"text"};switch(this.dataType||w2utils.settings.dataType){case"HTTP":u.data="object"==typeof u.data?String($.param(u.data,!1)).replace(/%5B/g,"[").replace(/%5D/g,"]"):u.data;break;case"HTTPJSON":u.data={request:JSON.stringify(u.data)};break;case"RESTFULL":u.type="GET","save"==r&&(u.type="PUT"),"delete"==r&&(u.type="DELETE"),u.data="object"==typeof u.data?String($.param(u.data,!1)).replace(/%5B/g,"[").replace(/%5D/g,"]"):u.data;break;case"RESTFULLJSON":u.type="GET","save"==r&&(u.type="PUT"),"delete"==r&&(u.type="DELETE"),u.data=JSON.stringify(u.data),u.contentType="application/json";break;case"JSON":u.type="POST",u.data=JSON.stringify(u.data),u.contentType="application/json"}this.method&&(u.type=this.method),this.last.xhr_cmd=r,this.last.xhr_start=(new Date).getTime(),this.last.xhr=$.ajax(u).done(function(e,t,i){o.requestComplete(t,r,l)}).fail(function(e,t,i){var s={status:t,error:i,rawResponseText:e.responseText},n=o.trigger({phase:"before",type:"error",error:s,xhr:e});if(!0!==n.isCancelled){if("abort"!=t){var a;try{a=$.parseJSON(e.responseText)}catch(e){}console.log("ERROR: Server communication failed.","\n   EXPECTED:",{status:"success",total:5,records:[{recid:1,field:"value"}]},"\n         OR:",{status:"error",message:"error message"},"\n   RECEIVED:","object"==typeof a?a:e.responseText),o.requestComplete("error",r,l)}o.trigger($.extend(n,{phase:"after"}))}}),"get"==r&&this.trigger($.extend(s,{phase:"after"}))}},requestComplete:function(status,cmd,callBack){var obj=this;this.unlock(),setTimeout(function(){obj.show.statusResponse&&obj.status(w2utils.lang("Server Response")+" "+((new Date).getTime()-obj.last.xhr_start)/1e3+" "+w2utils.lang("sec"))},10),this.last.pull_more=!1,this.last.pull_refresh=!0;var event_name="load";"save"==this.last.xhr_cmd&&(event_name="save"),"delete"==this.last.xhr_cmd&&(event_name="delete");var edata=this.trigger({phase:"before",target:this.name,type:event_name,xhr:this.last.xhr,status:status});if(!0!==edata.isCancelled){var data,responseText=this.last.xhr.responseText;if("error"!=status){if(null!=responseText&&""!=responseText){if("object"==typeof responseText)data=responseText;else if("function"==typeof obj.parser)data=obj.parser(responseText),"object"!=typeof data&&console.log("ERROR: Your parser did not return proper object");else try{eval("data = "+responseText)}catch(e){}if(null==data?data={status:"error",message:w2utils.lang(this.msgNotJSON),responseText:responseText}:Array.isArray(data)&&(data={status:"success",records:data,total:data.length}),obj.recid&&data.records)for(var i=0;i<data.records.length;i++)data.records[i].recid=data.records[i][obj.recid];if("error"==data.status)obj.error(data.message);else{if("get"==cmd){if(null==data.total&&(data.total=-1),null==data.records&&(data.records=[]),data.records.length==this.limit?this.last.xhr_hasMore=!0:(this.last.xhr_hasMore=!1,this.total=this.offset+this.last.xhr_offset+data.records.length),0===this.last.xhr_offset)this.records=[],this.summary=[],w2utils.isInt(data.total)&&(this.total=parseInt(data.total));else if(-1!=data.total&&parseInt(data.total)!=parseInt(this.total))return void this.message(w2utils.lang(this.msgNeedReload),function(){delete this.last.xhr_offset,this.reload()}.bind(this));if(data.records)for(var r=0;r<data.records.length;r++)this.records.push(data.records[r]);if(data.summary){this.summary=[];for(var r=0;r<data.summary.length;r++)this.summary.push(data.summary[r])}}if("delete"==cmd)return this.reset(),void this.reload()}}}else data={status:"error",message:w2utils.lang(this.msgAJAXerror),responseText:responseText},obj.error(w2utils.lang(this.msgAJAXerror));var url="object"!=typeof this.url?this.url:this.url.get;url||(this.localSort(),this.localSearch()),this.total=parseInt(this.total),0===this.last.xhr_offset?this.refresh():(this.scroll(),this.resize()),"function"==typeof callBack&&callBack(data),this.trigger($.extend(edata,{phase:"after"}))}else"function"==typeof callBack&&callBack({status:"error",message:"Request aborted."})},error:function(e){var t=this.trigger({target:this.name,type:"error",message:e,xhr:this.last.xhr});!0!==t.isCancelled?(this.message(e),this.trigger($.extend(t,{phase:"after"}))):"function"==typeof callBack&&callBack({status:"error",message:"Request aborted."})},getChanges:function(e){var t=[];if(void 0===e)e=this.records;for(var i=0;i<e.length;i++){var s=e[i];if(s.w2ui){if(null!=s.w2ui.changes){var n={};n[this.recid||"recid"]=s.recid,t.push($.extend(!0,n,s.w2ui.changes))}!0!==s.w2ui.expanded&&s.w2ui.children&&s.w2ui.children.length&&$.merge(t,this.getChanges(s.w2ui.children))}}return t},mergeChanges:function(){for(var changes=this.getChanges(),c=0;c<changes.length;c++){var record=this.get(changes[c].recid);for(var s in changes[c])if("recid"!=s){"object"==typeof changes[c][s]&&(changes[c][s]=changes[c][s].text);try{-1!=s.indexOf(".")?eval("record['"+s.replace(/\./g,"']['")+"'] = changes[c][s]"):record[s]=changes[c][s]}catch(e){console.log("ERROR: Cannot merge. ",e.message||"",e)}record.w2ui&&delete record.w2ui.changes}}this.refresh()},save:function(t){var i=this,e=this.getChanges(),s="object"!=typeof this.url?this.url:this.url.save,n=this.trigger({phase:"before",target:this.name,type:"save",changes:e});!0!==n.isCancelled?s?this.request("save",{changes:n.changes},null,function(e){"error"!==e.status&&i.mergeChanges(),i.trigger($.extend(n,{phase:"after"})),"function"==typeof t&&t(e)}):(this.mergeChanges(),this.trigger($.extend(n,{phase:"after"}))):s&&"function"==typeof t&&t({status:"error",message:"Request aborted."})},editField:function(d,u,e,t){var c=this;if(!0!==this.last.inEditMode){b=c.get(d,!0);var i=c.getCellEditable(b,u);if(i){var h=c.records[b],p=c.columns[u],s=!0===p.frozen?"_f":"_";if(-1==["enum","file"].indexOf(i.type)){var n=c.trigger({phase:"before",type:"editField",target:c.name,recid:d,column:u,value:e,index:b,originalEvent:t});if(!0!==n.isCancelled&&(e=n.value,this.last.inEditMode=!0,this.last._edit={value:e,index:b,column:u,recid:d},this.selectNone(),this.select({recid:d,column:u}),-1==["checkbox","check"].indexOf(i.type))){var a=$("#grid_"+c.name+s+"rec_"+w2utils.escapeId(d)),r=a.find("[col="+u+"] > div");$(this.box).find("div.w2ui-edit-box").remove(),"row"!=this.selectType&&($("#grid_"+this.name+s+"selection").attr("id","grid_"+this.name+"_editable").removeClass("w2ui-selection").addClass("w2ui-edit-box").prepend('<div style="position: absolute; top: 0px; bottom: 0px; left: 0px; right: 0px;"></div>').find(".w2ui-selection-resizer").remove(),r=$("#grid_"+this.name+"_editable >div:first-child")),null==i.inTag&&(i.inTag=""),null==i.outTag&&(i.outTag=""),null==i.style&&(i.style=""),null==i.items&&(i.items=[]);var l=h.w2ui&&h.w2ui.changes&&null!=h.w2ui.changes[p.field]?w2utils.stripTags(h.w2ui.changes[p.field]):w2utils.stripTags(h[p.field]);null==l&&(l="");var o="object"!=typeof l?l:"";null!=n.old_value&&(o=n.old_value),null!=e&&(l=e);var f=null!=p.style?p.style+";":"";switch("string"==typeof p.render&&-1!=["number","int","float","money","percent","size"].indexOf(p.render.split(":")[0])&&(f+="text-align: right;"),0<i.items.length&&!$.isPlainObject(i.items[0])&&(i.items=w2obj.field.prototype.normMenu(i.items)),i.type){case"select":for(var g="",m=0;m<i.items.length;m++)g+='<option value="'+i.items[m].id+'"'+(i.items[m].id==l?' selected="selected"':"")+">"+i.items[m].text+"</option>";r.addClass("w2ui-editable").html('<select id="grid_'+c.name+"_edit_"+d+"_"+u+'" column="'+u+'" class="w2ui-input"    style="width: 100%; pointer-events: auto; padding: 0 0 0 3px; margin: 0px; border-left: 0; border-right: 0; border-radius: 0px;            outline: none; font-family: inherit;'+f+i.style+'"     field="'+p.field+'" recid="'+d+'"     '+i.inTag+">"+g+"</select>"+i.outTag),setTimeout(function(){r.find("select").on("change",function(e){delete c.last.move}).on("blur",function(e){1!=$(this).data("keep-open")&&c.editChange.call(c,this,b,u,e)})},10);break;case"div":var w="font-family: "+(y=a.find("[col="+u+"] > div")).css("font-family")+"; font-size: "+y.css("font-size")+";";r.addClass("w2ui-editable").html('<div id="grid_'+c.name+"_edit_"+d+"_"+u+'" class="w2ui-input"    contenteditable style="'+w+f+i.style+'" autocorrect="off" autocomplete="off" spellcheck="false"     field="'+p.field+'" recid="'+d+'" column="'+u+'" '+i.inTag+"></div>"+i.outTag),null==e&&r.find("div.w2ui-input").text("object"!=typeof l?l:"");var v=r.find("div.w2ui-input").get(0);setTimeout(function(){var t=v;$(t).on("blur",function(e){1!=$(this).data("keep-open")&&c.editChange.call(c,t,b,u,e)})},10),null!=e&&$(v).text("object"!=typeof l?l:"");break;default:var y;w="font-family: "+(y=a.find("[col="+u+"] > div")).css("font-family")+"; font-size: "+y.css("font-size");r.addClass("w2ui-editable").html('<input id="grid_'+c.name+"_edit_"+d+"_"+u+'" autocorrect="off" autocomplete="off" spellcheck="false" type="text"     style="'+w+"; width: 100%; height: 100%; padding: 3px; border-color: transparent; outline: none; border-radius: 0;        pointer-events: auto; "+f+i.style+'"     field="'+p.field+'" recid="'+d+'" column="'+u+'" class="w2ui-input"'+i.inTag+"/>"+i.outTag),"number"==i.type&&(l=w2utils.formatNumber(l)),"date"==i.type&&(l=w2utils.formatDate(w2utils.isDate(l,i.format,!0)||new Date,i.format)),null==e&&r.find("input").val("object"!=typeof l?l:"");v=r.find("input").get(0);$(v).w2field(i.type,$.extend(i,{selected:l})),setTimeout(function(){var e=v;"list"==i.type&&(e=$($(v).data("w2field").helpers.focus).find("input"),"object"!=typeof l&&""!=l&&e.val(l).css({opacity:1}).prev().css({opacity:1}),r.find("input").on("change",function(e){c.editChange.call(c,v,b,u,e)})),$(e).on("blur",function(e){1!=$(this).data("keep-open")&&c.editChange.call(c,v,b,u,e)})},10),null!=e&&$(v).val("object"!=typeof l?l:"")}return void setTimeout(function(){c.last.inEditMode&&(r.find("input, select, div.w2ui-input").data("old_value",o).on("mousedown",function(e){e.stopPropagation()}).on("click",function(e){"div"==i.type?k.call(r.find("div.w2ui-input")[0],null):k.call(r.find("input, select")[0],null)}).on("paste",function(e){var t=e.originalEvent;e.preventDefault();var i=t.clipboardData.getData("text/plain");document.execCommand("insertHTML",!1,i)}).on("keydown",function(l){var o=this,e="DIV"==o.tagName.toUpperCase()?$(o).text():$(o).val();switch(l.keyCode){case 8:"list"!=i.type||$(v).data("w2field")||l.preventDefault();break;case 9:case 13:l.preventDefault();break;case 37:0===w2utils.getCursorPosition(o)&&l.preventDefault();break;case 39:w2utils.getCursorPosition(o)==e.length&&(w2utils.setCursorPosition(o,e.length),l.preventDefault())}setTimeout(function(){switch(l.keyCode){case 9:var e=d,t=l.shiftKey?c.prevCell(b,u,!0):c.nextCell(b,u,!0);if(null==t){var i=l.shiftKey?c.prevRow(b,u):c.nextRow(b,u);if(null!=i&&i!=b){e=c.records[i].recid;for(var s=0;s<c.columns.length;s++){var n=c.getCellEditable(b,s);if(null!=n&&-1==["checkbox","check"].indexOf(n.type)&&(t=parseInt(s),!l.shiftKey))break}}}!1===e&&(e=d),null==t&&(t=u),o.blur(),setTimeout(function(){"row"!=c.selectType?(c.selectNone(),c.select({recid:e,column:t})):c.editField(e,t,null,l)},1),l.preventDefault&&l.preventDefault();break;case 13:o.blur();var a=l.shiftKey?c.prevRow(b,u):c.nextRow(b,u);null!=a&&a!=b&&setTimeout(function(){"row"!=c.selectType?(c.selectNone(),c.select({recid:c.records[a].recid,column:u})):c.editField(c.records[a].recid,u,null,l)},1),"DIV"==o.tagName.toUpperCase()&&l.preventDefault();break;case 27:var r=c.parseField(h,p.field);h.w2ui&&h.w2ui.changes&&null!=h.w2ui.changes[p.field]&&(r=h.w2ui.changes[p.field]),null!=$(o).data("old_value")&&(r=$(o).data("old_value")),"DIV"==o.tagName.toUpperCase()?$(o).text(null!=r?r:""):o.value=null!=r?r:"",o.blur(),setTimeout(function(){c.select({recid:d,column:u})},1)}k.call(o,l)},1)}).on("keyup",function(e){k.call(this,e)}),setTimeout(function(){if(c.last.inEditMode){var e=r.find(".w2ui-input"),t=null!=$(e).val()?$(e).val().length:0;"div"==i.type&&(t=$(e).text().length),0<e.length&&(e.focus(),clearTimeout(c.last.kbd_timer),"SELECT"!=e[0].tagName.toUpperCase()&&w2utils.setCursorPosition(e[0],t),(e[0].resize=k).call(e[0],null))}},50),c.trigger($.extend(n,{phase:"after",input:r.find("input, select, div.w2ui-input")})))},5)}}else console.log('ERROR: input types "enum" and "file" are not supported in inline editing.')}}else if(13==t.keyCode){var b=this.last._edit.index;u=this.last._edit.column,d=this.last._edit.recid;this.editChange({type:"custom",value:this.last._edit.value},this.get(d,!0),u,t);var x=t.shiftKey?this.prevRow(b,u):this.nextRow(b,u);null!=x&&x!=b&&setTimeout(function(){"row"!=c.selectType?(c.selectNone(),c.select({recid:c.records[x].recid,column:u})):c.editField(c.records[x].recid,u,null,t)},1),this.last.inEditMode=!1}else{var _=$(this.box).find("div.w2ui-edit-box .w2ui-input");0<_.length&&"DIV"==_[0].tagName&&(_.text(_.text()+e),w2utils.setCursorPosition(_[0],_.text().length))}function k(e){try{var t="DIV"==this.tagName.toUpperCase()?$(this).text():this.value,i=$("#grid_"+c.name+"_editable"),s="font-family: "+$(this).css("font-family")+"; font-size: "+$(this).css("font-size")+"; white-space: pre;",n=w2utils.getStrWidth(t,s);n+20>i.width()&&i.width(n+20)}catch(e){}}},editChange:function(e,t,i,s){var n=this;setTimeout(function(){var e=$(n.box).find("#grid_"+n.name+"_focus");e.is(":focus")||e.focus()},10);var a=t<0;t=t<0?-t-1:t;var r=(a?this.summary:this.records)[t],l=this.columns[i],o=$("#grid_"+this.name+(!0===l.frozen?"_frec_":"_rec_")+w2utils.escapeId(r.recid)),d=e.tagName&&"DIV"==e.tagName.toUpperCase()?$(e).text():e.value,u=this.parseField(r,l.field),c=$(e).data("w2field");c&&("list"==c.type&&(d=$(e).data("selected")),!$.isEmptyObject(d)&&null!=d||(d=""),$.isPlainObject(d)||(d=c.clean(d))),"checkbox"==e.type&&(r.w2ui&&!1===r.w2ui.editable&&(e.checked=!e.checked),d=e.checked);var h={phase:"before",type:"change",target:this.name,input_id:e.id,recid:r.recid,index:t,column:i,originalEvent:s.originalEvent?s.originalEvent:s,value_new:d,value_previous:r.w2ui&&r.w2ui.changes&&r.w2ui.changes.hasOwnProperty(l.field)?r.w2ui.changes[l.field]:u,value_original:u};for(null!=$(s.target).data("old_value")&&(h.value_previous=$(s.target).data("old_value"));;){if("object"!=typeof(d=h.value_new)&&String(u)!=String(d)||"object"==typeof d&&d&&d.id!=u&&("object"!=typeof u||null==u||d.id!=u.id)){if(!0!==(h=this.trigger($.extend(h,{type:"change",phase:"before"}))).isCancelled){if(d!==h.value_new)continue;r.w2ui=r.w2ui||{},r.w2ui.changes=r.w2ui.changes||{},r.w2ui.changes[l.field]=h.value_new,this.trigger($.extend(h,{phase:"after"}))}}else if(!0!==(h=this.trigger($.extend(h,{type:"restore",phase:"before"}))).isCancelled){if(d!==h.value_new)continue;r.w2ui&&r.w2ui.changes&&delete r.w2ui.changes[l.field],r.w2ui&&$.isEmptyObject(r.w2ui.changes)&&delete r.w2ui.changes,this.trigger($.extend(h,{phase:"after"}))}break}var p=$(o).find("[col="+i+"]");a||(r.w2ui&&r.w2ui.changes&&null!=r.w2ui.changes[l.field]?p.addClass("w2ui-changed"):p.removeClass("w2ui-changed"),p.replaceWith(this.getCellHTML(t,i,a))),$(this.box).find("div.w2ui-edit-box").remove(),this.show.toolbarSave&&(0<this.getChanges().length?this.toolbar.enable("w2ui-save"):this.toolbar.disable("w2ui-save")),n.last.inEditMode=!1},delete:function(e){(new Date).getTime();var i=this,t=this.trigger({phase:"before",target:this.name,type:"delete",force:e});if(e&&this.message(),!0!==t.isCancelled){e=t.force,setTimeout(function(){$().w2tag()},20);var s=this.getSelection();if(0!==s.length)if(""==this.msgDelete||e){if("object"!=typeof this.url?this.url:this.url.remove)this.request("delete");else if("object"!=typeof s[0])this.selectNone(),this.remove.apply(this,s);else{for(var n=0;n<s.length;n++){var a=this.columns[s[n].column].field,r=this.get(s[n].recid,!0),l=this.records[r];null!=r&&"recid"!=a&&(this.records[r][a]="",l.w2ui&&l.w2ui.changes&&delete l.w2ui.changes[a])}this.update()}this.trigger($.extend(t,{phase:"after"}))}else this.message({width:380,height:170,body:'<div class="w2ui-centered">'+w2utils.lang(i.msgDelete).replace("NN",s.length).replace("records",1==s.length?"record":"records")+"</div>",buttons:w2utils.settings.macButtonOrder?'<button type="button" class="w2ui-btn btn-default" onclick="w2ui[\''+this.name+"'].message()\">"+w2utils.lang("Cancel")+'</button><button type="button" class="w2ui-btn" onclick="w2ui[\''+this.name+"'].delete(true)\">"+w2utils.lang(this.msgDeleteBtn)+"</button>":'<button type="button" class="w2ui-btn" onclick="w2ui[\''+this.name+"'].delete(true)\">"+w2utils.lang(this.msgDeleteBtn)+'</button><button type="button" class="w2ui-btn btn-default" onclick="w2ui[\''+this.name+"'].message()\">"+w2utils.lang("Cancel")+"</button>",onOpen:function(e){var t=$(this.box).find("input, textarea, select, button");t.off(".message").on("blur.message",function(e){t.index(e.target)+1===t.length&&(t.get(0).focus(),e.preventDefault())}).on("keydown.message",function(e){27==e.keyCode&&i.message()}),setTimeout(function(){$(this.box).find(".w2ui-btn.btn-default").focus(),clearTimeout(i.last.kbd_timer)}.bind(this),50)}})}},click:function(e,t){var i=(new Date).getTime(),s=null;if(!(1==this.last.cancelClick||t&&t.altKey))if("object"==typeof e&&null!==e&&(s=e.column,e=e.recid),null==t&&(t={}),i-parseInt(this.last.click_time)<350&&this.last.click_recid==e&&"click"==t.type)this.dblClick(e,t);else{this.last.bubbleEl&&($(this.last.bubbleEl).w2tag(),this.last.bubbleEl=null),this.last.click_time=i;var n=this.last.click_recid;if(this.last.click_recid=e,null==s&&t.target)"TD"!=(m=t.target).tagName.toUpperCase()&&(m=$(m).parents("td")[0]),null!=$(m).attr("col")&&(s=parseInt($(m).attr("col")));var a=this.trigger({phase:"before",target:this.name,type:"click",recid:e,column:s,originalEvent:t});if(!0!==a.isCancelled){var r=this,l=this.getSelection();$("#grid_"+this.name+"_check_all").prop("checked",!1);var o=this.get(e,!0),d=(this.records[o],[]);if(r.last.sel_ind=o,r.last.sel_col=s,r.last.sel_recid=e,r.last.sel_type="click",t.shiftKey&&0<l.length&&r.multiSelect){if(l[0].recid){var u=this.get(l[0].recid,!0),c=this.get(e,!0);if(s>l[0].column)var h=l[0].column,p=s;else h=s,p=l[0].column;for(var f=h;f<=p;f++)d.push(f)}else u=this.get(n,!0),c=this.get(e,!0);var g=[];if(c<u){var m=u;u=c,c=m}for(var w="object"!=typeof this.url?this.url:this.url.get,v=u;v<=c;v++)if(!(0<this.searchData.length)||w||-1!=$.inArray(v,this.last.searchIds))if("row"==this.selectType)g.push(this.records[v].recid);else for(var y=0;y<d.length;y++)g.push({recid:this.records[v].recid,column:d[y]});this.select.apply(this,g)}else{var b=this.last.selection,x=-1!=b.indexes.indexOf(o),_=!1;if($(t.target).parents("td").hasClass("w2ui-col-select")&&(_=!0),(t.ctrlKey||t.shiftKey||t.metaKey||_)&&this.multiSelect||this.showSelectColumn){var k=$(t.target).parents("tr").find(".w2ui-grid-select-check").is(":checked");"row"==this.selectType||-1!=$.inArray(s,b.columns[o])||k||(x=!1),!0===x?this.unselect({recid:e,column:s}):this.select({recid:e,column:s})}else"row"!=this.selectType&&-1==$.inArray(s,b.columns[o])&&(x=!1),300<l.length?this.selectNone():this.unselect.apply(this,l),!0===x&&1==l.length?this.unselect({recid:e,column:s}):this.select({recid:e,column:s})}this.status(),r.initResize(),this.trigger($.extend(a,{phase:"after"}))}}},columnClick:function(e,t){if(!0!==(i=this.trigger({phase:"before",type:"columnClick",target:this.name,field:e,originalEvent:t})).isCancelled){if("row"==this.selectType){(n=this.getColumn(e))&&n.sortable&&this.sort(e,null,!(!t||!t.ctrlKey&&!t.metaKey)),"line-number"==i.field&&(this.getSelection().length>=this.records.length?this.selectNone():this.selectAll())}else{if(t.altKey)(n=this.getColumn(e))&&n.sortable&&this.sort(e,null,!(!t||!t.ctrlKey&&!t.metaKey));if("line-number"==i.field)this.getSelection().length>=this.records.length?this.selectNone():this.selectAll();else{t.shiftKey||t.metaKey||t.ctrlKey||this.selectNone();var i,s=this.getSelection(),n=this.getColumn(i.field,!0),a=[],r=[];if(0!=s.length&&t.shiftKey){var l=n,o=s[0].column;o<l&&(l=s[0].column,o=n);for(var d=l;d<=o;d++)r.push(d)}else r.push(n);if(!0!==(i=this.trigger({phase:"before",type:"columnSelect",target:this.name,columns:r})).isCancelled){for(d=0;d<this.records.length;d++)a.push({recid:this.records[d].recid,column:r});this.select.apply(this,a)}this.trigger($.extend(i,{phase:"after"}))}}this.trigger($.extend(i,{phase:"after"}))}},columnDblClick:function(e,t){var i=this.trigger({phase:"before",type:"columnDblClick",target:this.name,field:e,originalEvent:t});!0!==i.isCancelled&&this.trigger($.extend(i,{phase:"after"}))},focus:function(e){var t=this,i=this.trigger({phase:"before",type:"focus",target:this.name,originalEvent:e});if(!0===i.isCancelled)return!1;this.hasFocus=!0,$(this.box).removeClass("w2ui-inactive").find(".w2ui-inactive").removeClass("w2ui-inactive"),setTimeout(function(){var e=$(t.box).find("#grid_"+t.name+"_focus");e.is(":focus")||e.focus()},10),this.trigger($.extend(i,{phase:"after"}))},blur:function(e){var t=this.trigger({phase:"before",type:"blur",target:this.name,originalEvent:e});if(!0===t.isCancelled)return!1;this.hasFocus=!1,$(this.box).addClass("w2ui-inactive").find(".w2ui-selected").addClass("w2ui-inactive"),$(this.box).find(".w2ui-selection").addClass("w2ui-inactive"),this.trigger($.extend(t,{phase:"after"}))},keydown:function(i){var s=this,e="object"!=typeof this.url?this.url:this.url.get;if(!0===s.keyboard){var t=s.trigger({phase:"before",type:"keydown",target:s.name,originalEvent:i});if(!0!==t.isCancelled)if(0<$(this.box).find(">.w2ui-message").length)27==i.keyCode&&this.message();else{var n=!1,a=$("#grid_"+s.name+"_records"),r=s.getSelection();0===r.length&&(n=!0);var l=r[0]||null,o=[],d=r[r.length-1];if("object"==typeof l&&null!=l){l=r[0].recid,o=[];for(var u=0;r[u]&&r[u].recid==l;)o.push(r[u].column),u++;d=r[r.length-1].recid}var c=s.get(l,!0),h=s.get(d,!0),p=(s.get(l),$("#grid_"+s.name+"_rec_"+(null!=c?w2utils.escapeId(s.records[c].recid):"none"))),f=!1,g=i.keyCode,m=i.shiftKey;switch(g){case 8:case 46:s.delete(),f=!0,i.stopPropagation();break;case 27:s.selectNone(),f=!0;break;case 65:if(!i.metaKey&&!i.ctrlKey)break;s.selectAll(),f=!0;break;case 13:if("row"==this.selectType&&!0===s.show.expandColumn){if(p.length<=0)break;s.toggle(l,i),f=!0}else{for(var w=0;w<this.columns.length;w++){if(this.getCellEditable(c,w)){o.push(parseInt(w));break}}"row"==this.selectType&&this.last._edit&&this.last._edit.column&&(o=[this.last._edit.column]),0<o.length&&(s.editField(l,o[0],null,i),f=!0)}break;case 37:if(n){T();break}if("row"==this.selectType){if(p.length<=0)break;!(y=this.records[c].w2ui||{})||null==y.parent_recid||Array.isArray(y.children)&&0!==y.children.length&&y.expanded?s.collapse(l,i):(s.unselect(l),s.collapse(y.parent_recid,i),s.select(y.parent_recid))}else{var v=s.prevCell(c,o[0]);if(m||null!=v||(this.selectNone(),v=0),null!=v)if(m&&s.multiSelect){if(S())return;var y=[],b=[],x=[];if(0===o.indexOf(this.last.sel_col)&&1<o.length){for(var _=0;_<r.length;_++)-1==y.indexOf(r[_].recid)&&y.push(r[_].recid),x.push({recid:r[_].recid,column:o[o.length-1]});s.unselect.apply(s,x),s.scrollIntoView(c,o[o.length-1],!0)}else{for(_=0;_<r.length;_++)-1==y.indexOf(r[_].recid)&&y.push(r[_].recid),b.push({recid:r[_].recid,column:v});s.select.apply(s,b),s.scrollIntoView(c,v,!0)}}else i.metaKey=!1,s.click({recid:l,column:v},i),s.scrollIntoView(c,v,!0);else if(!m)if(1<r.length)s.selectNone();else for(var k=1;k<r.length;k++)s.unselect(r[k])}f=!0;break;case 39:if(n){T();break}if("row"==this.selectType){if(p.length<=0)break;s.expand(l,i)}else{var C=s.nextCell(c,o[o.length-1]);if(m||null!=C||(this.selectNone(),C=this.columns.length-1),null!=C)if(m&&39==g&&s.multiSelect){if(S())return;y=[],b=[],x=[];if(o.indexOf(this.last.sel_col)==o.length-1&&1<o.length){for(_=0;_<r.length;_++)-1==y.indexOf(r[_].recid)&&y.push(r[_].recid),x.push({recid:r[_].recid,column:o[0]});s.unselect.apply(s,x),s.scrollIntoView(c,o[0],!0)}else{for(_=0;_<r.length;_++)-1==y.indexOf(r[_].recid)&&y.push(r[_].recid),b.push({recid:r[_].recid,column:C});s.select.apply(s,b),s.scrollIntoView(c,C,!0)}}else i.metaKey=!1,s.click({recid:l,column:C},i),s.scrollIntoView(c,C,!0);else if(!m)if(1<r.length)s.selectNone();else for(k=0;k<r.length-1;k++)s.unselect(r[k])}f=!0;break;case 38:if(n&&T(),p.length<=0)break;v=s.prevRow(c,o[0]);if(m||null!=v||(v=0==this.searchData.length||e?0:this.last.searchIds[0]),null!=v){if(m&&s.multiSelect){if(S())return;if("row"==s.selectType)s.last.sel_ind>v&&s.last.sel_ind!=h?s.unselect(s.records[h].recid):s.select(s.records[v].recid);else if(s.last.sel_ind>v&&s.last.sel_ind!=h){v=h;for(y=[],w=0;w<o.length;w++)y.push({recid:s.records[v].recid,column:o[w]});s.unselect.apply(s,y)}else{for(y=[],w=0;w<o.length;w++)y.push({recid:s.records[v].recid,column:o[w]});s.select.apply(s,y)}}else 300<r.length?this.selectNone():this.unselect.apply(this,r),s.click({recid:s.records[v].recid,column:o[0]},i);s.scrollIntoView(v),i.preventDefault&&i.preventDefault()}else if(!m)if(1<r.length)s.selectNone();else for(k=1;k<r.length;k++)s.unselect(r[k]);break;case 40:if(n&&T(),p.length<=0)break;C=s.nextRow(h,o[0]);if(m||null!=C||(C=0==this.searchData.length||e?this.records.length-1:this.last.searchIds[this.last.searchIds.length-1]),null!=C){if(m&&s.multiSelect){if(S())return;if("row"==s.selectType)this.last.sel_ind<C&&this.last.sel_ind!=c?s.unselect(s.records[c].recid):s.select(s.records[C].recid);else if(this.last.sel_ind<C&&this.last.sel_ind!=c){C=c;for(y=[],w=0;w<o.length;w++)y.push({recid:s.records[C].recid,column:o[w]});s.unselect.apply(s,y)}else{for(y=[],w=0;w<o.length;w++)y.push({recid:s.records[C].recid,column:o[w]});s.select.apply(s,y)}}else 300<r.length?this.selectNone():this.unselect.apply(this,r),s.click({recid:s.records[C].recid,column:o[0]},i);s.scrollIntoView(C),f=!0}else if(!m)if(1<r.length)s.selectNone();else for(k=0;k<r.length-1;k++)s.unselect(r[k]);break;case 17:case 91:if(n)break;s.last.isSafari&&(s.last.copy_event=s.copy(!1,i),$("#grid_"+s.name+"_focus").val(s.last.copy_event.text).select());break;case 67:(i.metaKey||i.ctrlKey)&&(s.last.isSafari||(s.last.copy_event=s.copy(!1,i),$("#grid_"+s.name+"_focus").val(s.last.copy_event.text).select()),s.copy(s.last.copy_event,i));break;case 88:if(n)break;(i.ctrlKey||i.metaKey)&&(s.last.isSafari||(s.last.copy_event=s.copy(!1,i),$("#grid_"+s.name+"_focus").val(s.last.copy_event.text).select()),s.copy(s.last.copy_event,i))}for(y=[32,187,189,192,219,220,221,186,222,188,190,191],_=48;_<=111;_++)y.push(_);-1==y.indexOf(g)||i.ctrlKey||i.metaKey||f||(0===o.length&&o.push(0),f=!1,setTimeout(function(){var e=$("#grid_"+s.name+"_focus"),t=e.val();e.val(""),s.editField(l,o[0],t,i)},1)),f&&i.preventDefault&&i.preventDefault(),s.trigger($.extend(t,{phase:"after"}))}}function T(){var e=Math.floor(a[0].scrollTop/s.recordHeight)+1;(!s.records[e]||e<2)&&(e=0),s.select({recid:s.records[e].recid,column:0})}function S(){if("click"!=s.last.sel_type)return!1;if("row"==s.selectType)return s.last.sel_type="key",1<r.length&&(r.splice(r.indexOf(s.records[s.last.sel_ind].recid),1),s.unselect.apply(s,r),!0);if(s.last.sel_type="key",1<r.length){for(var e=0;e<r.length;e++)if(r[e].recid==s.last.sel_recid&&r[e].column==s.last.sel_col){r.splice(e,1);break}return s.unselect.apply(s,r),!0}return!1}},scrollIntoView:function(e,t,i){var s=this.records.length;if(0==this.searchData.length||this.url||(s=this.last.searchIds.length),0!==s){if(null==e){var n=this.getSelection();if(0===n.length)return;$.isPlainObject(n[0])?(e=n[0].index,t=n[0].column):e=this.get(n[0],!0)}var a=$("#grid_"+this.name+"_records"),r=this.last.searchIds.length;if(0<r&&(e=this.last.searchIds.indexOf(e)),a.height()<this.recordHeight*(0<r?r:s)&&0<a.length){var l=Math.floor(a[0].scrollTop/this.recordHeight),o=l+Math.floor(a.height()/this.recordHeight);e==l&&(!0===i?a.prop({scrollTop:a.scrollTop()-a.height()/1.3}):(a.stop(),a.animate({scrollTop:a.scrollTop()-a.height()/1.3},250,"linear"))),e==o&&(!0===i?a.prop({scrollTop:a.scrollTop()+a.height()/1.3}):(a.stop(),a.animate({scrollTop:a.scrollTop()+a.height()/1.3},250,"linear"))),(e<l||o<e)&&(!0===i?a.prop({scrollTop:(e-1)*this.recordHeight}):(a.stop(),a.animate({scrollTop:(e-1)*this.recordHeight},250,"linear")))}if(null!=t){for(var d=0,u=0,c=w2utils.scrollBarSize(),h=0;h<=t;h++){var p=this.columns[h];p.frozen||p.hidden||(d=u,u+=parseInt(p.sizeCalculated))}a.width()<u-a.scrollLeft()?!0===i?a.prop({scrollLeft:d-c}):a.animate({scrollLeft:d-c},250,"linear"):d<a.scrollLeft()&&(!0===i?a.prop({scrollLeft:u-a.width()+2*c}):a.animate({scrollLeft:u-a.width()+2*c},250,"linear"))}}},dblClick:function(e,t){var i=null;if("object"==typeof e&&null!==e&&(i=e.column,e=e.recid),null==t&&(t={}),null==i&&t.target){var s=t.target;"TD"!=s.tagName.toUpperCase()&&(s=$(s).parents("td")[0]),i=parseInt($(s).attr("col"))}var n=this.get(e,!0),a=this.records[n],r=this.trigger({phase:"before",target:this.name,type:"dblClick",recid:e,column:i,originalEvent:t});!0!==r.isCancelled&&(this.selectNone(),this.getCellEditable(n,i)?this.editField(e,i,null,t):(this.select({recid:e,column:i}),(this.show.expandColumn||a.w2ui&&Array.isArray(a.w2ui.children))&&this.toggle(e)),this.trigger($.extend(r,{phase:"after"})))},contextMenu:function(t,e,i){var s=this;if("text"!=s.last.userSelect){null==i&&(i={offsetX:0,offsetY:0,target:$("#grid_"+s.name+"_rec_"+t)[0]}),null==i.offsetX&&(i.offsetX=i.layerX-i.target.offsetLeft,i.offsetY=i.layerY-i.target.offsetTop),w2utils.isFloat(t)&&(t=parseFloat(t));var n=this.getSelection();if("row"==this.selectType)-1==n.indexOf(t)&&s.click(t);else{var a=$(i.target);"TD"!=a[0].tagName.toUpperCase()&&(a=$(i.target).parents("td"));var r=!1;e=a.attr("col");for(var l=0;l<n.length;l++)n[l].recid!=t&&n[l].column!=e||(r=!0);r||null==t||s.click({recid:t,column:e}),r||null==e||s.columnClick(this.columns[e].field,i)}var o=s.trigger({phase:"before",type:"contextMenu",target:s.name,originalEvent:i,recid:t,column:e});!0!==o.isCancelled&&(0<s.menu.length&&$(s.box).find(i.target).w2menu(s.menu,{originalEvent:i,contextMenu:!0,onSelect:function(e){s.menuClick(t,parseInt(e.index),e.originalEvent)}}),i.preventDefault&&i.preventDefault(),s.trigger($.extend(o,{phase:"after"})))}},menuClick:function(e,t,i){var s=this.trigger({phase:"before",type:"menuClick",target:this.name,originalEvent:i,recid:e,menuIndex:t,menuItem:this.menu[t]});!0!==s.isCancelled&&this.trigger($.extend(s,{phase:"after"}))},toggle:function(e){var t=this.get(e);return t.w2ui=t.w2ui||{},!0===t.w2ui.expanded?this.collapse(e):this.expand(e)},expand:function(e){var t=this.get(e,!0),i=this.records[t];i.w2ui=i.w2ui||{};var s=w2utils.escapeId(e),n=i.w2ui.children;if(Array.isArray(n)){if(!0===i.w2ui.expanded||0===n.length)return!1;if(!0===(a=this.trigger({phase:"before",type:"expand",target:this.name,recid:e})).isCancelled)return!1;i.w2ui.expanded=!0,n.forEach(function(e){e.w2ui=e.w2ui||{},e.w2ui.parent_recid=i.recid,null==e.w2ui.children&&(e.w2ui.children=[])}),this.records.splice.apply(this.records,[t+1,0].concat(n)),this.total+=n.length,("object"!=typeof this.url?this.url:this.url.get)||(this.localSort(!0,!0),0<this.searchData.length&&this.localSearch(!0)),this.refresh(),this.trigger($.extend(a,{phase:"after"}))}else{if(0<$("#grid_"+this.name+"_rec_"+s+"_expanded_row").length||!0!==this.show.expandColumn)return!1;if("none"==i.w2ui.expanded)return!1;var a;if($("#grid_"+this.name+"_rec_"+s).after('<tr id="grid_'+this.name+"_rec_"+e+'_expanded_row" class="w2ui-expanded-row">    <td colspan="100" class="w2ui-expanded2">        <div id="grid_'+this.name+"_rec_"+e+'_expanded"></div>    </td>    <td class="w2ui-grid-data-last"></td></tr>'),$("#grid_"+this.name+"_frec_"+s).after('<tr id="grid_'+this.name+"_frec_"+e+'_expanded_row" class="w2ui-expanded-row">'+(this.show.lineNumbers?'<td class="w2ui-col-number"></td>':"")+'    <td class="w2ui-grid-data w2ui-expanded1" colspan="100">       <div id="grid_'+this.name+"_frec_"+e+'_expanded"></div>   </td></tr>'),!0===(a=this.trigger({phase:"before",type:"expand",target:this.name,recid:e,box_id:"grid_"+this.name+"_rec_"+e+"_expanded",fbox_id:"grid_"+this.name+"_frec_"+s+"_expanded"})).isCancelled)return $("#grid_"+this.name+"_rec_"+s+"_expanded_row").remove(),$("#grid_"+this.name+"_frec_"+s+"_expanded_row").remove(),!1;var r=$(this.box).find("#grid_"+this.name+"_rec_"+e+"_expanded"),l=$(this.box).find("#grid_"+this.name+"_frec_"+e+"_expanded"),o=r.find("> div:first-child").height();r.height()<o&&r.css({height:o+"px"}),l.height()<o&&l.css({height:o+"px"}),$("#grid_"+this.name+"_rec_"+s).attr("expanded","yes").addClass("w2ui-expanded"),$("#grid_"+this.name+"_frec_"+s).attr("expanded","yes").addClass("w2ui-expanded"),$("#grid_"+this.name+"_cell_"+this.get(e,!0)+"_expand div").html("-"),i.w2ui.expanded=!0,this.trigger($.extend(a,{phase:"after"})),this.resizeRecords()}return!0},collapse:function(e){var t=this,i=this.get(e,!0),s=this.records[i];s.w2ui=s.w2ui||{};var n=w2utils.escapeId(e),a=s.w2ui.children;if(Array.isArray(a)){if(!0!==s.w2ui.expanded)return!1;if(!0===(u=this.trigger({phase:"before",type:"collapse",target:this.name,recid:e})).isCancelled)return!1;!function e(t){t.w2ui.expanded=!1;for(var i=0;i<t.w2ui.children.length;i++){var s=t.w2ui.children[i];s.w2ui.expanded&&e(s)}}(s);for(var r=[],l=s;null!=l;l=this.get(l.w2ui.parent_recid))r.push(l.w2ui.parent_recid);for(var o=i+1,d=o;!(this.records.length<=d+1||null==this.records[d+1].w2ui||0<=r.indexOf(this.records[d+1].w2ui.parent_recid));)d++;this.records.splice(o,d-o+1),this.total-=d-o+1,("object"!=typeof this.url?this.url:this.url.get)||0<this.searchData.length&&this.localSearch(!0),this.refresh(),t.trigger($.extend(u,{phase:"after"}))}else{if(0===$("#grid_"+this.name+"_rec_"+n+"_expanded_row").length||!0!==this.show.expandColumn)return!1;var u;if(!0===(u=this.trigger({phase:"before",type:"collapse",target:this.name,recid:e,box_id:"grid_"+this.name+"_rec_"+n+"_expanded",fbox_id:"grid_"+this.name+"_frec_"+n+"_expanded"})).isCancelled)return!1;$("#grid_"+this.name+"_rec_"+n).removeAttr("expanded").removeClass("w2ui-expanded"),$("#grid_"+this.name+"_frec_"+n).removeAttr("expanded").removeClass("w2ui-expanded"),$("#grid_"+this.name+"_cell_"+this.get(e,!0)+"_expand div").html("+"),$("#grid_"+t.name+"_rec_"+n+"_expanded").css("height","0px"),$("#grid_"+t.name+"_frec_"+n+"_expanded").css("height","0px"),setTimeout(function(){$("#grid_"+t.name+"_rec_"+n+"_expanded_row").remove(),$("#grid_"+t.name+"_frec_"+n+"_expanded_row").remove(),s.w2ui.expanded=!1,t.trigger($.extend(u,{phase:"after"})),t.resizeRecords()},300)}return!0},sort:function(e,t,i){var s=this.trigger({phase:"before",type:"sort",target:this.name,field:e,direction:t,multiField:i});if(!0!==s.isCancelled){if(null!=e){for(var n=this.sortData.length,a=0;a<this.sortData.length;a++)if(this.sortData[a].field==e){n=a;break}if(null==t)if(null==this.sortData[n])t="asc";else switch(null==this.sortData[n].direction&&(this.sortData[n].direction=""),this.sortData[n].direction.toLowerCase()){case"asc":t="desc";break;case"desc":default:t="asc"}!1===this.multiSort&&(this.sortData=[],n=0),1!=i&&(this.sortData=[],n=0),null==this.sortData[n]&&(this.sortData[n]={}),this.sortData[n].field=e,this.sortData[n].direction=t}else this.sortData=[];("object"!=typeof this.url?this.url:this.url.get)?(this.trigger($.extend(s,{phase:"after",direction:t})),this.last.xhr_offset=0,this.reload()):(this.localSort(!0,!0),0<this.searchData.length&&this.localSearch(!0),this.last.scrollTop=0,$("#grid_"+this.name+"_records").prop("scrollTop",0),this.trigger($.extend(s,{phase:"after",direction:t})),this.refresh())}},copy:function(e,t){if($.isPlainObject(e))return this.trigger($.extend(e,{phase:"after"})),e.text;var i=this.getSelection();if(0===i.length)return"";var s,n="";if("object"==typeof i[0]){for(var a=i[0].column,r=i[0].column,l=[],o=0;o<i.length;o++)i[o].column<a&&(a=i[o].column),i[o].column>r&&(r=i[o].column),-1==l.indexOf(i[o].index)&&l.push(i[o].index);l.sort(function(e,t){return e-t});for(var d=0;d<l.length;d++){for(var u=l[d],c=a;c<=r;c++){!0!==(p=this.columns[c]).hidden&&(n+=this.getCellCopy(u,c)+"\t")}n=n.substr(0,n.length-1),n+="\n"}}else{for(c=0;c<this.columns.length;c++){if(!0!==(p=this.columns[c]).hidden){var h=p.text?p.text:p.field;p.text&&p.text.length<3&&p.tooltip&&(h=p.tooltip),n+='"'+w2utils.stripTags(h)+'"\t'}}n=n.substr(0,n.length-1),n+="\n";for(o=0;o<i.length;o++){for(u=this.get(i[o],!0),c=0;c<this.columns.length;c++){var p;!0!==(p=this.columns[c]).hidden&&(n+='"'+this.getCellCopy(u,c)+'"\t')}n=n.substr(0,n.length-1),n+="\n"}}return n=n.substr(0,n.length-1),null==e?!0===(s=this.trigger({phase:"before",type:"copy",target:this.name,text:n,cut:88==t.keyCode,originalEvent:t})).isCancelled?"":(n=s.text,this.trigger($.extend(s,{phase:"after"})),n):!1===e?!0===(s=this.trigger({phase:"before",type:"copy",target:this.name,text:n,cut:88==t.keyCode,originalEvent:t})).isCancelled?"":(n=s.text,s):void 0},getCellCopy:function(e,t){return w2utils.stripTags(this.getCellHTML(e,t))},paste:function(e){var t=this.getSelection(),i=this.get(t[0].recid,!0),s=t[0].column,n=this.trigger({phase:"before",type:"paste",target:this.name,text:e,index:i,column:s});if(!0!==n.isCancelled){if(e=n.text,"row"==this.selectType||0===t.length)return console.log("ERROR: You can paste only if grid.selectType = 'cell' and when at least one cell selected."),void this.trigger($.extend(n,{phase:"after"}));for(var a=[],r=(e=e.split("\n"),0);r<e.length;r++){var l=e[r].split("\t"),o=0,d=this.records[i],u=[];if(null!=d){for(var c=0;c<l.length;c++)this.columns[s+o]&&(this.setCellPaste(d,s+o,l[c]),u.push(s+o),o++);for(var h=0;h<u.length;h++)a.push({recid:d.recid,column:u[h]});i++}}this.selectNone(),this.select.apply(this,a),this.refresh(),this.trigger($.extend(n,{phase:"after"}))}},setCellPaste:function(e,t,i){var s=this.columns[t].field;e.w2ui=e.w2ui||{},e.w2ui.changes=e.w2ui.changes||{},e.w2ui.changes[s]=i},resize:function(){var e=this,t=(new Date).getTime();if(this.box&&$(this.box).attr("name")==this.name){$(this.box).find("> div.w2ui-grid-box").css("width",$(this.box).width()).css("height",$(this.box).height());var i=this.trigger({phase:"before",type:"resize",target:this.name});if(!0!==i.isCancelled)return e.resizeBoxes(),e.resizeRecords(),e.toolbar&&e.toolbar.resize&&e.toolbar.resize(),this.trigger($.extend(i,{phase:"after"})),(new Date).getTime()-t}},update:function(e){var t=(new Date).getTime();if(null==this.box)return 0;if(null==e){for(var i=this.last.range_start-1;i<=this.last.range_end-1;i++)if(!(i<0)){(r=this.records[i]||{}).w2ui||(r.w2ui={});for(var s=0;s<this.columns.length;s++){var n=$(this.box).find("#grid_"+this.name+"_rec_"+w2utils.escapeId(r.recid));(l=$(this.box).find("#grid_"+this.name+"_data_"+i+"_"+s)).replaceWith(this.getCellHTML(i,s,!1)),l=$(this.box).find("#grid_"+this.name+"_data_"+i+"_"+s),null==r.w2ui.style||$.isEmptyObject(r.w2ui.style)?l.attr("style",""):("string"==typeof r.w2ui.style&&n.attr("style",r.w2ui.style),$.isPlainObject(r.w2ui.style)&&"string"==typeof r.w2ui.style[s]&&l.attr("style",r.w2ui.style[s])),null==r.w2ui.class||$.isEmptyObject(r.w2ui.class)||("string"==typeof r.w2ui.class&&n.addClass(r.w2ui.class),$.isPlainObject(r.w2ui.class)&&"string"==typeof r.w2ui.class[s]&&l.addClass(r.w2ui.class[s]))}}}else for(var a=0;a<e.length;a++){i=e[a].index,s=e[a].column;if(!(i<0))if(null!=i&&null!=s){var r=this.records[i]||{},l=(n=$(this.box).find("#grid_"+this.name+"_rec_"+w2utils.escapeId(r.recid)),$(this.box).find("#grid_"+this.name+"_data_"+i+"_"+s));r.w2ui||(r.w2ui={}),l.replaceWith(this.getCellHTML(i,s,!1)),l=$(this.box).find("#grid_"+this.name+"_data_"+i+"_"+s),null==r.w2ui.style||$.isEmptyObject(r.w2ui.style)?l.attr("style",""):("string"==typeof r.w2ui.style&&n.attr("style",r.w2ui.style),$.isPlainObject(r.w2ui.style)&&"string"==typeof r.w2ui.style[s]&&l.attr("style",r.w2ui.style[s])),null==r.w2ui.class||$.isEmptyObject(r.w2ui.class)||("string"==typeof r.w2ui.class&&n.addClass(r.w2ui.class),$.isPlainObject(r.w2ui.class)&&"string"==typeof r.w2ui.class[s]&&l.addClass(r.w2ui.class[s]))}else console.log("ERROR: Wrong argument for grid.update(cells), cells should be [{ index: X, column: Y }, ...]")}return(new Date).getTime()-t},refreshCell:function(e,t){var i=this.get(e,!0),s=!this.records[i]||this.records[i].recid!=e,n=this.getColumn(t,!0),a=s?this.summary[i]:this.records[i],r=this.columns[n],l=$(this.box).find("#grid_"+this.name+"_data_"+i+"_"+n);if(null==a)return!1;l.replaceWith(this.getCellHTML(i,n,s)),l=$(this.box).find("#grid_"+this.name+"_data_"+i+"_"+n),a.w2ui&&a.w2ui.changes&&null!=a.w2ui.changes[r.field]?l.addClass("w2ui-changed"):l.removeClass("w2ui-changed"),a.w2ui&&null!=a.w2ui.style&&!$.isEmptyObject(a.w2ui.style)?("string"==typeof a.w2ui.style&&$(this.box).find("#grid_"+this.name+"_rec_"+w2utils.escapeId(a.recid)).attr("style",a.w2ui.style),$.isPlainObject(a.w2ui.style)&&"string"==typeof a.w2ui.style[n]&&l.attr("style",a.w2ui.style[n])):l.attr("style",""),a.w2ui&&null!=a.w2ui.class&&!$.isEmptyObject(a.w2ui.class)&&("string"==typeof a.w2ui.class&&$(this.box).find("#grid_"+this.name+"_rec_"+w2utils.escapeId(a.recid)).addClass(a.w2ui.class),$.isPlainObject(a.w2ui.class)&&"string"==typeof a.w2ui.class[n]&&l.addClass(a.w2ui.class[n]))},refreshRow:function(e,t){var i=$(this.box).find("#grid_"+this.name+"_frec_"+w2utils.escapeId(e)),s=$(this.box).find("#grid_"+this.name+"_rec_"+w2utils.escapeId(e));if(0<i.length){null==t&&(t=this.get(e,!0));var n=i.attr("line"),a=!this.records[t]||this.records[t].recid!=e,r="object"!=typeof this.url?this.url:this.url.get;if(0<this.searchData.length&&!r)for(var l=0;l<this.last.searchIds.length;l++)this.last.searchIds[l]==t&&(t=l);var o=this.getRecordHTML(t,n,a);$(i).replaceWith(o[0]),$(s).replaceWith(o[1]);var d=this.records[t].w2ui?this.records[t].w2ui.style:"";if("string"==typeof d){i=$(this.box).find("#grid_"+this.name+"_frec_"+w2utils.escapeId(e)),s=$(this.box).find("#grid_"+this.name+"_rec_"+w2utils.escapeId(e));i.attr("custom_style",d),s.attr("custom_style",d),i.hasClass("w2ui-selected")&&(d=d.replace("background-color","none")),i[0].style.cssText="height: "+this.recordHeight+"px;"+d,s[0].style.cssText="height: "+this.recordHeight+"px;"+d}a&&this.resize()}},refresh:function(){var a=this,e=(new Date).getTime(),t="object"!=typeof this.url?this.url:this.url.get;if(this.total<=0&&!t&&0===this.searchData.length&&(this.total=this.records.length),this.toolbar.disable("w2ui-edit","w2ui-delete"),this.box){var i=this.trigger({phase:"before",target:this.name,type:"refresh"});if(!0!==i.isCancelled){if(this.show.header?$("#grid_"+this.name+"_header").html(this.header+"&#160;").show():$("#grid_"+this.name+"_header").hide(),this.show.toolbar){if(this.toolbar&&this.toolbar.get("w2ui-column-on-off")&&this.toolbar.get("w2ui-column-on-off").checked);else if($("#grid_"+this.name+"_toolbar").show(),"object"==typeof this.toolbar)for(var s=this.toolbar.items,n=0;n<s.length;n++)"w2ui-search"!=s[n].id&&"break"!=s[n].type&&this.toolbar.refresh(s[n].id)}else $("#grid_"+this.name+"_toolbar").hide();this.searchClose();var r=$("#grid_"+a.name+"_search_all");!this.multiSearch&&"all"==this.last.field&&0<this.searches.length&&(this.last.field=this.searches[0].field,this.last.label=this.searches[0].label);for(var l=0;l<this.searches.length;l++)this.searches[l].field==this.last.field&&(this.last.label=this.searches[l].label);if(this.last.multi?(r.attr("placeholder","["+w2utils.lang("Multiple Fields")+"]"),r.w2field("clear")):r.attr("placeholder",w2utils.lang(this.last.label)),r.val()!=this.last.search){var o=this.last.search;(s=r.data("w2field"))&&(o=s.format(o)),r.val(o)}a.refreshBody(),this.show.footer?$("#grid_"+this.name+"_footer").html(this.getFooterHTML()).show():$("#grid_"+this.name+"_footer").hide();var d=$("#grid_"+this.name+"_searchClear");d.hide(),this.searchData.some(function(e){var t=a.getSearch(e.field);if(a.last.multi||t&&!t.hidden&&-1==["list","enum"].indexOf(t.type))return d.show(),!0});var u=this.last.selection,c=0<this.records.length&&u.indexes.length==this.records.length,h=0<u.indexes.length&&0!==this.searchData.length&&u.indexes.length==this.last.searchIds.length;c||h?$("#grid_"+this.name+"_check_all").prop("checked",!0):$("#grid_"+this.name+"_check_all").prop("checked",!1),this.status();for(var p=a.find({"w2ui.expanded":!0},!0),f=0;f<p.length;f++){(s=a.records[p[f]].w2ui)&&!Array.isArray(s.children)&&(s.expanded=!1)}return a.markSearch&&setTimeout(function(){for(var e=[],t=0;t<a.searchData.length;t++){var i=a.searchData[t],s=a.getSearch(i.field);if(s&&!s.hidden){var n=a.getColumn(i.field,!0);e.push({field:i.field,search:i.value,col:n})}}0<e.length&&e.forEach(function(e){$(a.box).find('td[col="'+e.col+'"]').not(".w2ui-head").w2marker(e.search)})},50),this.show.toolbarSave&&(0<this.getChanges().length?this.toolbar.enable("w2ui-save"):this.toolbar.disable("w2ui-save")),this.trigger($.extend(i,{phase:"after"})),a.resize(),a.addRange("selection"),setTimeout(function(){a.resize(),a.scroll()},1),a.reorderColumns&&!a.last.columnDrag?a.last.columnDrag=a.initColumnDrag():!a.reorderColumns&&a.last.columnDrag&&a.last.columnDrag.remove(),(new Date).getTime()-e}}},refreshBody:function(){var r=this,e=this.find({"w2ui.summary":!0},!0);if(0<e.length){for(var t=0;t<e.length;t++)this.summary.push(this.records[e[t]]);for(t=e.length-1;0<=t;t--)this.records.splice(e[t],1)}this.scroll();var i=this.getRecordsHTML(),s=this.getColumnsHTML(),n='<div id="grid_'+this.name+'_frecords" class="w2ui-grid-frecords" style="margin-bottom: '+(w2utils.scrollBarSize()-1)+'px;">'+i[0]+'</div><div id="grid_'+this.name+'_records" class="w2ui-grid-records" onscroll="w2ui[\''+this.name+"'].scroll(event);\">"+i[1]+'</div><div id="grid_'+this.name+'_scroll1" class="w2ui-grid-scroll1" style="height: '+w2utils.scrollBarSize()+'px"></div><div id="grid_'+this.name+'_fcolumns" class="w2ui-grid-fcolumns">    <table><tbody>'+s[0]+'</tbody></table></div><div id="grid_'+this.name+'_columns" class="w2ui-grid-columns">    <table><tbody>'+s[1]+"</tbody></table></div>",l=$("#grid_"+this.name+"_body",r.box).html(n),o=$("#grid_"+this.name+"_records",r.box);if(l.data("scrolldata",{lastTime:0,lastDelta:0,time:0}).find(".w2ui-grid-frecords").on("mousewheel DOMMouseScroll ",function(e){e.preventDefault();var t=e.originalEvent,i=l.data("scrolldata"),s=$(this).siblings(".w2ui-grid-records").addBack().filter(".w2ui-grid-records"),n=null!=typeof t.wheelDelta?-1*t.wheelDelta/120:(t.detail||t.deltaY)/3,a=s.scrollTop();i.time=+new Date,i.lastTime<i.time-150&&(i.lastDelta=0),i.lastTime=i.time,i.lastDelta+=n,n=Math.abs(i.lastDelta)<1?0:Math.round(i.lastDelta),l.data("scrolldata",i),n*=(Math.round(o.height()/r.recordHeight)-1)*r.recordHeight/4,s.stop().animate({scrollTop:a+n},250,"linear")}),0===this.records.length&&this.msgEmpty?$("#grid_"+this.name+"_body").append('<div id="grid_'+this.name+'_empty_msg" class="w2ui-grid-empty-msg"><div>'+this.msgEmpty+"</div></div>"):0<$("#grid_"+this.name+"_empty_msg").length&&$("#grid_"+this.name+"_empty_msg").remove(),0<this.summary.length){var a=this.getSummaryHTML();$("#grid_"+this.name+"_fsummary").html(a[0]).show(),$("#grid_"+this.name+"_summary").html(a[1]).show()}else $("#grid_"+this.name+"_fsummary").hide(),$("#grid_"+this.name+"_summary").hide()},render:function(e){var C=this,t=(new Date).getTime();if(null!=e&&(0<$(this.box).find("#grid_"+this.name+"_body").length&&$(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-grid w2ui-inactive").html(""),this.box=e),this.box){var i="object"!=typeof this.url?this.url:this.url.get,s=this.trigger({phase:"before",target:this.name,type:"render",box:e});if(!0!==s.isCancelled){if(this.reset(!0),!this.last.field)if(this.multiSearch&&this.show.searchAll)this.last.field="all",this.last.label=w2utils.lang("All Fields");else{for(var n=0;n<this.searches.length&&(this.searches[n].hidden||!1===this.searches[n].simple);)n++;n>=this.searches.length?(this.last.field="",this.last.label=""):(this.last.field=this.searches[n].field,this.last.label=this.searches[n].label)}if($(this.box).attr("name",this.name).addClass("w2ui-reset w2ui-grid w2ui-inactive").html('<div class="w2ui-grid-box">    <div id="grid_'+this.name+'_header" class="w2ui-grid-header"></div>    <div id="grid_'+this.name+'_toolbar" class="w2ui-grid-toolbar"></div>    <div id="grid_'+this.name+'_body" class="w2ui-grid-body"></div>    <div id="grid_'+this.name+'_fsummary" class="w2ui-grid-body w2ui-grid-summary"></div>    <div id="grid_'+this.name+'_summary" class="w2ui-grid-body w2ui-grid-summary"></div>    <div id="grid_'+this.name+'_footer" class="w2ui-grid-footer"></div>    <textarea id="grid_'+this.name+'_focus" class="w2ui-grid-focus-input" '+(w2utils.isIOS?"readonly":"")+"></textarea></div>"),"row"!=this.selectType&&$(this.box).addClass("w2ui-ss"),0<$(this.box).length&&($(this.box)[0].style.cssText+=this.style),this.initToolbar(),null!=this.toolbar&&this.toolbar.render($("#grid_"+this.name+"_toolbar")[0]),this.last.field&&"all"!=this.last.field){var a=this.searchData;setTimeout(function(){C.initAllField(C.last.field,1==a.length?a[0].value:null)},1)}$("#grid_"+this.name+"_footer").html(this.getFooterHTML()),this.last.state||(this.last.state=this.stateSave(!0)),this.stateRestore(),i&&(this.clear(),this.refresh());for(var T,r=!1,l=0;l<this.searches.length;l++)if(this.searches[l].hidden){r=!0;break}return r?(this.searchReset(!1),i||setTimeout(function(){C.searchReset()},1)):this.reload(),$(this.box).find("#grid_"+this.name+"_focus").on("focus",function(e){clearTimeout(C.last.kbd_timer),C.hasFocus||C.focus()}).on("blur",function(e){clearTimeout(C.last.kbd_timer),C.last.kbd_timer=setTimeout(function(){C.hasFocus&&C.blur()},100)}).on("paste",function(e){var t=this;setTimeout(function(){w2ui[C.name].paste(t.value),t.value=""},1)}).on("keydown",function(e){w2ui[C.name].keydown.call(w2ui[C.name],e)}),$(this.box).on("mousedown",function(e){if(1!=e.which)return;"text"==C.last.userSelect&&(delete C.last.userSelect,$(C.box).find(".w2ui-grid-body").css(w2utils.cssPrefix("user-select","none")));if("row"==C.selectType&&($(e.target).parents().hasClass("w2ui-head")||$(e.target).hasClass("w2ui-head")))return;if(C.last.move&&"expand"==C.last.move.type)return;if(e.altKey)$(C.box).find(".w2ui-grid-body").css(w2utils.cssPrefix("user-select","text")),C.selectNone(),C.last.move={type:"text-select"},C.last.userSelect="text";else{for(var t=e.target,i={x:e.offsetX-10,y:e.offsetY-10},s=!1;t&&(!t.classList||!t.classList.contains("w2ui-grid"));)t.tagName&&"TD"==t.tagName.toUpperCase()&&(s=!0),t.tagName&&"TR"!=t.tagName.toUpperCase()&&1==s&&(i.x+=t.offsetLeft,i.y+=t.offsetTop),t=t.parentNode;C.last.move={x:e.screenX,y:e.screenY,divX:0,divY:0,focusX:i.x,focusY:i.y,recid:$(e.target).parents("tr").attr("recid"),column:parseInt("TD"==e.target.tagName.toUpperCase()?$(e.target).attr("col"):$(e.target).parents("td").attr("col")),type:"select",ghost:!1,start:!0},null==C.last.move.recid&&(C.last.move.type="select-column");var n=e.target,a=$(C.box).find("#grid_"+C.name+"_focus");if(C.last.move){var r=C.last.move.focusX,l=C.last.move.focusY,o=$(n).parents("table").parent();(o.hasClass("w2ui-grid-records")||o.hasClass("w2ui-grid-frecords")||o.hasClass("w2ui-grid-columns")||o.hasClass("w2ui-grid-fcolumns")||o.hasClass("w2ui-grid-summary"))&&(r=C.last.move.focusX-$(C.box).find("#grid_"+C.name+"_records").scrollLeft(),l=C.last.move.focusY-$(C.box).find("#grid_"+C.name+"_records").scrollTop()),($(n).hasClass("w2ui-grid-footer")||0<$(n).parents("div.w2ui-grid-footer").length)&&(l=$(C.box).find("#grid_"+C.name+"_footer").position().top),o.hasClass("w2ui-scroll-wrapper")&&o.parent().hasClass("w2ui-toolbar")&&(r=C.last.move.focusX-o.scrollLeft()),a.css({left:r-10,top:l})}setTimeout(function(){-1!=["INPUT","TEXTAREA","SELECT"].indexOf(n.tagName.toUpperCase())?$(n).focus():a.is(":focus")||a.focus()},50),C.multiSelect||C.reorderRows||"drag"!=C.last.move.type||delete C.last.move}if(1==C.reorderRows){var d=e.target;if("TD"!=d.tagName.toUpperCase()&&(d=$(d).parents("td")[0]),$(d).hasClass("w2ui-col-number")||$(d).hasClass("w2ui-col-order")){C.selectNone(),C.last.move.reorder=!0;var u=$(C.box).find(".w2ui-even.w2ui-empty-record").css("background-color"),c=$(C.box).find(".w2ui-odd.w2ui-empty-record").css("background-color");$(C.box).find(".w2ui-even td").not(".w2ui-col-number").css("background-color",u),$(C.box).find(".w2ui-odd td").not(".w2ui-col-number").css("background-color",c);var h=C.last.move;if(!h.ghost){var p=$("#grid_"+C.name+"_rec_"+h.recid);t=p.parents("table").find("tr:first-child").clone();h.offsetY=e.offsetY,h.from=h.recid,h.pos=p.position(),h.ghost=$(p).clone(!0),h.ghost.removeAttr("id"),p.find("td").remove(),p.append('<td colspan="1000"><div style="height: '+C.recordHeight+'px; background-color: #eee; border-bottom: 1px dashed #aaa; border-top: 1px dashed #aaa;"></div></td>'),(g=$(C.box).find(".w2ui-grid-records")).append('<div id="grid_'+C.name+'_ghost_line" style="position: absolute; z-index: 999999; pointer-events: none; width: 100%;"></div>'),g.append('<table id="grid_'+C.name+'_ghost" style="position: absolute; z-index: 999998; opacity: 0.9; pointer-events: none;"></table>'),$("#grid_"+C.name+"_ghost").append(t).append(h.ghost)}var f=$("#grid_"+C.name+"_ghost"),g=$(C.box).find(".w2ui-grid-records");f.css({top:h.pos.top+g.scrollTop(),left:h.pos.left,"border-top":"1px solid #aaa","border-bottom":"1px solid #aaa"})}else C.last.move.reorder=!1}$(document).on("mousemove.w2ui-"+C.name,m).on("mouseup.w2ui-"+C.name,w),e.stopPropagation()}),this.updateToolbar(),this.trigger($.extend(s,{phase:"after"})),0===$(".w2ui-layout").length&&$(window).off("resize.w2ui-"+C.name).on("resize.w2ui-"+C.name,function(e){null==w2ui[C.name]?$(window).off("resize.w2ui-"+C.name):w2ui[C.name].resize()}),(new Date).getTime()-t}}function m(e){var t=C.last.move;if(t&&-1!=["select","select-column"].indexOf(t.type)&&(t.divX=e.screenX-t.x,t.divY=e.screenY-t.y,!(Math.abs(t.divX)<=1&&Math.abs(t.divY)<=1)))if(C.last.cancelClick=!0,1==C.reorderRows&&C.last.move.reorder){var i=$(C.box).find(".w2ui-grid-records");if("-none-"==(r=(c=$(e.target).parents("tr")).attr("recid"))&&(r="bottom"),r!=t.from){$("#grid_"+C.name+"_rec_"+t.recid);var s=$("#grid_"+C.name+"_rec_"+r);$(C.box).find(".insert-before"),s.addClass("insert-before"),t.lastY=e.screenY,t.to=r;var n=s.position(),a=$("#grid_"+C.name+"_ghost_line");n?a.css({top:n.top+i.scrollTop(),left:t.pos.left,"border-top":"2px solid #769EFC"}):a.css({"border-top":"2px solid transparent"})}$("#grid_"+C.name+"_ghost").css({top:t.pos.top+t.divY+i.scrollTop(),left:t.pos.left})}else{t.start&&t.recid&&(C.selectNone(),t.start=!1);var r,l=[];if(null==(r="TR"==e.target.tagName.toUpperCase()?$(e.target).attr("recid"):$(e.target).parents("tr").attr("recid"))){if("row"==C.selectType)return;if(C.last.move&&"select"==C.last.move.type)return;var o=parseInt($(e.target).parents("td").attr("col"));if(isNaN(o))C.removeRange("column-selection"),$(C.box).find(".w2ui-grid-columns .w2ui-col-header, .w2ui-grid-fcolumns .w2ui-col-header").removeClass("w2ui-col-selected"),$(C.box).find(".w2ui-col-number").removeClass("w2ui-row-selected"),delete t.colRange;else{var d=o+"-"+o;t.column<o&&(d=t.column+"-"+o),t.column>o&&(d=o+"-"+t.column);for(var u=[],c=d.split("-"),h=parseInt(c[0]);h<=parseInt(c[1]);h++)u.push(h);if(t.colRange!=d&&!0!==(T=C.trigger({phase:"before",type:"columnSelect",target:C.name,columns:u,isCancelled:!1})).isCancelled){null==t.colRange&&C.selectNone();c=d.split("-");$(C.box).find(".w2ui-grid-columns .w2ui-col-header, .w2ui-grid-fcolumns .w2ui-col-header").removeClass("w2ui-col-selected");for(var p=parseInt(c[0]);p<=parseInt(c[1]);p++)$(C.box).find("#grid_"+C.name+"_column_"+p+" .w2ui-col-header").addClass("w2ui-col-selected");$(C.box).find(".w2ui-col-number").not(".w2ui-head").addClass("w2ui-row-selected"),t.colRange=d,C.removeRange("column-selection"),C.addRange({name:"column-selection",range:[{recid:C.records[0].recid,column:c[0]},{recid:C.records[C.records.length-1].recid,column:c[1]}],style:"background-color: rgba(90, 145, 234, 0.1)"})}}}else{var f=C.get(t.recid,!0);if(null==f||C.records[f]&&C.records[f].recid!=t.recid)return;var g=C.get(r,!0);if(null==g)return;var m=parseInt(t.column),w=parseInt("TD"==e.target.tagName.toUpperCase()?$(e.target).attr("col"):$(e.target).parents("td").attr("col"));if(isNaN(m)&&isNaN(w)&&(m=0,w=C.columns.length-1),g<f){c=f;f=g,g=c}c="ind1:"+f+",ind2;"+g+",col1:"+m+",col2:"+w;if(t.range==c)return;t.range=c;for(var v=f;v<=g;v++)if(!(0<C.last.searchIds.length&&-1==C.last.searchIds.indexOf(v)))if("row"!=C.selectType){if(w<m){c=m;m=w,w=c}c=[];for(var y=m;y<=w;y++)C.columns[y].hidden||l.push({recid:C.records[v].recid,column:parseInt(y)})}else l.push(C.records[v].recid);if("row"!=C.selectType){for(var b=C.getSelection(),x=(c=[],0);x<l.length;x++){for(var _=!1,k=0;k<b.length;k++)l[x].recid==b[k].recid&&l[x].column==b[k].column&&(_=!0);_||c.push({recid:l[x].recid,column:l[x].column})}C.select.apply(C,c);for(c=[],k=0;k<b.length;k++){for(_=!1,x=0;x<l.length;x++)l[x].recid==b[k].recid&&l[x].column==b[k].column&&(_=!0);_||c.push({recid:b[k].recid,column:b[k].column})}C.unselect.apply(C,c)}else if(C.multiSelect){for(b=C.getSelection(),x=0;x<l.length;x++)-1==b.indexOf(l[x])&&C.select(l[x]);for(k=0;k<b.length;k++)-1==l.indexOf(b[k])&&C.unselect(b[k])}}}}function w(e){var t=C.last.move;if(setTimeout(function(){delete C.last.cancelClick},1),!$(e.target).parents().hasClass(".w2ui-head")&&!$(e.target).hasClass(".w2ui-head")){if(t&&-1!=["select","select-column"].indexOf(t.type)){if(null!=t.colRange&&!0!==T.isCancelled){for(var i=t.colRange.split("-"),s=[],n=0;n<C.records.length;n++){for(var a=[],r=parseInt(i[0]);r<=parseInt(i[1]);r++)a.push(r);s.push({recid:C.records[n].recid,column:a})}C.removeRange("column-selection"),C.trigger($.extend(T,{phase:"after"})),C.select.apply(C,s)}if(1==C.reorderRows&&C.last.move.reorder){var l=C.trigger({phase:"before",target:C.name,type:"reorderRow",recid:t.from,moveAfter:t.to});if(!0===l.isCancelled)return $("#grid_"+C.name+"_ghost").remove(),$("#grid_"+C.name+"_ghost_line").remove(),C.refresh(),void delete C.last.move;var o=C.get(t.from,!0),d=C.get(t.to,!0);"bottom"==t.to&&(d=C.records.length);i=C.records[o];null!=o&&null!=d&&(C.records.splice(o,1),d<o?C.records.splice(d,0,i):C.records.splice(d-1,0,i)),$("#grid_"+C.name+"_ghost").remove(),$("#grid_"+C.name+"_ghost_line").remove(),C.refresh(),C.trigger($.extend(l,{phase:"after"}))}}delete C.last.move,$(document).off(".w2ui-"+C.name)}}},destroy:function(){var e=this.trigger({phase:"before",target:this.name,type:"destroy"});!0!==e.isCancelled&&($(this.box).off(),"object"==typeof this.toolbar&&this.toolbar.destroy&&this.toolbar.destroy(),0<$(this.box).find("#grid_"+this.name+"_body").length&&$(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-grid w2ui-inactive").html(""),delete w2ui[this.name],this.trigger($.extend(e,{phase:"after"})))},initColumnOnOff:function(){if(this.show.toolbarColumns){for(var e=this,t='<div class="w2ui-col-on-off"><table><tbody><tr id="grid_'+this.name+'_column_ln_check" onclick="w2ui[\''+e.name+'\'].columnOnOff(event, \'line-numbers\'); event.stopPropagation();">   <td style="width: 30px; text-align: center; padding-right: 3px; color: #888;">      <span class="w2ui-column-check w2ui-icon-'+(e.show.lineNumbers?"check":"empty")+'"></span>   </td>   <td>      <label>'+w2utils.lang("Line #")+"</label>   </td></tr>",i=0;i<this.columns.length;i++){var s=this.columns[i],n=this.columns[i].text;!1!==s.hideable&&(!n&&this.columns[i].tooltip&&(n=this.columns[i].tooltip),n=n||"- column "+(parseInt(i)+1)+" -",t+='<tr id="grid_'+this.name+"_column_"+i+'_check"        onclick="w2ui[\''+e.name+"'].columnOnOff(event, '"+s.field+'\'); event.stopPropagation();">   <td style="width: 30px; text-align: center; padding-right: 3px; color: #888;">      <span class="w2ui-column-check w2ui-icon-'+(s.hidden?"empty":"check")+'"></span>   </td>   <td>       <label>'+w2utils.stripTags(n)+"</label>   </td></tr>")}var a="object"!=typeof this.url?this.url:this.url.get;(a&&e.show.skipRecords||e.show.saveRestoreState)&&(t+='<tr style="pointer-events: none"><td colspan="2"><div style="border-top: 1px solid #ddd;"></div></td></tr>'),a&&e.show.skipRecords&&(t+='<tr><td colspan="2" style="padding: 0px">    <div style="cursor: pointer; padding: 2px 8px; cursor: default">'+w2utils.lang("Skip")+'        <input type="text" style="width: 60px" value="'+this.offset+'"             onkeydown="if ([48,49,50,51,52,53,54,55,56,57,58,13,8,46,37,39].indexOf(event.keyCode) == -1) { event.preventDefault() }"            onkeypress="if (event.keyCode == 13) {                w2ui[\''+e.name+"'].skip(this.value);                jQuery('.w2ui-overlay')[0].hide();             }\"/> "+w2utils.lang("Records")+"    </div></td></tr>"),e.show.saveRestoreState&&(t+='<tr><td colspan="2" onclick="var obj = w2ui[\''+e.name+"']; obj.toolbar.uncheck('w2ui-column-on-off'); obj.stateSave();\">    <div style=\"cursor: pointer; padding: 4px 8px; cursor: default\">"+w2utils.lang("Save Grid State")+'</div></td></tr><tr><td colspan="2" onclick="var obj = w2ui[\''+e.name+"']; obj.toolbar.uncheck('w2ui-column-on-off'); obj.stateReset();\">    <div style=\"cursor: pointer; padding: 4px 8px; cursor: default\">"+w2utils.lang("Restore Default State")+"</div></td></tr>"),t+="</tbody></table></div>",this.toolbar.get("w2ui-column-on-off").html=t}},initColumnDrag:function(e){if(this.columnGroups&&this.columnGroups.length)throw"Draggable columns are not currently supported with column groups.";var u=this,c={};function t(){c.pressed=!1,clearTimeout(c.timeout)}function i(o){c.timeout&&clearTimeout(c.timeout);var d=this;c.pressed=!0,c.timeout=setTimeout(function(){if(c.pressed&&0!==c.numberPreColumnsPresent){var e,t,i,s,n,a=["w2ui-col-number","w2ui-col-expand","w2ui-col-select"].concat(["w2ui-head-last"]);if($(o.originalEvent.target).parents().hasClass("w2ui-head")){for(var r=0,l=a.length;r<l;r++)if($(o.originalEvent.target).parents().hasClass(a[r]))return;if(c.numberPreColumnsPresent=$(u.box).find(".w2ui-head.w2ui-col-number, .w2ui-head.w2ui-col-expand, .w2ui-head.w2ui-col-select").length,c.columnHead=s=$(o.originalEvent.target).parents(".w2ui-head"),c.originalPos=n=parseInt(s.attr("col"),10),!0===(e=u.trigger({type:"columnDragStart",phase:"before",originalEvent:o,origColumnNumber:n,target:s[0]})).isCancelled)return!1;t=c.columns=$(u.box).find(".w2ui-head:not(.w2ui-head-last)"),$(document).on("mouseup",p),$(document).on("mousemove",h),c.ghost=$(d).clone(!0),$(c.ghost).find('[col]:not([col="'+c.originalPos+'"]), .w2ui-toolbar, .w2ui-grid-header').remove(),$(c.ghost).find(".w2ui-col-number, .w2ui-col-expand, .w2ui-col-select").remove(),$(c.ghost).find(".w2ui-grid-body").css({top:0}),i=$(c.ghost).find('[col="'+c.originalPos+'"]'),$(document.body).append(c.ghost),$(c.ghost).css({width:0,height:0,margin:0,position:"fixed",zIndex:999999,opacity:0}).addClass(".w2ui-grid-ghost").animate({width:i.width(),height:$(u.box).find(".w2ui-grid-body:first").height(),left:o.pageX,top:o.pageY,opacity:.8},0),c.offsets=[];for(r=0,l=t.length;r<l;r++)c.offsets.push($(t[r]).offset().left);u.trigger($.extend(e,{phase:"after"}))}}},150)}function h(e){if(c.pressed){var t=e.originalEvent.pageX,i=e.originalEvent.pageY,s=c.offsets,n=$(".w2ui-head:not(.w2ui-head-last)").width();c.targetInt=Math.max(c.numberPreColumnsPresent,function(e,t,i){{if(e<=t[0])return 0;if(e>=t[t.length-1]+i)return t.length;for(var s=0,n=t.length;s<n;s++){var a=t[s],r=t[s+1]||t[s]+i,l=(r-t[s])/2+t[s];if(a<e&&e<=l)return s;if(l<e&&e<=r)return s+1}return intersection}}(t,s,n)),function(e){c.marker||c.markerLeft||(c.marker=$('<div class="col-intersection-marker"><div class="top-marker"></div><div class="bottom-marker"></div></div>'),c.markerLeft=$('<div class="col-intersection-marker"><div class="top-marker"></div><div class="bottom-marker"></div></div>'));c.lastInt&&c.lastInt===e||(c.lastInt=e,c.marker.remove(),c.markerLeft.remove(),$(".w2ui-head").removeClass("w2ui-col-intersection"),e>=c.columns.length?($(c.columns[c.columns.length-1]).children("div:last").append(c.marker.addClass("right").removeClass("left")),$(c.columns[c.columns.length-1]).addClass("w2ui-col-intersection")):e<=c.numberPreColumnsPresent?($(c.columns[c.numberPreColumnsPresent]).prepend(c.marker.addClass("left").removeClass("right")).css({position:"relative"}),$(c.columns[c.numberPreColumnsPresent]).prev().addClass("w2ui-col-intersection")):($(c.columns[e]).children("div:last").prepend(c.marker.addClass("left").removeClass("right")),$(c.columns[e]).prev().children("div:last").append(c.markerLeft.addClass("right").removeClass("left")).css({position:"relative"}),$(c.columns[e-1]).addClass("w2ui-col-intersection")))}(c.targetInt),function(e,t){$(c.ghost).css({left:e-10,top:t-10})}(t,i)}}function p(e){c.pressed=!1;var t,i,s,n,a,r=$(".w2ui-grid-ghost");if(!0===(t=u.trigger({type:"columnDragEnd",phase:"before",originalEvent:e,target:c.columnHead[0]})).isCancelled)return!1;s=u.columns[c.originalPos],n=u.columns,a=$(c.columns[Math.min(c.lastInt,c.columns.length-1)]),(i=c.lastInt<c.columns.length?parseInt(a.attr("col")):n.length)!==c.originalPos+1&&i!==c.originalPos&&a&&a.length?($(c.ghost).animate({top:$(u.box).offset().top,left:a.offset().left,width:0,height:0,opacity:.2},300,function(){$(this).remove(),r.remove()}),n.splice(i,0,$.extend({},s)),n.splice(n.indexOf(s),1)):($(c.ghost).remove(),r.remove()),$(document).off("mouseup",p),$(document).off("mousemove",h),c.marker&&c.marker.remove(),c={},u.refresh(),u.trigger($.extend(t,{phase:"after",targetColumnNumber:i-1}))}return c.lastInt=null,c.pressed=!1,c.timeout=null,c.columnHead=null,$(u.box).on("mousedown",i),$(u.box).on("mouseup",t),{remove:function(){$(u.box).off("mousedown",i),$(u.box).off("mouseup",t),$(u.box).find(".w2ui-head").removeAttr("draggable"),u.last.columnDrag=!1}}},columnOnOff:function(e,t){var i=$(e.target).parents("tr").find(".w2ui-column-check"),s=this.trigger({phase:"before",target:this.name,type:"columnOnOff",field:t,originalEvent:e});if(!0!==s.isCancelled){for(var n=this,a=!(e.shiftKey||e.metaKey||e.ctrlKey||$(e.target).hasClass("w2ui-column-check")),r=n.find({"w2ui.expanded":!0},!0),l=0;l<r.length;l++){var o=this.records[l].w2ui;o&&!Array.isArray(o.children)&&(this.records[l].w2ui.expanded=!1)}if("line-numbers"==t)this.show.lineNumbers=!this.show.lineNumbers,this.show.lineNumbers?i.addClass("w2ui-icon-check").removeClass("w2ui-icon-empty"):i.addClass("w2ui-icon-empty").removeClass("w2ui-icon-check"),this.refreshBody(),this.resizeRecords();else{var d=this.getColumn(t);d.hidden?(i.addClass("w2ui-icon-check").removeClass("w2ui-icon-empty"),setTimeout(function(){n.showColumn(d.field)},a?0:50)):(i.addClass("w2ui-icon-empty").removeClass("w2ui-icon-check"),setTimeout(function(){n.hideColumn(d.field)},a?0:50))}a&&setTimeout(function(){$().w2overlay({name:n.name+"_toolbar"})},40),this.trigger($.extend(s,{phase:"after"}))}},scrollToColumn:function(e){if(null!=e){for(var t=0,i=!1,s=0;s<this.columns.length;s++){var n=this.columns[s];if(n.field==e){i=!0;break}if(!n.frozen&&!n.hidden)t+=parseInt(n.sizeCalculated?n.sizeCalculated:n.size)}i&&(this.last.scrollLeft=t+1,this.scroll())}},initToolbar:function(){var r=this;if(null==this.toolbar.render){var e=this.toolbar.items||[];if(this.toolbar.items=[],this.toolbar=$().w2toolbar($.extend(!0,{},this.toolbar,{name:this.name+"_toolbar",owner:this})),this.show.toolbarReload&&this.toolbar.items.push($.extend(!0,{},this.buttons.reload)),this.show.toolbarColumns&&this.toolbar.items.push($.extend(!0,{},this.buttons.columns)),(this.show.toolbarReload||this.show.toolbarColumns)&&this.toolbar.items.push({type:"break",id:"w2ui-break0"}),this.show.toolbarInput){var t='<div class="w2ui-toolbar-search"><table cellpadding="0" cellspacing="0"><tbody><tr>    <td>'+this.buttons.search.html+'</td>    <td>        <input type="text" id="grid_'+this.name+'_search_all" class="w2ui-search-all" tabindex="-1"             autocapitalize="off" autocomplete="off" autocorrect="off" spellcheck="false"            placeholder="'+w2utils.lang(this.last.label)+'" value="'+this.last.search+'"            onfocus="var grid = w2ui[\''+this.name+'\']; clearTimeout(grid.last.kbd_timer); grid.searchShowFields(true); grid.searchClose()"            onkeydown="if (event.keyCode == 13 &amp;&amp; w2utils.isIE) this.onchange();"            onchange="                var grid = w2ui[\''+this.name+"'];                 var val = this.value;                 var sel = jQuery(this).data('selected');                var fld = jQuery(this).data('w2field');                 if (fld) val = fld.clean(val);                if (fld &amp;&amp; fld.type == 'list' &amp;&amp; sel &amp;&amp; typeof sel.id == 'undefined') {                   grid.searchReset();                } else {                   grid.search(grid.last.field, val);                }            \"/>    </td>    <td>        <div class=\"w2ui-search-clear\" id=\"grid_"+this.name+'_searchClear"               onclick="var obj = w2ui[\''+this.name+'\']; obj.searchReset();" style="display: none"        >&#160;&#160;</div>    </td></tr></tbody></table></div>';this.toolbar.items.push({type:"html",id:"w2ui-search",html:t})}if(this.show.toolbarSearch&&this.multiSearch&&0<this.searches.length&&this.toolbar.items.push($.extend(!0,{},this.buttons["search-go"])),(this.show.toolbarSearch||this.show.toolbarInput)&&(this.show.toolbarAdd||this.show.toolbarEdit||this.show.toolbarDelete||this.show.toolbarSave)&&this.toolbar.items.push({type:"break",id:"w2ui-break1"}),this.show.toolbarAdd&&Array.isArray(e)&&-1==e.map(function(e){return e.id}).indexOf(this.buttons.add.id)&&this.toolbar.items.push($.extend(!0,{},this.buttons.add)),this.show.toolbarEdit&&Array.isArray(e)&&-1==e.map(function(e){return e.id}).indexOf(this.buttons.edit.id)&&this.toolbar.items.push($.extend(!0,{},this.buttons.edit)),this.show.toolbarDelete&&Array.isArray(e)&&-1==e.map(function(e){return e.id}).indexOf(this.buttons.delete.id)&&this.toolbar.items.push($.extend(!0,{},this.buttons.delete)),this.show.toolbarSave&&Array.isArray(e)&&-1==e.map(function(e){return e.id}).indexOf(this.buttons.save.id)&&((this.show.toolbarAdd||this.show.toolbarDelete||this.show.toolbarEdit)&&this.toolbar.items.push({type:"break",id:"w2ui-break2"}),this.toolbar.items.push($.extend(!0,{},this.buttons.save))),e)for(var i=0;i<e.length;i++)this.toolbar.items.push(e[i]);r=this;this.toolbar.on("click",function(e){var t=r.trigger({phase:"before",type:"toolbar",target:e.target,originalEvent:e});if(!0!==t.isCancelled){var i=e.target;switch(i){case"w2ui-reload":if(!0===(s=r.trigger({phase:"before",type:"reload",target:r.name})).isCancelled)return!1;r.reload(),r.trigger($.extend(s,{phase:"after"}));break;case"w2ui-column-on-off":r.initColumnOnOff(),r.initResize(),r.resize();break;case"w2ui-search-advanced":this.get(i).checked?r.searchClose():r.searchOpen(),r.toolbar.tooltipHide("w2ui-search-advanced"),e.preventDefault();break;case"w2ui-add":if(!0===(s=r.trigger({phase:"before",target:r.name,type:"add",recid:null})).isCancelled)return!1;r.trigger($.extend(s,{phase:"after"})),setTimeout(function(){$().w2tag()},20);break;case"w2ui-edit":var s,n=r.getSelection(),a=null;if(1==n.length&&(a=n[0]),!0===(s=r.trigger({phase:"before",target:r.name,type:"edit",recid:a})).isCancelled)return!1;r.trigger($.extend(s,{phase:"after"})),setTimeout(function(){$().w2tag()},20);break;case"w2ui-delete":r.delete();break;case"w2ui-save":r.save()}r.trigger($.extend(t,{phase:"after"}))}}),this.toolbar.on("refresh",function(e){if("w2ui-search"==e.target){var t=r.searchData;setTimeout(function(){r.initAllField(r.last.field,1==t.length?t[0].value:null)},1)}})}},initResize:function(){var a=this;$(this.box).find(".w2ui-resizer").off("click").on("click",function(e){e.stopPropagation?e.stopPropagation():e.cancelBubble=!0,e.preventDefault&&e.preventDefault()}).off("mousedown").on("mousedown",function(e){e=e||window.event,a.resizing=!0,a.last.tmp={x:e.screenX,y:e.screenY,gx:e.screenX,gy:e.screenY,col:parseInt($(this).attr("name"))},e.stopPropagation?e.stopPropagation():e.cancelBubble=!0,e.preventDefault&&e.preventDefault();for(var t=0;t<a.columns.length;t++)a.columns[t].hidden||(null==a.columns[t].sizeOriginal&&(a.columns[t].sizeOriginal=a.columns[t].size),a.columns[t].size=a.columns[t].sizeCalculated);var i={phase:"before",type:"columnResize",target:a.name,column:a.last.tmp.col,field:a.columns[a.last.tmp.col].field};i=a.trigger($.extend(i,{resizeBy:0,originalEvent:e}));$(document).on("mousemove","body",function(e){1==a.resizing&&(e=e||window.event,!0!==(i=a.trigger($.extend(i,{resizeBy:e.screenX-a.last.tmp.gx,originalEvent:e}))).isCancelled?(a.last.tmp.x=e.screenX-a.last.tmp.x,a.last.tmp.y=e.screenY-a.last.tmp.y,a.columns[a.last.tmp.col].size=parseInt(a.columns[a.last.tmp.col].size)+a.last.tmp.x+"px",a.resizeRecords(),a.scroll(),a.last.tmp.x=e.screenX,a.last.tmp.y=e.screenY):i.isCancelled=!1)}),$(document).on("mouseup","body",function(e){delete a.resizing,$(document).off("mousemove","body"),$(document).off("mouseup","body"),a.resizeRecords(),a.scroll(),a.trigger($.extend(i,{phase:"after",originalEvent:e}))})}).off("dblclick").on("dblclick",function(e){var t=parseInt($(this).attr("name")),i=a.columns[t],s=0;if(!1===i.autoResize)return!0;e.stopPropagation?e.stopPropagation():e.cancelBubble=!0,e.preventDefault&&e.preventDefault(),$('.w2ui-grid-records td[col="'+t+'"] > div',a.box).each(function(){var e=this.offsetWidth-this.scrollWidth;e<s&&(s=e-3)});var n={phase:"before",type:"columnAutoResize",target:a.name,column:i,field:i.field};!0!==(n=a.trigger($.extend(n,{resizeBy:Math.abs(s),originalEvent:e}))).isCancelled?(s<0&&(i.size=Math.min(parseInt(i.size)+Math.abs(s),i.max||1/0)+"px",a.resizeRecords(),a.resizeRecords(),a.scroll()),a.trigger($.extend(n,{phase:"after",originalEvent:e}))):n.isCancelled=!1}).each(function(e,t){var i=$(t).parent();$(t).css({height:i.height(),"margin-left":i.width()-3+"px"})})},resizeBoxes:function(){var e=$("#grid_"+this.name+"_header"),t=$("#grid_"+this.name+"_toolbar"),i=$("#grid_"+this.name+"_fsummary"),s=$("#grid_"+this.name+"_summary"),n=$("#grid_"+this.name+"_footer"),a=$("#grid_"+this.name+"_body");this.show.header&&e.css({top:"0px",left:"0px",right:"0px"}),this.show.toolbar&&t.css({top:0+(this.show.header?w2utils.getSize(e,"height"):0)+"px",left:"0px",right:"0px"}),0<this.summary.length&&(i.css({bottom:0+(this.show.footer?w2utils.getSize(n,"height"):0)+"px"}),s.css({bottom:0+(this.show.footer?w2utils.getSize(n,"height"):0)+"px",right:"0px"})),this.show.footer&&n.css({bottom:"0px",left:"0px",right:"0px"}),a.css({top:0+(this.show.header?w2utils.getSize(e,"height"):0)+(this.show.toolbar?w2utils.getSize(t,"height"):0)+"px",bottom:0+(this.show.footer?w2utils.getSize(n,"height"):0)+(0<this.summary.length?w2utils.getSize(s,"height"):0)+"px",left:"0px",right:"0px"})},resizeRecords:function(){var a=this;$(this.box).find(".w2ui-empty-record").remove();var e=$(this.box),t=$(this.box).find("> div.w2ui-grid-box"),i=$("#grid_"+this.name+"_header"),s=$("#grid_"+this.name+"_toolbar"),n=$("#grid_"+this.name+"_summary"),r=$("#grid_"+this.name+"_fsummary"),l=$("#grid_"+this.name+"_footer"),o=$("#grid_"+this.name+"_body"),d=$("#grid_"+this.name+"_columns"),u=$("#grid_"+this.name+"_fcolumns"),c=$("#grid_"+this.name+"_records"),h=$("#grid_"+this.name+"_frecords"),p=$("#grid_"+this.name+"_scroll1"),f=8*String(this.total).length+10;f<34&&(f=34),null!=this.lineNumberWidth&&(f=this.lineNumberWidth);for(var g=!1,m=!1,w=0,v=0;v<a.columns.length;v++){if(!a.columns[v].frozen&&!a.columns[v].hidden)w+=parseInt(a.columns[v].sizeCalculated?a.columns[v].sizeCalculated:a.columns[v].size)}if(c.width()<w&&(g=!0),o.height()-d.height()<$(c).find(">table").height()+(g?w2utils.scrollBarSize():0)&&(m=!0),this.fixedBody){y=t.height()-(this.show.header?w2utils.getSize(i,"height"):0)-(this.show.toolbar?w2utils.getSize(s,"height"):0)-("none"!=n.css("display")?w2utils.getSize(n,"height"):0)-(this.show.footer?w2utils.getSize(l,"height"):0);o.css("height",y)}else{var y=w2utils.getSize(d,"height")+w2utils.getSize($("#grid_"+a.name+"_records table"),"height")+(g?w2utils.scrollBarSize():0);a.height=y+w2utils.getSize(t,"+height")+(a.show.header?w2utils.getSize(i,"height"):0)+(a.show.toolbar?w2utils.getSize(s,"height"):0)+("none"!=n.css("display")?w2utils.getSize(n,"height"):0)+(a.show.footer?w2utils.getSize(l,"height"):0),t.css("height",a.height),o.css("height",y),e.css("height",w2utils.getSize(t,"height")+w2utils.getSize(e,"+height"))}var b=this.records.length,x="object"!=typeof this.url?this.url:this.url.get;if(0==this.searchData.length||x||(b=this.last.searchIds.length),this.fixedBody||(m=!1),g||m?(d.find("> table > tbody > tr:nth-child(1) td.w2ui-head-last").css("width",w2utils.scrollBarSize()).show(),c.css({top:(0<this.columnGroups.length&&this.show.columns?1:0)+w2utils.getSize(d,"height")+"px","-webkit-overflow-scrolling":"touch","overflow-x":g?"auto":"hidden","overflow-y":m?"auto":"hidden"})):(d.find("> table > tbody > tr:nth-child(1) td.w2ui-head-last").hide(),c.css({top:(0<this.columnGroups.length&&this.show.columns?1:0)+w2utils.getSize(d,"height")+"px",overflow:"hidden"}),0<c.length&&(this.last.scrollTop=0,this.last.scrollLeft=0)),g?(h.css("margin-bottom",w2utils.scrollBarSize()),p.show()):(h.css("margin-bottom",0),p.hide()),h.css({overflow:"hidden",top:c.css("top")}),this.show.emptyRecords&&!m){var _=Math.floor(c.height()/this.recordHeight)-1,k=0;if(c[0]&&(k=c[0].scrollHeight-_*this.recordHeight),k>=this.recordHeight&&(k-=this.recordHeight,_++),this.fixedBody){for(var C=b;C<_;C++)T(C,this.recordHeight,this);T(_,k,this)}}function T(e,t,i){var s="",n="",a="";s+='<tr class="'+(e%2?"w2ui-even":"w2ui-odd")+' w2ui-empty-record" recid="-none-" style="height: '+t+'px">',n+='<tr class="'+(e%2?"w2ui-even":"w2ui-odd")+' w2ui-empty-record" recid="-none-" style="height: '+t+'px">',i.show.lineNumbers&&(s+='<td class="w2ui-col-number"></td>'),i.show.selectColumn&&(s+='<td class="w2ui-grid-data w2ui-col-select"></td>'),i.show.expandColumn&&(s+='<td class="w2ui-grid-data w2ui-col-expand"></td>'),n+='<td class="w2ui-grid-data-spacer" col="start" style="border-right: 0"></td>',i.show.orderColumn&&(n+='<td class="w2ui-grid-data w2ui-col-order" col="order"></td>');for(var r=0;r<i.columns.length;r++){var l=i.columns[r];(l.hidden||r<i.last.colStart||r>i.last.colEnd)&&!l.frozen||(a='<td class="w2ui-grid-data" '+(null!=l.attr?l.attr:"")+' col="'+r+'"></td>',l.frozen?s+=a:n+=a)}s+='<td class="w2ui-grid-data-last"></td> </tr>',n+='<td class="w2ui-grid-data-last" col="end"></td> </tr>',$("#grid_"+i.name+"_frecords > table").append(s),$("#grid_"+i.name+"_records > table").append(n)}if(0<o.length){var S=parseInt(o.width())-(m?w2utils.scrollBarSize():0)-(this.show.lineNumbers?f:0)-(this.show.selectColumn?26:0)-(this.show.expandColumn?26:0)-1,O=S,D=0,z=!1;for(v=0;v<this.columns.length;v++){0<(E=this.columns[v]).gridMinWidth&&(E.gridMinWidth>O&&!0!==E.hidden&&(z=E.hidden=!0),E.gridMinWidth<O&&!0===E.hidden&&(z=!(E.hidden=!1)))}if(!0===z)return void this.refresh();for(v=0;v<this.columns.length;v++){(E=this.columns[v]).hidden||("px"==String(E.size).substr(String(E.size).length-2).toLowerCase()?(S-=parseFloat(E.size),this.columns[v].sizeCalculated=E.size,this.columns[v].sizeType="px"):(D+=parseFloat(E.size),this.columns[v].sizeType="%",delete E.sizeCorrected))}if(100!=D&&0<D)for(v=0;v<this.columns.length;v++){(E=this.columns[v]).hidden||"%"==E.sizeType&&(E.sizeCorrected=Math.round(100*parseFloat(E.size)*100/D)/100+"%")}for(v=0;v<this.columns.length;v++){(E=this.columns[v]).hidden||"%"==E.sizeType&&(null!=this.columns[v].sizeCorrected?this.columns[v].sizeCalculated=Math.floor(S*parseFloat(E.sizeCorrected)/100)-1+"px":this.columns[v].sizeCalculated=Math.floor(S*parseFloat(E.size)/100)-1+"px")}}var I=0;for(v=0;v<this.columns.length;v++){(E=this.columns[v]).hidden||(null==E.min&&(E.min=20),parseInt(E.sizeCalculated)<parseInt(E.min)&&(E.sizeCalculated=E.min+"px"),parseInt(E.sizeCalculated)>parseInt(E.max)&&(E.sizeCalculated=E.max+"px"),I+=parseInt(E.sizeCalculated))}var j=parseInt(O)-parseInt(I);if(0<j&&0<D)for(v=0;;){var E;if(null!=(E=this.columns[v]))if(E.hidden||"px"==E.sizeType)v++;else{if(E.sizeCalculated=parseInt(E.sizeCalculated)+1+"px",0===--j)break;v++}else v=0}else 0<j&&d.find("> table > tbody > tr:nth-child(1) td.w2ui-head-last").css("width",w2utils.scrollBarSize()).show();var R=1;this.show.lineNumbers&&(R+=f),this.show.selectColumn&&(R+=26),this.show.expandColumn&&(R+=26);for(v=0;v<this.columns.length;v++)this.columns[v].hidden||this.columns[v].frozen&&(R+=parseInt(this.columns[v].sizeCalculated));u.css("width",R),h.css("width",R),r.css("width",R),p.css("width",R),d.css("left",R),c.css("left",R),n.css("left",R),d.find("> table > tbody > tr:nth-child(1) td").add(u.find("> table > tbody > tr:nth-child(1) td")).each(function(e,t){$(t).hasClass("w2ui-col-number")&&$(t).css("width",f);var i=$(t).attr("col");if(null!=i){if("start"==i){for(var s=0,n=0;n<a.last.colStart;n++)!a.columns[n]||a.columns[n].frozen||a.columns[n].hidden||(s+=parseInt(a.columns[n].sizeCalculated));$(t).css("width",s+"px")}a.columns[i]&&$(t).css("width",a.columns[i].sizeCalculated)}if($(t).hasClass("w2ui-head-last"))if(a.last.colEnd+1<a.columns.length){for(s=0,n=a.last.colEnd+1;n<a.columns.length;n++)!a.columns[n]||a.columns[n].frozen||a.columns[n].hidden||(s+=parseInt(a.columns[n].sizeCalculated));$(t).css("width",s+"px")}else $(t).css("width",w2utils.scrollBarSize()+(0<j&&0===D?j:0)+"px")}),3==d.find("> table > tbody > tr").length&&d.find("> table > tbody > tr:nth-child(1) td").add(u.find("> table > tbody > tr:nth-child(1) td")).html("").css({height:"0px",border:"0px",padding:"0px",margin:"0px"}),c.find("> table > tbody > tr:nth-child(1) td").add(h.find("> table > tbody > tr:nth-child(1) td")).each(function(e,t){$(t).hasClass("w2ui-col-number")&&$(t).css("width",f);var i=$(t).attr("col");if(null!=i){if("start"==i){for(var s=0,n=0;n<a.last.colStart;n++)!a.columns[n]||a.columns[n].frozen||a.columns[n].hidden||(s+=parseInt(a.columns[n].sizeCalculated));$(t).css("width",s+"px")}a.columns[i]&&$(t).css("width",a.columns[i].sizeCalculated)}if($(t).hasClass("w2ui-grid-data-last")&&0===$(t).parents(".w2ui-grid-frecords").length)if(a.last.colEnd+1<a.columns.length){for(s=0,n=a.last.colEnd+1;n<a.columns.length;n++)!a.columns[n]||a.columns[n].frozen||a.columns[n].hidden||(s+=parseInt(a.columns[n].sizeCalculated));$(t).css("width",s+"px")}else $(t).css("width",(0<j&&0===D?j:0)+"px")}),n.find("> table > tbody > tr:nth-child(1) td").add(r.find("> table > tbody > tr:nth-child(1) td")).each(function(e,t){$(t).hasClass("w2ui-col-number")&&$(t).css("width",f);var i=$(t).attr("col");if(null!=i){if("start"==i){for(var s=0,n=0;n<a.last.colStart;n++)!a.columns[n]||a.columns[n].frozen||a.columns[n].hidden||(s+=parseInt(a.columns[n].sizeCalculated));$(t).css("width",s+"px")}a.columns[i]&&$(t).css("width",a.columns[i].sizeCalculated)}$(t).hasClass("w2ui-grid-data-last")&&0===$(t).parents(".w2ui-grid-frecords").length&&$(t).css("width",w2utils.scrollBarSize()+(0<j&&0===D?j:0)+"px")}),this.initResize(),this.refreshRanges(),(this.last.scrollTop||this.last.scrollLeft)&&0<c.length&&(d.prop("scrollLeft",this.last.scrollLeft),c.prop("scrollTop",this.last.scrollTop),c.prop("scrollLeft",this.last.scrollLeft))},getSearchesHTML:function(){for(var l=this,e='<table cellspacing="0"><tbody>',t=!1,i=0;i<this.searches.length;i++){var s=this.searches[i];if(s.type=String(s.type).toLowerCase(),!s.hidden){var n="";0==t&&(n='<button type="button" class="w2ui-btn close-btn" onclick="obj = w2ui[\''+this.name+"']; if (obj) obj.searchClose()\">X</button>",t=!0),null==s.inTag&&(s.inTag=""),null==s.outTag&&(s.outTag=""),null==s.style&&(s.style=""),null==s.type&&(s.type="text"),null==s.label&&null!=s.caption&&(console.log("NOTICE: grid search.caption property is deprecated, please use search.label. Search ->",s),s.label=s.caption);var a='<select id="grid_'+this.name+"_operator_"+i+'" class="w2ui-input"    onchange="w2ui[\''+this.name+"'].initOperator(this, "+i+')">'+o(s.type,s.operators)+"</select>";switch(e+='<tr>    <td class="close-btn">'+n+'</td>    <td class="caption">'+(s.label||"")+'</td>    <td class="operator">'+a+'</td>    <td class="value">',s.type){case"text":case"alphanumeric":case"hex":case"color":case"list":case"combo":case"enum":var r="width: 250px;";-1!=["hex","color"].indexOf(s.type)&&(r="width: 90px;"),e+='<input rel="search" type="text" id="grid_'+this.name+"_field_"+i+'" name="'+s.field+'"    class="w2ui-input" style="'+r+s.style+'" '+s.inTag+"/>";break;case"int":case"float":case"money":case"currency":case"percent":case"date":case"time":case"datetime":r="width: 90px";"datetime"==s.type&&(r="width: 140px;"),e+='<input rel="search" type="text" class="w2ui-input" style="'+r+s.style+'" id="grid_'+this.name+"_field_"+i+'" name="'+s.field+'" '+s.inTag+'/><span id="grid_'+this.name+"_range_"+i+'" style="display: none">&#160;-&#160;&#160;<input rel="search" type="text" class="w2ui-input" style="'+r+s.style+'" id="grid_'+this.name+"_field2_"+i+'" name="'+s.field+'" '+s.inTag+"/></span>";break;case"select":e+='<select rel="search" class="w2ui-input" style="'+s.style+'" id="grid_'+this.name+"_field_"+i+'"  name="'+s.field+'" '+s.inTag+"></select>"}e+=s.outTag+"    </td></tr>"}}return e+='<tr>    <td colspan="4" class="actions">        <div>        <button type="button" class="w2ui-btn" onclick="obj = w2ui[\''+this.name+"']; if (obj) { obj.searchReset(); }\">"+w2utils.lang("Reset")+'</button>        <button type="button" class="w2ui-btn w2ui-btn-blue" onclick="obj = w2ui[\''+this.name+"']; if (obj) { obj.search(); }\">"+w2utils.lang("Search")+"</button>        </div>    </td></tr></tbody></table>";function o(e,t){var i="",s=l.operators[l.operatorsMap[e]];null!=t&&(s=t);for(var n=0;n<s.length;n++){var a=s[n],r=a;Array.isArray(a)?(r=a[1],a=a[0],null==r&&(r=a)):$.isPlainObject(a)&&(r=a.text,a=a.oper),i+='<option value="'+a+'">'+w2utils.lang(r)+"</option>\n"}return i}},initOperator:function(e,t){var i=this.searches[t],s=$("#grid_"+this.name+"_range_"+t),n=$("#grid_"+this.name+"_field_"+t),a=n.parent().find("span input");switch(n.show(),s.hide(),$(e).val()){case"between":s.show(),a.w2field(i.type,i.options);break;case"not null":case"null":n.hide(),n.val("1"),n.change()}},initSearches:function(){for(var t=this,e=0;e<this.searches.length;e++){var i=this.searches[e],s=this.getSearchData(i.field);i.type=String(i.type).toLowerCase();var n=t.operators[t.operatorsMap[i.type]];i.operators&&(n=i.operators);var a=n[0];$.isPlainObject(a)&&(a=a.oper),"object"!=typeof i.options&&(i.options={}),"text"==i.type&&(a=this.textSearch);for(var r=0;r<n.length;r++){var l=n[r];if($.isPlainObject(l)&&(l=l.oper),i.operator==l){a=i.operator;break}}switch(i.type){case"text":case"alphanumeric":$("#grid_"+this.name+"_field_"+e).w2field(i.type,i.options);break;case"int":case"float":case"hex":case"color":case"money":case"currency":case"percent":case"date":case"time":case"datetime":$("#grid_"+this.name+"_field_"+e).w2field(i.type,i.options),$("#grid_"+this.name+"_field2_"+e).w2field(i.type,i.options),setTimeout(function(){$("#grid_"+t.name+"_field_"+e).keydown(),$("#grid_"+t.name+"_field2_"+e).keydown()},1);break;case"list":case"combo":case"enum":var o=i.options;"list"==i.type&&(o.selected={}),"enum"==i.type&&(o.selected=[]),s&&(o.selected=s.value),$("#grid_"+this.name+"_field_"+e).w2field(i.type,$.extend({openOnFocus:!0},o)),s&&null!=s.text&&$("#grid_"+this.name+"_field_"+e).data("selected",{id:s.value,text:s.text});break;case"select":for(o='<option value="">--</option>',r=0;r<i.options.items.length;r++){var d=i.options.items[r];if($.isPlainObject(i.options.items[r])){var u=d.id,c=d.text;null==u&&null!=d.value&&(u=d.value),null==c&&null!=d.text&&(c=d.text),null==u&&(u=""),o+='<option value="'+u+'">'+c+"</option>"}else o+='<option value="'+d+'">'+d+"</option>"}$("#grid_"+this.name+"_field_"+e).html(o)}null!=s?("int"==s.type&&-1!=["in","not in"].indexOf(s.operator)&&$("#grid_"+this.name+"_field_"+e).w2field("clear").val(s.value),$("#grid_"+this.name+"_operator_"+e).val(s.operator).trigger("change"),$.isArray(s.value)?-1!=["in","not in"].indexOf(s.operator)?$("#grid_"+this.name+"_field_"+e).val(s.value).trigger("change"):($("#grid_"+this.name+"_field_"+e).val(s.value[0]).trigger("change"),$("#grid_"+this.name+"_field2_"+e).val(s.value[1]).trigger("change")):null!=s.value&&$("#grid_"+this.name+"_field_"+e).val(s.value).trigger("change")):$("#grid_"+this.name+"_operator_"+e).val(a).trigger("change")}$("#w2ui-overlay-"+this.name+"-searchOverlay .w2ui-grid-searches *[rel=search]").on("keypress",function(e){13==e.keyCode&&(t.search(),$().w2overlay({name:t.name+"-searchOverlay"}))})},getColumnsHTML:function(){var p=this,e="",t="";if(this.show.columnHeaders)if(0<this.columnGroups.length){var i=r(!0),s=function(){var e="<tr>",t="<tr>",i="",s=p.columnGroups.length-1;null==p.columnGroups[s].text&&null!=p.columnGroups[s].caption&&(console.log("NOTICE: grid columnGroup.caption property is deprecated, please use columnGroup.text. Group -> ",p.columnGroups[s]),p.columnGroups[s].text=p.columnGroups[s].caption);""!=p.columnGroups[p.columnGroups.length-1].text&&p.columnGroups.push({text:""});p.show.lineNumbers&&(e+='<td class="w2ui-head w2ui-col-number">    <div style="height: '+(p.recordHeight+1)+'px">&#160;</div></td>');p.show.selectColumn&&(e+='<td class="w2ui-head w2ui-col-select">    <div style="height: 25px">&#160;</div></td>');p.show.expandColumn&&(e+='<td class="w2ui-head w2ui-col-expand">    <div style="height: 25px">&#160;</div></td>');var n=0;t+='<td id="grid_'+p.name+'_column_start" class="w2ui-head" col="start" style="border-right: 0"></td>',p.show.orderColumn&&(t+='<td class="w2ui-head w2ui-col-order" col="order">    <div style="height: 25px">&#160;</div></td>');for(var a=0;a<p.columnGroups.length;a++){var r=p.columnGroups[a],l=p.columns[n];null!=r.colspan&&(r.span=r.colspan),null!=r.span&&r.span==parseInt(r.span)||(r.span=1),null==l.text&&null!=l.caption&&(console.log("NOTICE: grid column.caption property is deprecated, please use column.text. Column ->",l),l.text=l.caption);for(var o=0,d=n;d<n+r.span;d++)p.columns[d]&&!p.columns[d].hidden&&o++;if(a==p.columnGroups.length-1&&o++,o<=0);else if(!0===r.master){for(var u="",c=0;c<p.sortData.length;c++)p.sortData[c].field==l.field&&("asc"===(p.sortData[c].direction||"").toLowerCase()&&(u="w2ui-sort-up"),"desc"===(p.sortData[c].direction||"").toLowerCase()&&(u="w2ui-sort-down"));var h="";!1!==l.resizable&&(h='<div class="w2ui-resizer" name="'+n+'"></div>'),i='<td id="grid_'+p.name+"_column_"+n+'" class="w2ui-head '+u+'" col="'+n+'"     rowspan="2" colspan="'+o+'"     oncontextmenu = "w2ui[\''+p.name+"'].contextMenu(null, "+n+', event);"    onclick="w2ui[\''+p.name+"'].columnClick('"+l.field+"', event);\"    ondblclick=\"w2ui['"+p.name+"'].columnDblClick('"+l.field+"', event);\">"+h+'    <div class="w2ui-col-group w2ui-col-header '+(u?"w2ui-col-sorted":"")+'">        <div class="'+u+'"></div>'+(l.text?l.text:"&#160;")+"    </div></td>",l&&l.frozen?e+=i:t+=i}else i='<td id="grid_'+p.name+"_column_"+n+'" class="w2ui-head" col="'+n+'"         colspan="'+o+'">    <div class="w2ui-col-group">'+(r.text?r.text:"&#160;")+"    </div></td>",l&&l.frozen?e+=i:t+=i;n+=r.span}return e+="<td></td></tr>",t+='<td id="grid_'+p.name+'_column_end" class="w2ui-head" col="end"></td></tr>',[e,t]}(),n=r(!1);e=i[0]+s[0]+n[0],t=i[1]+s[1]+n[1]}else{var a=r(!0);e=a[0],t=a[1]}return[e,t];function r(e){var t="<tr>",i="<tr>";p.show.lineNumbers&&(t+='<td class="w2ui-head w2ui-col-number"        onclick="w2ui[\''+p.name+"'].columnClick('line-number', event);\"       ondblclick=\"w2ui['"+p.name+"'].columnDblClick('line-number', event);\">    <div>#</div></td>"),p.show.selectColumn&&(t+='<td class="w2ui-head w2ui-col-select"       onclick="if (event.stopPropagation) event.stopPropagation(); else event.cancelBubble = true;">    <div>        <input type="checkbox" id="grid_'+p.name+'_check_all" tabindex="-1"            style="'+(0==p.multiSelect?"display: none;":"")+'"            onmousedown="if (event.stopPropagation) event.stopPropagation(); else event.cancelBubble = true;"            onclick="var grid = w2ui[\''+p.name+"'];               if (this.checked) grid.selectAll(); else grid.selectNone();               if (event.stopPropagation) event.stopPropagation(); else event.cancelBubble = true;               clearTimeout(grid.last.kbd_timer); /* keep focus */            \"/>    </div></td>"),p.show.expandColumn&&(t+='<td class="w2ui-head w2ui-col-expand">    <div>&#160;</div></td>');var s,n=0,a=0;i+='<td id="grid_'+p.name+'_column_start" class="w2ui-head" col="start" style="border-right: 0"></td>',p.show.orderColumn&&(i+='<td class="w2ui-head w2ui-col-order" col="order">    <div>&#160;</div></td>');for(var r=0;r<p.columns.length;r++){var l=p.columns[r];if(null==l.text&&null!=l.caption&&(console.log("NOTICE: grid column.caption property is deprecated, please use column.text. Column -> ",l),l.text=l.caption),null==l.size&&(l.size="100%"),r==a&&(a+=(s=p.columnGroups[n++]||{}).span),(!(r<p.last.colStart||r>p.last.colEnd)||l.frozen)&&!l.hidden&&(!0!==s.master||e)){var o=p.getColumnCellHTML(r);l&&l.frozen?t+=o:i+=o}}return t+='<td class="w2ui-head w2ui-head-last"><div>&#160;</div></td>',i+='<td class="w2ui-head w2ui-head-last" col="end"><div>&#160;</div></td>',[t+="</tr>",i+="</tr>"]}},getColumnCellHTML:function(e){var t=this.columns[e];if(null==t)return"";for(var i=!this.reorderColumns||this.columnGroups&&this.columnGroups.length?"":" w2ui-reorder-cols-head ",s="",n=0;n<this.sortData.length;n++)this.sortData[n].field==t.field&&("asc"===(this.sortData[n].direction||"").toLowerCase()&&(s="w2ui-sort-up"),"desc"===(this.sortData[n].direction||"").toLowerCase()&&(s="w2ui-sort-down"));var a=this.last.selection.columns,r=!1;for(var l in a)for(n=0;n<a[l].length;n++)a[l][n]==e&&(r=!0);return'<td id="grid_'+this.name+"_column_"+e+'" col="'+e+'" class="w2ui-head '+s+i+'" '+("normal"==this.columnTooltip&&t.tooltip?'title="'+t.tooltip+'" ':"")+"    onmouseover = \"w2ui['"+this.name+"'].columnTooltipShow('"+e+"', event);\"    onmouseout  = \"w2ui['"+this.name+"'].columnTooltipHide('"+e+"', event);\"    oncontextmenu = \"w2ui['"+this.name+"'].contextMenu(null, "+e+', event);"    onclick="w2ui[\''+this.name+"'].columnClick('"+t.field+"', event);\"    ondblclick=\"w2ui['"+this.name+"'].columnDblClick('"+t.field+"', event);\">"+(!1!==t.resizable?'<div class="w2ui-resizer" name="'+e+'"></div>':"")+'    <div class="w2ui-col-header '+(s?"w2ui-col-sorted":"")+" "+(r?"w2ui-col-selected":"")+'">        <div class="'+s+'"></div>'+(t.text?t.text:"&#160;")+"    </div></td>"},columnTooltipShow:function(e){if("normal"!=this.columnTooltip){var t=$(this.box).find("#grid_"+this.name+"_column_"+e),i=this.columns[e],s=this.columnTooltip;t.prop("_mouse_over",!0),setTimeout(function(){!0===t.prop("_mouse_over")&&!0!==t.prop("_mouse_tooltip")&&(t.prop("_mouse_tooltip",!0),t.w2tag(i.tooltip,{position:s}))},1)}},columnTooltipHide:function(e){if("normal"!=this.columnTooltip){var t=$(this.box).find("#grid_"+this.name+"_column_"+e);this.columns[e];t.removeProp("_mouse_over"),setTimeout(function(){!0!==t.prop("_mouse_over")&&!0===t.prop("_mouse_tooltip")&&(t.removeProp("_mouse_tooltip"),t.w2tag())},1)}},getRecordsHTML:function(){var e=this.records.length,t="object"!=typeof this.url?this.url:this.url.get;0==this.searchData.length||t||(e=this.last.searchIds.length),e>this.vs_start?this.last.show_extra=this.vs_extra:this.last.show_extra=this.vs_start;var i=$("#grid_"+this.name+"_records"),s=Math.floor((i.height()||0)/this.recordHeight)+this.last.show_extra+1;(!this.fixedBody||e<s)&&(s=e);var n=this.getRecordHTML(-1,0),a="<table><tbody>"+n[0],r="<table><tbody>"+n[1];a+='<tr id="grid_'+this.name+'_frec_top" line="top" style="height: 0px">    <td colspan="2000"></td></tr>',r+='<tr id="grid_'+this.name+'_rec_top" line="top" style="height: 0px">    <td colspan="2000"></td></tr>';for(var l=0;l<s;l++)a+=(n=this.getRecordHTML(l,l+1))[0],r+=n[1];var o=(Math.max(e,this.total)-s)*this.recordHeight;return a+='<tr id="grid_'+this.name+'_frec_bottom" rec="bottom" line="bottom" style="height: '+o+'px">    <td colspan="2000" style="border: 0"></td></tr><tr id="grid_'+this.name+'_frec_more" style="display: none; visibility: hidden">    <td colspan="2000" class="w2ui-load-more"></td></tr></tbody></table>',r+='<tr id="grid_'+this.name+'_rec_bottom" rec="bottom" line="bottom" style="height: '+o+'px">    <td colspan="2000" style="border: 0"></td></tr><tr id="grid_'+this.name+'_rec_more" style="display: none">    <td colspan="2000" class="w2ui-load-more"></td></tr></tbody></table>',this.last.range_start=0,this.last.range_end=s,[a,r]},getSummaryHTML:function(){if(0!==this.summary.length){for(var e=this.getRecordHTML(-1,0),t="<table><tbody>"+e[0],i="<table><tbody>"+e[1],s=0;s<this.summary.length;s++)t+=(e=this.getRecordHTML(s,s+1,!0))[0],i+=e[1];return[t+="</tbody></table>",i+="</tbody></table>"]}},scroll:function(e){(new Date).getTime();var a=this,t="object"!=typeof this.url?this.url:this.url.get,i=$("#grid_"+this.name+"_records"),s=$("#grid_"+this.name+"_frecords");if(e){var n=e.target.scrollTop,r=e.target.scrollLeft;a.last.scrollTop=n,a.last.scrollLeft=r,$("#grid_"+a.name+"_columns")[0].scrollLeft=r,$("#grid_"+a.name+"_summary")[0].scrollLeft=r,s[0].scrollTop=n}this.last.bubbleEl&&($(this.last.bubbleEl).w2tag(),this.last.bubbleEl=null);var l=null,o=null;if(a.disableCVS||0<a.columnGroups.length)l=0,o=a.columns.length-1;else{for(var d=i.width(),u=0,c=0;c<a.columns.length;c++)if(!a.columns[c].frozen&&!a.columns[c].hidden){var h=parseInt(a.columns[c].sizeCalculated?a.columns[c].sizeCalculated:a.columns[c].size);u+h+30>a.last.scrollLeft&&null==l&&(l=c),u+h-30>a.last.scrollLeft+d&&null==o&&(o=c),u+=h}null==o&&(o=a.columns.length-1)}if(null!=l&&(l<0&&(l=0),o<0&&(o=0),l==o&&(0<l?l--:o++),l!=a.last.colStart||o!=a.last.colEnd)){var p=$(a.box),f=Math.abs(l-a.last.colStart),g=Math.abs(o-a.last.colEnd);if(f<5&&g<5){var m=p.find(".w2ui-grid-columns #grid_"+a.name+"_column_start"),w=p.find(".w2ui-grid-columns .w2ui-head-last"),v=p.find("#grid_"+a.name+"_records .w2ui-grid-data-spacer"),y=p.find("#grid_"+a.name+"_records .w2ui-grid-data-last"),b=p.find("#grid_"+a.name+"_summary .w2ui-grid-data-spacer"),x=p.find("#grid_"+a.name+"_summary .w2ui-grid-data-last");if(l>a.last.colStart)for(c=a.last.colStart;c<l;c++)p.find("#grid_"+a.name+"_columns #grid_"+a.name+"_column_"+c).remove(),p.find("#grid_"+a.name+'_records td[col="'+c+'"]').remove(),p.find("#grid_"+a.name+'_summary td[col="'+c+'"]').remove();if(o<a.last.colEnd)for(c=a.last.colEnd;o<c;c--)p.find("#grid_"+a.name+"_columns #grid_"+a.name+"_column_"+c).remove(),p.find("#grid_"+a.name+'_records td[col="'+c+'"]').remove(),p.find("#grid_"+a.name+'_summary td[col="'+c+'"]').remove();if(l<a.last.colStart)for(c=a.last.colStart-1;l<=c;c--)a.columns[c]&&(a.columns[c].frozen||a.columns[c].hidden)||(m.after(a.getColumnCellHTML(c)),v.each(function(e,t){var i=$(t).parent().attr("index"),s='<td class="w2ui-grid-data" col="'+c+'" style="height: 0px"></td>';null!=i&&(s=a.getCellHTML(parseInt(i),c,!1)),$(t).after(s)}),b.each(function(e,t){var i=$(t).parent().attr("index"),s='<td class="w2ui-grid-data" col="'+c+'" style="height: 0px"></td>';null!=i&&(s=a.getCellHTML(parseInt(i),c,!0)),$(t).after(s)}));if(o>a.last.colEnd)for(c=a.last.colEnd+1;c<=o;c++)a.columns[c]&&(a.columns[c].frozen||a.columns[c].hidden)||(w.before(a.getColumnCellHTML(c)),y.each(function(e,t){var i=$(t).parent().attr("index"),s='<td class="w2ui-grid-data" col="'+c+'" style="height: 0px"></td>';null!=i&&(s=a.getCellHTML(parseInt(i),c,!1)),$(t).before(s)}),x.each(function(e,t){var i=$(t).parent().attr("index")||-1,s=a.getCellHTML(parseInt(i),c,!0);$(t).before(s)}));a.last.colStart=l,a.last.colEnd=o,a.resizeRecords()}else{a.last.colStart=l,a.last.colEnd=o;var _=this.getColumnsHTML(),k=this.getRecordsHTML(),C=this.getSummaryHTML(),T=p.find("#grid_"+this.name+"_columns"),S=p.find("#grid_"+this.name+"_records"),O=p.find("#grid_"+this.name+"_frecords"),D=p.find("#grid_"+this.name+"_summary");T.find("tbody").html(_[1]),O.html(k[0]),S.prepend(k[1]),null!=C&&D.html(C[1]),setTimeout(function(){S.find("> table").not("table:first-child").remove(),D[0]&&(D[0].scrollLeft=a.last.scrollLeft)},1),a.resizeRecords()}}var z=this.records.length;if(0==this.searchData.length||t||(z=this.last.searchIds.length),0!==z&&0!==i.length&&0!==i.height()&&(z>this.vs_start?this.last.show_extra=this.vs_extra:this.last.show_extra=this.vs_start,!(i.height()<z*this.recordHeight&&"hidden"==i.css("overflow-y")))){var I=Math.round(i[0].scrollTop/this.recordHeight+1),j=I+(Math.round(i.height()/this.recordHeight)-1);if(z<I&&(I=z),z-1<=j&&(j=z),$("#grid_"+this.name+"_footer .w2ui-footer-right").html((a.show.statusRange?w2utils.formatNumber(this.offset+I)+"-"+w2utils.formatNumber(this.offset+j)+(-1!=this.total?" "+w2utils.lang("of")+" "+w2utils.formatNumber(this.total):""):"")+(t&&a.show.statusBuffered?" ("+w2utils.lang("buffered")+" "+w2utils.formatNumber(z)+(0<this.offset?", skip "+w2utils.formatNumber(this.offset):"")+")":"")),t||this.fixedBody&&!(-1!=this.total&&this.total<=this.vs_start)){var E=Math.floor(i[0].scrollTop/this.recordHeight)-this.last.show_extra,R=E+Math.floor(i.height()/this.recordHeight)+2*this.last.show_extra+1;E<1&&(E=1),R>this.total&&-1!=this.total&&(R=this.total);var F=i.find("#grid_"+this.name+"_rec_top"),A=i.find("#grid_"+this.name+"_rec_bottom"),M=s.find("#grid_"+this.name+"_frec_top"),N=s.find("#grid_"+this.name+"_frec_bottom");-1!=String(F.next().prop("id")).indexOf("_expanded_row")&&(F.next().remove(),M.next().remove()),this.total>R&&-1!=String(A.prev().prop("id")).indexOf("_expanded_row")&&(A.prev().remove(),N.prev().remove());var P=parseInt(F.next().attr("line")),L=parseInt(A.prev().attr("line"));if(P<E||1==P||this.last.pull_refresh){if(R<=L+this.last.show_extra-2&&R!=this.total)return;for(this.last.pull_refresh=!1;;){var H=s.find("#grid_"+this.name+"_frec_top").next();if("bottom"==(W=i.find("#grid_"+this.name+"_rec_top").next()).attr("line"))break;if(!(parseInt(W.attr("line"))<E))break;H.remove(),W.remove()}"top"==(Y=i.find("#grid_"+this.name+"_rec_bottom").prev().attr("line"))&&(Y=E);for(c=parseInt(Y)+1;c<=R;c++)if(this.records[c-1]){(W=this.records[c-1].w2ui)&&!Array.isArray(W.children)&&(W.expanded=!1);var B=this.getRecordHTML(c-1,c);A.before(B[1]),N.before(B[0])}V(),setTimeout(function(){a.refreshRanges()},0)}else{if(E>=P-this.last.show_extra+2&&1<E)return;for(;;){H=s.find("#grid_"+this.name+"_frec_bottom").prev();if("top"==(W=i.find("#grid_"+this.name+"_rec_bottom").prev()).attr("line"))break;if(!(parseInt(W.attr("line"))>R))break;H.remove(),W.remove()}var Y;"bottom"==(Y=i.find("#grid_"+this.name+"_rec_top").next().attr("line"))&&(Y=R);for(c=parseInt(Y)-1;E<=c;c--)if(this.records[c-1]){var W;(W=this.records[c-1].w2ui)&&!Array.isArray(W.children)&&(W.expanded=!1);B=this.getRecordHTML(c-1,c);F.after(B[1]),M.after(B[0])}V(),setTimeout(function(){a.refreshRanges()},0)}var K=(E-1)*a.recordHeight,U=(Math.max(z,this.total)-R)*this.recordHeight;if(U<0&&(U=0),F.css("height",K+"px"),M.css("height",K+"px"),A.css("height",U+"px"),N.css("height",U+"px"),a.last.range_start=E,a.last.range_end=R,z<Math.floor(i[0].scrollTop/this.recordHeight)+Math.floor(i.height()/this.recordHeight)+10&&!0!==this.last.pull_more&&(z<this.total-this.offset||-1==this.total&&this.last.xhr_hasMore))if(!0===this.autoLoad)this.last.pull_more=!0,this.last.xhr_offset+=this.limit,this.request("get");else{var X=$("#grid_"+this.name+"_rec_more, #grid_"+this.name+"_frec_more");"none"==X.css("display")&&X.show().on("click",function(){a.last.pull_more=!0,a.last.xhr_offset+=a.limit,a.request("get"),$(this).find("td").html('<div><div style="width: 20px; height: 20px;" class="w2ui-spinner"></div></div>')}),(0<X.find("td .w2ui-spinner").length||-1==X.find("td").text().indexOf("Load"))&&X.find("td").html("<div>"+w2utils.lang("Load")+" "+a.limit+" "+w2utils.lang("More")+"...</div>")}z>=this.total-this.offset&&-1!=this.total&&$("#grid_"+this.name+"_rec_more, #grid_"+this.name+"_frec_more").hide()}}function V(){a.markSearch&&(clearTimeout(a.last.marker_timer),a.last.marker_timer=setTimeout(function(){for(var e=[],t=0;t<a.searchData.length;t++){var i=a.searchData[t],s=a.getSearch(i.field);if(s&&!s.hidden){var n=a.getColumn(i.field,!0);e.push({field:i.field,search:i.value,col:n})}}0<e.length&&e.forEach(function(e){$(a.box).find('td[col="'+e.col+'"]').not(".w2ui-head").w2marker(e.search)})},50))}},getRecordHTML:function(e,t,i){var s,n="",a="",r="",l=this.last.selection;if(-1==e){a+='<tr line="0">',r+='<tr line="0">',this.show.lineNumbers&&(a+='<td class="w2ui-col-number" style="height: 0px;"></td>'),this.show.selectColumn&&(a+='<td class="w2ui-col-select" style="height: 0px;"></td>'),this.show.expandColumn&&(a+='<td class="w2ui-col-expand" style="height: 0px;"></td>'),r+='<td class="w2ui-grid-data w2ui-grid-data-spacer" col="start" style="height: 0px; width: 0px;"></td>',this.show.orderColumn&&(r+='<td class="w2ui-col-order" style="height: 0px;" col="order"></td>');for(var o=0;o<this.columns.length;o++){if(n='<td class="w2ui-grid-data" col="'+o+'" style="height: 0px;"></td>',(w=this.columns[o]).frozen&&!w.hidden)a+=n;else{if(w.hidden||o<this.last.colStart||o>this.last.colEnd)continue;r+=n}}return a+='<td class="w2ui-grid-data-last" style="height: 0px"></td>',r+='<td class="w2ui-grid-data-last" col="end" style="height: 0px"></td>',[a+="</tr>",r+="</tr>"]}var d="object"!=typeof this.url?this.url:this.url.get;if(!0!==i)if(0<this.searchData.length&&!d){if(e>=this.last.searchIds.length)return"";e=this.last.searchIds[e],s=this.records[e]}else{if(e>=this.records.length)return"";s=this.records[e]}else{if(e>=this.summary.length)return"";s=this.summary[e]}if(!s)return"";if(null==s.recid&&null!=this.recid){var u=this.parseField(s,this.recid);null!=u&&(s.recid=u)}w2utils.escapeId(s.recid);var c=!1;-1!=l.indexes.indexOf(e)&&(c=!0);var h=s.w2ui?s.w2ui.style:"";null!=h&&"string"==typeof h||(h="");var p=s.w2ui?s.w2ui.class:"";if(null!=p&&"string"==typeof p||(p=""),a+='<tr id="grid_'+this.name+"_frec_"+s.recid+'" recid="'+s.recid+'" line="'+t+'" index="'+e+'"  class="'+(t%2==0?"w2ui-even":"w2ui-odd")+" w2ui-record "+p+(c&&"row"==this.selectType?" w2ui-selected":"")+(s.w2ui&&!1===s.w2ui.editable?" w2ui-no-edit":"")+(s.w2ui&&!0===s.w2ui.expanded?" w2ui-expanded":"")+'" '+(!0!==i?w2utils.isIOS?"    onclick  = \"w2ui['"+this.name+"'].dblClick(jQuery(this).attr('recid'), event);\"":"    onclick  = \"w2ui['"+this.name+"'].click(jQuery(this).attr('recid'), event);\"    oncontextmenu = \"w2ui['"+this.name+"'].contextMenu(jQuery(this).attr('recid'), null, event);\"":"")+("row"==this.selectType?" onmouseover=\"jQuery('#grid_"+this.name+"_rec_'+ w2utils.escapeId(jQuery(this).attr('recid'))).addClass('w2ui-record-hover')\" onmouseout =\"jQuery('#grid_"+this.name+"_rec_'+ w2utils.escapeId(jQuery(this).attr('recid'))).removeClass('w2ui-record-hover')\"":"")+' style="height: '+this.recordHeight+"px; "+(c||""==h?h.replace("background-color","none"):h)+'" '+(""!=h?'custom_style="'+h+'"':"")+">",r+='<tr id="grid_'+this.name+"_rec_"+s.recid+'" recid="'+s.recid+'" line="'+t+'" index="'+e+'"  class="'+(t%2==0?"w2ui-even":"w2ui-odd")+" w2ui-record "+p+(c&&"row"==this.selectType?" w2ui-selected":"")+(s.w2ui&&!1===s.w2ui.editable?" w2ui-no-edit":"")+(s.w2ui&&!0===s.w2ui.expanded?" w2ui-expanded":"")+'" '+(!0!==i?w2utils.isIOS?"    onclick  = \"var obj = w2ui['"+this.name+"']; obj.dblClick(jQuery(this).attr('recid'), event);\"":"    onclick  = \"var obj = w2ui['"+this.name+"']; obj.click(jQuery(this).attr('recid'), event);\"    oncontextmenu = \"var obj = w2ui['"+this.name+"']; obj.contextMenu(jQuery(this).attr('recid'), null, event);\"":"")+("row"==this.selectType?" onmouseover=\"jQuery('#grid_"+this.name+"_frec_' + w2utils.escapeId(jQuery(this).attr('recid'))).addClass('w2ui-record-hover')\" onmouseout =\"jQuery('#grid_"+this.name+"_frec_' + w2utils.escapeId(jQuery(this).attr('recid'))).removeClass('w2ui-record-hover')\"":"")+' style="height: '+this.recordHeight+"px; "+(c||""==h?h.replace("background-color","none"):h)+'" '+(""!=h?'custom_style="'+h+'"':"")+">",this.show.lineNumbers&&(a+='<td id="grid_'+this.name+"_cell_"+e+"_number"+(i?"_s":"")+'"    class="w2ui-col-number '+(c?" w2ui-row-selected":"")+'"'+(this.reorderRows?' style="cursor: move"':"")+">"+(!0!==i?this.getLineHTML(t,s):"")+"</td>"),this.show.selectColumn){s&&s.w2ui&&!0===s.w2ui.hideCheckBox&&!0,a+='<td id="grid_'+this.name+"_cell_"+e+"_select"+(i?"_s":"")+'" class="w2ui-grid-data w2ui-col-select">'+(!0===i||s.w2ui&&!0===s.w2ui.hideCheckBox?"":'    <div>        <input class="w2ui-grid-select-check" type="checkbox" tabindex="-1" '+(c?'checked="checked"':"")+' style="pointer-events: none"/>    </div>')+"</td>"}if(this.show.expandColumn){var f="";f=s.w2ui&&!0===s.w2ui.expanded?"-":"+",s.w2ui&&"none"==s.w2ui.expanded&&(f=""),s.w2ui&&"spinner"==s.w2ui.expanded&&(f='<div class="w2ui-spinner" style="width: 16px; margin: -2px 2px;"></div>'),a+='<td id="grid_'+this.name+"_cell_"+e+"_expand"+(i?"_s":"")+'" class="w2ui-grid-data w2ui-col-expand">'+(!0!==i?'    <div ondblclick="if (event.stopPropagation) event.stopPropagation(); else event.cancelBubble = true;"             onclick="w2ui[\''+this.name+"'].toggle(jQuery(this).parents('tr').attr('recid'));                 if (event.stopPropagation) event.stopPropagation(); else event.cancelBubble = true;\">        "+f+" </div>":"")+"</td>"}r+='<td class="w2ui-grid-data-spacer" col="start" style="border-right: 0"></td>',this.show.orderColumn&&(r+='<td id="grid_'+this.name+"_cell_"+e+"_order"+(i?"_s":"")+'" class="w2ui-grid-data w2ui-col-order" col="order">'+(!0!==i?'<div title="Drag to reorder">&nbsp;</div>':"")+"</td>");for(var g=0,m=0;;){var w,v=1;if(null==(w=this.columns[g]))break;if(w.hidden)g++,0<m&&m--;else if(0<m){if(g++,null==this.columns[g])break;s.w2ui.colspan[this.columns[g-1].field]=0,m--}else{if(s.w2ui){var y=s.w2ui.colspan,b=this.columns[g].field;y&&0===y[b]&&delete y[b]}if(!(g<this.last.colStart||g>this.last.colEnd)||w.frozen){if(s.w2ui&&"object"==typeof s.w2ui.colspan){var x=parseInt(s.w2ui.colspan[w.field])||null;if(1<x){var _=0;for(o=g;o<g+x&&!(o>=this.columns.length);o++)this.columns[o].hidden&&_++;v=x-_,m=x-1}}var k=this.getCellHTML(e,g,i,v);w.frozen?a+=k:r+=k,g++}else g++}}return a+='<td class="w2ui-grid-data-last"></td>',r+='<td class="w2ui-grid-data-last" col="end"></td>',[a+="</tr>",r+="</tr>"]},getLineHTML:function(e){return"<div>"+e+"</div>"},getCellHTML:function(e,t,i,s){var n=this.columns[t];if(null==n)return"";var a=!0!==i?this.records[e]:this.summary[e],r=-1!==e?this.getCellValue(e,t,i):"",l=-1!==e?this.getCellEditable(e,t):"",o="max-height: "+parseInt(this.recordHeight)+"px;",d=!i&&a&&a.w2ui&&a.w2ui.changes&&null!=a.w2ui.changes[n.field],u="",c="",h=this.last.selection,p=!1,f="";if(-1!=h.indexes.indexOf(e)&&(p=!0),null==s&&(s=a&&a.w2ui&&a.w2ui.colspan&&a.w2ui.colspan[n.field]?a.w2ui.colspan[n.field]:1),0===t&&a&&a.w2ui&&Array.isArray(a.w2ui.children)){for(var g=0,m=this.get(a.w2ui.parent_recid,!0);null!=m;){if(g++,null==(k=this.records[m].w2ui)||null==k.parent_recid)break;m=this.get(k.parent_recid,!0)}if(a.w2ui.parent_recid)for(var w=0;w<g;w++)f+='<span class="w2ui-show-children w2ui-icon-empty"></span>';f+='<span class="w2ui-show-children '+(0<a.w2ui.children.length?a.w2ui.expanded?"w2ui-icon-collapse":"w2ui-icon-expand":"w2ui-icon-empty")+'"  onclick="event.stopPropagation(); w2ui[\''+this.name+"'].toggle(jQuery(this).parents('tr').attr('recid'))\"></span>"}if(!0===n.info&&(n.info={}),null!=n.info){var v="w2ui-icon-info";"function"==typeof n.info.icon?v=n.info.icon(a):"object"==typeof n.info.icon?v=n.info.icon[this.parseField(a,n.field)]||"":"string"==typeof n.info.icon&&(v=n.info.icon);var y=n.info.style||"";"function"==typeof n.info.style?y=n.info.style(a):"object"==typeof n.info.style?y=n.info.style[this.parseField(a,n.field)]||"":"string"==typeof n.info.style&&(y=n.info.style),f+='<span class="w2ui-info '+v+'" style="'+y+'" '+(null!=n.info.showOn?"on"+n.info.showOn:"click")+"=\"event.stopPropagation(); w2ui['"+this.name+"'].showBubble("+e+", "+t+')"'+(null!=n.info.hideOn?"on"+n.info.hideOn:"")+"=\"var grid = w2ui['"+this.name+"']; if (grid.last.bubbleEl) { $(grid.last.bubbleEl).w2tag() } grid.last.bubbleEl = null;\"></span>"}if(null!=n.render&&-1!==e){if("function"==typeof n.render){var b=n.render.call(this,a,e,t,r);null!=b&&"object"==typeof b?(r=$.trim(b.html||""),c=b.class||"",u=b.style||""):r=$.trim(b),(r.length<4||"<div"!=r.substr(0,4).toLowerCase())&&(r='<div style="'+o+'">'+f+String(r)+"</div>")}if("object"==typeof n.render){var x=n.render[r];null!=x&&""!==x||(x=r),r='<div style="'+o+'">'+f+x+"</div>"}if("string"==typeof n.render){var _=n.render.toLowerCase().indexOf(":"),k=[];-1==_?(k[0]=n.render.toLowerCase(),k[1]=""):(k[0]=n.render.toLowerCase().substr(0,_),k[1]=n.render.toLowerCase().substr(_+1));var C=w2utils.formatters[k[0]];r='<div style="'+o+'">'+f+("function"==typeof C?C(r,k[1]):"")+"</div>"}}else{if(l&&-1!=["checkbox","check"].indexOf(l.type)){var T=i?-(e+1):e;o+="text-align: center;",r='<input tabindex="-1" type="checkbox" '+(r?'checked="checked"':"")+" onclick=\"    var obj = w2ui['"+this.name+"'];     obj.editChange.call(obj, this, "+T+", "+t+', event); "/>',f=""}if(this.show.recordTitles){var S=w2utils.stripTags(String(r).replace(/"/g,"''"));null!=n.title&&("function"==typeof n.title&&(S=n.title.call(this,a,e,t)),"string"==typeof n.title&&(S=n.title))}r='<div style="'+o+'" title="'+(S||"")+'">'+f+String(r)+"</div>"}if(null==r&&(r=""),"string"==typeof n.render){k=n.render.toLowerCase().split(":");-1!=["number","int","float","money","currency","percent","size"].indexOf(k[0])&&(u+="text-align: right;")}a&&a.w2ui&&("object"==typeof a.w2ui.style&&("string"==typeof a.w2ui.style[t]&&(u+=a.w2ui.style[t]+";"),"string"==typeof a.w2ui.style[n.field]&&(u+=a.w2ui.style[n.field]+";")),"object"==typeof a.w2ui.class&&("string"==typeof a.w2ui.class[t]&&(c+=a.w2ui.class[t]+" "),"string"==typeof a.w2ui.class[n.field]&&(c+=a.w2ui.class[n.field]+" ")));var O=!1;return p&&-1!=$.inArray(t,h.columns[e])&&(O=!0),r='<td class="w2ui-grid-data'+(O?" w2ui-selected":"")+" "+c+(d?" w2ui-changed":"")+'"    id="grid_'+this.name+"_data_"+e+"_"+t+'" col="'+t+'"    style="'+u+(null!=n.style?n.style:"")+'" '+(null!=n.attr?n.attr:"")+(1<s?'colspan="'+s+'"':"")+">"+r+"</td>",-1===e&&!0===i&&(r='<td class="w2ui-grid-data" col="'+t+'" style="height: 0px; '+u+'" '+(1<s?'colspan="'+s+'"':"")+"></td>"),r},showBubble:function(e,t){var i="",s=this.columns[t].info,n=this.records[e],a=$(this.box).find("#grid_"+this.name+"_data_"+e+"_"+t+" .w2ui-info");if(this.last.bubbleEl&&$(this.last.bubbleEl).w2tag(),this.last.bubbleEl=a,null==s.fields){s.fields=[];for(var r=0;r<this.columns.length;r++){var l=this.columns[r];s.fields.push(l.field+("string"==typeof l.render?":"+l.render:""))}}var o=s.fields;if("function"==typeof o&&(o=o(n,e,t)),"function"==typeof s.render)i=s.render(n,e,t);else if($.isArray(o)){i='<table cellpadding="0" cellspacing="0">';for(r=0;r<o.length;r++){if(""!=(h=String(o[r]).split(":"))[0]&&"-"!=h[0]&&"--"!=h[0]&&"---"!=h[0]){null==(l=this.getColumn(h[0]))&&(l={field:h[0],caption:h[0]});var d=l?this.parseField(n,l.field):"";1<h.length&&(w2utils.formatters[h[1]]?d=w2utils.formatters[h[1]](d,h[2]||null):console.log('ERROR: w2utils.formatters["'+h[1]+'"] does not exists.')),(!0===s.showEmpty||null!=d&&""!=d)&&(null!=s.maxLength&&"string"==typeof d&&d.length>s.maxLength&&(d=d.substr(0,s.maxLength)+"..."),i+="<tr><td>"+l.text+"</td><td>"+((0===d?"0":d)||"")+"</td></tr>")}else i+='<tr><td colspan=2><div style="border-top: '+(""==h[0]?"0":"1")+'px solid #C1BEBE; margin: 6px 0px;"></div></td></tr>'}i+="</table>"}else if($.isPlainObject(o)){for(var u in i='<table cellpadding="0" cellspacing="0">',o){var c=o[u];if(""!=c&&"-"!=c&&"--"!=c&&"---"!=c){var h=String(c).split(":");null==(l=this.getColumn(h[0]))&&(l={field:h[0],caption:h[0]});d=l?this.parseField(n,l.field):"";1<h.length&&(w2utils.formatters[h[1]]?d=w2utils.formatters[h[1]](d,h[2]||null):console.log('ERROR: w2utils.formatters["'+h[1]+'"] does not exists.')),"function"==typeof c&&(d=c(n,e,t)),(!0===s.showEmpty||null!=d&&""!=d)&&(null!=s.maxLength&&"string"==typeof d&&d.length>s.maxLength&&(d=d.substr(0,s.maxLength)+"..."),i+="<tr><td>"+u+"</td><td>"+(d||"")+"</td></tr>")}else i+='<tr><td colspan=2><div style="border-top: '+(""==c?"0":"1")+'px solid #C1BEBE; margin: 6px 0px;"></div></td></tr>'}i+="</table>"}$(a).w2tag($.extend({html:i,left:-4,position:"bottom|top",className:"w2ui-info-bubble",style:"",hideOnClick:!0},s.options||{}))},getCellEditable:function(e,t){var i=this.columns[t],s=this.records[e];if(!s||!i)return null;var n=s.w2ui?s.w2ui.editable:null;if(!1===n)return null;if((null==n||!0===n)&&"function"==typeof(n=i?i.editable:null)){var a=this.getCellValue(e,t,!1);n=n.call(this,s,e,t,a)}return n},getCellValue:function(e,t,i){var s=this.columns[t],n=!0!==i?this.records[e]:this.summary[e],a=this.parseField(n,s.field);return n&&n.w2ui&&n.w2ui.changes&&null!=n.w2ui.changes[s.field]&&(a=n.w2ui.changes[s.field]),$.isPlainObject(a)&&(s.options&&s.options.items?(val=s.options.items.find(function(e){return e.id==a.id}),a=val?val.text:a.id):(null!=a.text&&(a=a.text),null!=a.id&&(a=a.id))),null==a&&(a=""),a},getFooterHTML:function(){return'<div>    <div class="w2ui-footer-left"></div>    <div class="w2ui-footer-right"></div>    <div class="w2ui-footer-center"></div></div>'},status:function(e){if(null!=e)$("#grid_"+this.name+"_footer").find(".w2ui-footer-left").html(e);else{var t="",i=this.getSelection();if(0<i.length&&(this.show.statusSelection&&1<i.length&&(t=String(i.length).replace(/(\d)(?=(\d\d\d)+(?!\d))/g,"$1,")+" "+w2utils.lang("selected")),this.show.statusRecordID&&1==i.length)){var s=i[0];"object"==typeof s&&(s=s.recid+", "+w2utils.lang("Column")+": "+s.column),t=w2utils.lang("Record ID")+": "+s+" "}$("#grid_"+this.name+"_footer .w2ui-footer-left").html(t),1==i.length?this.toolbar.enable("w2ui-edit"):this.toolbar.disable("w2ui-edit"),1<=i.length?this.toolbar.enable("w2ui-delete"):this.toolbar.disable("w2ui-delete")}},lock:function(e,t){var i=this,s=Array.prototype.slice.call(arguments,0);s.unshift(this.box),setTimeout(function(){$(i.box).find("#grid_"+i.name+"_empty_msg").remove(),w2utils.lock.apply(window,s)},10)},unlock:function(e){var t=this.box;setTimeout(function(){0<$(t).find(".w2ui-message").not(".w2ui-closing").length||w2utils.unlock(t,e)},25)},stateSave:function(e){var i=this;if(!w2utils.hasLocalStorage)return null;for(var s,t={columns:[],show:$.extend({},this.show),last:{search:this.last.search,multi:this.last.multi,logic:this.last.logic,label:this.last.label,field:this.last.field,scrollTop:this.last.scrollTop,scrollLeft:this.last.scrollLeft},sortData:[],searchData:[]},n=0;n<this.columns.length;n++){var a=i.columns[n],r={};Object.keys(i.stateColProps).forEach(function(e,t){i.stateColProps[e]&&(s=void 0!==a[e]?a[e]:i.stateColDefaults[e]||null,r[e]=s)}),t.columns.push(r)}for(n=0;n<this.sortData.length;n++)t.sortData.push($.extend({},this.sortData[n]));for(n=0;n<this.searchData.length;n++)t.searchData.push($.extend({},this.searchData[n]));if(!0!==e){var l=this.trigger({phase:"before",type:"stateSave",target:this.name,state:t});if(!0===l.isCancelled)return void("function"==typeof callBack&&callBack({status:"error",message:"Request aborted."}));try{var o=$.parseJSON(localStorage.w2ui||"{}");(o=o||{}).states||(o.states={}),o.states[this.stateId||this.name]=t,localStorage.w2ui=JSON.stringify(o)}catch(e){return delete localStorage.w2ui,null}this.trigger($.extend(l,{phase:"after"}))}return t},stateRestore:function(e){var t=this,i="object"!=typeof this.url?this.url:this.url.get;if(!e)try{if(!w2utils.hasLocalStorage)return!1;(l=(l=$.parseJSON(localStorage.w2ui||"{}"))||{}).states||(l.states={}),e=l.states[this.stateId||this.name]}catch(e){return delete localStorage.w2ui,null}var s=this.trigger({phase:"before",type:"stateRestore",target:this.name,state:e});if(!0!==s.isCancelled){if($.isPlainObject(e)){$.extend(this.show,e.show),$.extend(this.last,e.last);for(var n=this.last.scrollTop,a=this.last.scrollLeft,r=0;r<e.columns.length;r++){var l=e.columns[r],o=this.getColumn(l.field,!0);null!==o&&($.extend(this.columns[o],l),r!==o&&this.columns.splice(r,0,this.columns.splice(o,1)[0]))}this.sortData.splice(0,this.sortData.length);for(r=0;r<e.sortData.length;r++)this.sortData.push(e.sortData[r]);this.searchData.splice(0,this.searchData.length);for(r=0;r<e.searchData.length;r++)this.searchData.push(e.searchData[r]);setTimeout(function(){i||(0<t.sortData.length&&t.localSort(),0<t.searchData.length&&t.localSearch()),t.last.scrollTop=n,t.last.scrollLeft=a,t.refresh()},1)}return this.trigger($.extend(s,{phase:"after"})),!0}"function"==typeof callBack&&callBack({status:"error",message:"Request aborted."})},stateReset:function(){if(this.stateRestore(this.last.state),w2utils.hasLocalStorage)try{var e=$.parseJSON(localStorage.w2ui||"{}");e.states&&e.states[this.stateId||this.name]&&delete e.states[this.stateId||this.name],localStorage.w2ui=JSON.stringify(e)}catch(e){return delete localStorage.w2ui,null}},parseField:function(e,t){if(this.nestedFields){var i="";try{i=e;for(var s=String(t).split("."),n=0;n<s.length;n++)i=i[s[n]]}catch(e){i=""}return i}return e?e[t]:""},prepareData:function(){for(var r=this,e=0;e<this.records.length;e++){l(this.records[e])}function l(e){for(var t=0;t<r.columns.length;t++){var i=r.columns[t];if(null!=e[i.field]&&"string"==typeof i.render){if(-1!=["number","int","float","money","currency","percent"].indexOf(i.render.split(":")[0])&&"number"!=typeof e[i.field]&&(e[i.field]=parseFloat(e[i.field])),-1!=["date","age"].indexOf(i.render.split(":")[0])&&!e[i.field+"_"]){var s=e[i.field];w2utils.isInt(s)&&(s=parseInt(s)),e[i.field+"_"]=new Date(s)}if(-1!=["time"].indexOf(i.render))if(w2utils.isTime(e[i.field])){var n=w2utils.isTime(e[i.field],!0);(s=new Date).setHours(n.hours,n.minutes,n.seconds?n.seconds:0,0),e[i.field+"_"]||(e[i.field+"_"]=s)}else{n=e[i.field];w2utils.isInt(n)&&(n=parseInt(n));n=null!=n?new Date(n):new Date;(s=new Date).setHours(n.getHours(),n.getMinutes(),n.getSeconds(),0),e[i.field+"_"]||(e[i.field+"_"]=s)}}}if(e.w2ui&&e.w2ui.children&&!0!==e.w2ui.expanded)for(var a=0;a<e.w2ui.children.length;a++){l(e.w2ui.children[a])}}},nextCell:function(e,t,i){var s=t+1;if(s>=this.columns.length)return null;var n=this.records[e].w2ui,a=(this.columns[t],this.columns[s]),r=n&&n.colspan&&!isNaN(n.colspan[a.field])?parseInt(n.colspan[a.field]):1;if(null==a)return null;if(a&&a.hidden||0===r)return this.nextCell(e,s,i);if(i){var l=this.getCellEditable(e,t);if(null==l||-1!=["checkbox","check"].indexOf(l.type))return this.nextCell(e,s,i)}return s},prevCell:function(e,t,i){var s=t-1;if(s<0)return null;var n=this.records[e].w2ui,a=this.columns[s],r=n&&n.colspan&&!isNaN(n.colspan[a.field])?parseInt(n.colspan[a.field]):1;if(null==a)return null;if(a&&a.hidden||0===r)return this.prevCell(e,s,i);if(i){var l=this.getCellEditable(e,t);if(null==l||-1!=["checkbox","check"].indexOf(l.type))return this.prevCell(e,s,i)}return s},nextRow:function(e,t){var i=this.last.searchIds,s=null;if(e+1<this.records.length&&0===i.length||0<i.length&&e<i[i.length-1]){if(e++,0<i.length)for(;!(-1!=$.inArray(e,i)||e>this.records.length);)e++;var n=this.records[e].w2ui,a=this.columns[t];s=0===(n&&n.colspan&&null!=a&&!isNaN(n.colspan[a.field])?parseInt(n.colspan[a.field]):1)?this.nextRow(e,t):e}return s},prevRow:function(e,t){var i=this.last.searchIds,s=null;if(0<e&&0===i.length||0<i.length&&e>i[0]){if(e--,0<i.length)for(;!(-1!=$.inArray(e,i)||e<0);)e--;var n=this.records[e].w2ui,a=this.columns[t];s=0===(n&&n.colspan&&null!=a&&!isNaN(n.colspan[a.field])?parseInt(n.colspan[a.field]):1)?this.prevRow(e,t):e}return s},selectionSave:function(){return this.last._selection=this.getSelection(),this.last._selection},selectionRestore:function(e){var t=(new Date).getTime();this.last.selection={indexes:[],columns:{}};var i=this.last.selection,s=this.last._selection;if(s)for(var n=0;n<s.length;n++){var a;if($.isPlainObject(s[n]))null!=(a=this.get(s[n].recid,!0))&&(-1==i.indexes.indexOf(a)&&i.indexes.push(a),i.columns[a]||(i.columns[a]=[]),i.columns[a].push(s[n].column));else null!=(a=this.get(s[n],!0))&&i.indexes.push(a)}return delete this.last._selection,!0!==e&&this.refresh(),(new Date).getTime()-t},message:function(e,t){"string"==typeof e&&(e={width:e.length<300?350:550,height:e.length<300?170:250,body:'<div class="w2ui-centered">'+e+"</div>",buttons:'<button type="button" class="w2ui-btn" onclick="w2ui[\''+this.name+"'].message()\">Ok</button>",onOpen:function(e){setTimeout(function(){$(this.box).find(".w2ui-btn").focus()},25)},onClose:function(e){"function"==typeof t&&t()}}),w2utils.message.call(this,{box:this.box,path:"w2ui."+this.name,title:".w2ui-grid-header:visible",body:".w2ui-grid-box"},e)}},$.extend(w2grid.prototype,w2utils.event),w2obj.grid=w2grid}(jQuery),function(D){function d(e){this.box=null,this.name=null,this.panels=[],this.tmp={},this.padding=1,this.resizer=4,this.style="",D.extend(!0,this,w2obj.layout,e)}var z=["top","left","main","preview","right","bottom"];D.fn.w2layout=function(e){if(D.isPlainObject(e)){if(!w2utils.checkName(e,"w2layout"))return;var t=e.panels||[],i=new d(e);D.extend(i,{handlers:[],panels:[]});for(var s=0,n=t.length;s<n;s++)i.panels[s]=D.extend(!0,{},d.prototype.panel,t[s]),(D.isPlainObject(i.panels[s].tabs)||D.isArray(i.panels[s].tabs))&&l(i,t[s].type),(D.isPlainObject(i.panels[s].toolbar)||D.isArray(i.panels[s].toolbar))&&o(i,t[s].type);for(var a=0;a<z.length;a++)null==i.get(z[a])&&i.panels.push(D.extend(!0,{},d.prototype.panel,{type:z[a],hidden:"main"!==z[a],size:50}));return 0<D(this).length&&i.render(D(this)[0]),w2ui[i.name]=i}var r=w2ui[D(this).attr("name")];return r?0<arguments.length?(r[e]&&r[e].apply(r,Array.prototype.slice.call(arguments,1)),this):r:null;function l(e,t,i){var s=e.get(t);return null!=s&&null==i&&(i=s.tabs),null!=s&&null!=i&&(D.isArray(i)&&(i={tabs:i}),D().w2destroy(e.name+"_"+t+"_tabs"),s.tabs=D().w2tabs(D.extend({},i,{owner:e,name:e.name+"_"+t+"_tabs"})),s.show.tabs=!0)}function o(e,t,i){var s=e.get(t);return null!=s&&null==i&&(i=s.toolbar),null!=s&&null!=i&&(D.isArray(i)&&(i={items:i}),D().w2destroy(e.name+"_"+t+"_toolbar"),s.toolbar=D().w2toolbar(D.extend({},i,{owner:e,name:e.name+"_"+t+"_toolbar"})),s.show.toolbar=!0)}},d.prototype={onShow:null,onHide:null,onResizing:null,onResizerClick:null,onRender:null,onRefresh:null,onContent:null,onResize:null,onDestroy:null,panel:{type:null,title:"",size:100,minSize:20,maxSize:!1,hidden:!1,resizable:!1,overflow:"auto",style:"",content:"",tabs:null,toolbar:null,width:null,height:null,show:{toolbar:!1,tabs:!1},callBack:null,onRefresh:null,onShow:null,onHide:null},content:function(e,t,i){return console.log("NOTICE: layout.content method is deprecated, please use layout.html() instead"),this.html(e,t,i)},html:function(e,t,i){var s=this,n=this.get(e),a={panel:e,html:n.content,error:!1,cancelled:!1,removed:function(e){"function"==typeof e&&(n.callBack=e)}};if("function"==typeof n.callBack&&(n.callBack({panel:e,content:n.content,new_content:t,transition:i||"none"}),n.callBack=null),"css"==e)return D("#layout_"+s.name+"_panel_css").html("<style>"+t+"</style>"),a.status=!0,a;if(null==n)return console.log("ERROR: incorrect panel name. Panel name can be main, left, right, top, bottom, preview or css"),a.error=!0,a;if(null==t)return a;var r=this.trigger({phase:"before",type:"content",target:e,object:n,content:t,transition:i});if(!0===r.isCancelled)return a.cancelled=!0,a;if(t instanceof jQuery)return console.log("ERROR: You can not pass jQuery object to w2layout.content() method"),a;var l="#layout_"+this.name+"_panel_"+n.type,o=D(l+"> .w2ui-panel-content"),d=0;if(0<o.length&&(D(l).scrollTop(0),d=D(o).position().top),""===n.content)n.content=t,this.refresh(e);else{if(n.content=t,!n.hidden&&null!=i&&""!==i){var u=D(l+"> .w2ui-panel-content");u.after('<div class="w2ui-panel-content new-panel" style="'+u[0].style.cssText+'"></div>');var c=D(l+"> .w2ui-panel-content.new-panel");u.css("top",d),c.css("top",d),"object"==typeof t?(t.box=c[0],t.render()):c.html(t),w2utils.transition(u[0],c[0],i,function(){u.remove(),c.removeClass("new-panel"),c.css("overflow",n.overflow),s.resize(),-1!=window.navigator.userAgent.indexOf("MSIE")&&setTimeout(function(){s.resize()},100)})}this.refresh(e)}return s.trigger(D.extend(r,{phase:"after"})),s.resize(),-1!=window.navigator.userAgent.indexOf("MSIE")&&setTimeout(function(){s.resize()},100),a},message:function(e,t){var i=this;"string"==typeof t&&(t={width:t.length<300?350:550,height:t.length<300?170:250,body:'<div class="w2ui-centered">'+t+"</div>",buttons:'<button class="w2ui-btn" onclick="w2ui[\''+this.name+"'].message('"+e+"')\">Ok</button>",onOpen:function(e){setTimeout(function(){D(this.box).find(".w2ui-btn").focus()},25)}});var s,n=this.get(e),a=D("#layout_"+this.name+"_panel_"+n.type).css("overflow");t&&(t.onClose&&(s=t.onClose),t.onClose=function(e){"function"==typeof s&&s(e),e.done(function(){D("#layout_"+i.name+"_panel_"+n.type).css("overflow",a)})}),D("#layout_"+this.name+"_panel_"+n.type).css("overflow","hidden"),w2utils.message.call(this,{box:D("#layout_"+this.name+"_panel_"+n.type),param:e,path:"w2ui."+this.name,title:".w2ui-panel-title:visible",body:".w2ui-panel-content"},t)},load:function(s,e,n,a){var r=this;return"css"==s?(D.get(e,function(e,t,i){r.content(s,i.responseText),a&&a()}),!0):null!=this.get(s)&&(D.get(e,function(e,t,i){r.content(s,i.responseText,n),a&&a(),r.resize(),-1!=window.navigator.userAgent.indexOf("MSIE")&&setTimeout(function(){r.resize()},100)}),!0)},sizeTo:function(e,t,i){var s=this;return null!=s.get(e)&&(D(s.box).find(" > div > .w2ui-panel").css(w2utils.cssPrefix("transition",!0!==i?".2s":"0s")),setTimeout(function(){s.set(e,{size:t})},1),setTimeout(function(){D(s.box).find(" > div > .w2ui-panel").css(w2utils.cssPrefix("transition","0s")),s.resize()},500),!0)},show:function(e,t){var i=this,s=this.trigger({phase:"before",type:"show",target:e,object:this.get(e),immediate:t});if(!0!==s.isCancelled){var n=i.get(e);return null!=n&&(!(n.hidden=!1)===t?(D("#layout_"+i.name+"_panel_"+e).css({opacity:"1"}),i.trigger(D.extend(s,{phase:"after"})),i.resize()):(D("#layout_"+i.name+"_panel_"+e).css({opacity:"0"}),D(i.box).find(" > div > .w2ui-panel").css(w2utils.cssPrefix("transition",".2s")),setTimeout(function(){i.resize()},1),setTimeout(function(){D("#layout_"+i.name+"_panel_"+e).css({opacity:"1"})},250),setTimeout(function(){D(i.box).find(" > div > .w2ui-panel").css(w2utils.cssPrefix("transition","0s")),i.trigger(D.extend(s,{phase:"after"})),i.resize()},500)),!0)}},hide:function(e,t){var i=this,s=this.trigger({phase:"before",type:"hide",target:e,object:this.get(e),immediate:t});if(!0!==s.isCancelled){var n=i.get(e);return null!=n&&((n.hidden=!0)===t?(D("#layout_"+i.name+"_panel_"+e).css({opacity:"0"}),i.trigger(D.extend(s,{phase:"after"})),i.resize()):(D(i.box).find(" > div > .w2ui-panel").css(w2utils.cssPrefix("transition",".2s")),D("#layout_"+i.name+"_panel_"+e).css({opacity:"0"}),setTimeout(function(){i.resize()},1),setTimeout(function(){D(i.box).find(" > div > .w2ui-panel").css(w2utils.cssPrefix("transition","0s")),i.trigger(D.extend(s,{phase:"after"})),i.resize()},500)),!0)}},toggle:function(e,t){var i=this.get(e);return null!=i&&(i.hidden?this.show(e,t):this.hide(e,t))},set:function(e,t){var i=this.get(e,!0);return null!=i&&(D.extend(this.panels[i],t),null==t.content&&null==t.resizable||this.refresh(e),this.resize(),!0)},get:function(e,t){for(var i=0;i<this.panels.length;i++)if(this.panels[i].type==e)return!0===t?i:this.panels[i];return null},el:function(e){var t=D("#layout_"+this.name+"_panel_"+e+"> .w2ui-panel-content");return 1!=t.length?null:t[0]},hideToolbar:function(e){var t=this.get(e);t&&(t.show.toolbar=!1,D("#layout_"+this.name+"_panel_"+e+"> .w2ui-panel-toolbar").hide(),this.resize())},showToolbar:function(e){var t=this.get(e);t&&(t.show.toolbar=!0,D("#layout_"+this.name+"_panel_"+e+"> .w2ui-panel-toolbar").show(),this.resize())},toggleToolbar:function(e){var t=this.get(e);t&&(t.show.toolbar?this.hideToolbar(e):this.showToolbar(e))},assignToolbar:function(e,t){"string"==typeof t&&null!=w2ui[t]&&(t=w2ui[t]);var i=this.get(e);i.toolbar=t;var s=D(this.box).find(e+"> .w2ui-panel-toolbar");null!=i.toolbar?(0===s.find("[name="+i.toolbar.name+"]").length?s.w2render(i.toolbar):null!=i.toolbar&&i.toolbar.refresh(),(t.owner=this).showToolbar(e),this.refresh(e)):(s.html(""),this.hideToolbar(e))},hideTabs:function(e){var t=this.get(e);t&&(t.show.tabs=!1,D("#layout_"+this.name+"_panel_"+e+"> .w2ui-panel-tabs").hide(),this.resize())},showTabs:function(e){var t=this.get(e);t&&(t.show.tabs=!0,D("#layout_"+this.name+"_panel_"+e+"> .w2ui-panel-tabs").show(),this.resize())},toggleTabs:function(e){var t=this.get(e);t&&(t.show.tabs?this.hideTabs(e):this.showTabs(e))},render:function(e){var c=this,t=(new Date).getTime(),i=c.trigger({phase:"before",type:"render",target:c.name,box:e});if(!0!==i.isCancelled){if(null!=e&&(0<D(c.box).find("#layout_"+c.name+"_panel_main").length&&D(c.box).removeAttr("name").removeClass("w2ui-layout").html(""),c.box=e),!c.box)return!1;D(c.box).attr("name",c.name).addClass("w2ui-layout").html("<div></div>"),0<D(c.box).length&&(D(c.box)[0].style.cssText+=c.style);for(var s=0;s<z.length;s++){c.get(z[s]);var n='<div id="layout_'+c.name+"_panel_"+z[s]+'" class="w2ui-panel">    <div class="w2ui-panel-title"></div>    <div class="w2ui-panel-tabs"></div>    <div class="w2ui-panel-toolbar"></div>    <div class="w2ui-panel-content"></div></div><div id="layout_'+c.name+"_resizer_"+z[s]+'" class="w2ui-resizer"></div>';D(c.box).find(" > div").append(n)}return D(c.box).find(" > div").append('<div id="layout_'+c.name+'_panel_css" style="position: absolute; top: 10000px;"></div>'),c.refresh(),c.trigger(D.extend(i,{phase:"after"})),setTimeout(function(){c.tmp.events={resize:function(e){null==w2ui[c.name]?D(window).off("resize.w2ui-"+c.name):w2ui[c.name].resize()},resizeStart:a,mouseMove:l,mouseUp:r},D(window).on("resize.w2ui-"+c.name,c.tmp.events.resize),c.resize()},0),(new Date).getTime()-t}function a(e,t){if(c.box){t=t||window.event,D(document).off("mousemove",c.tmp.events.mouseMove).on("mousemove",c.tmp.events.mouseMove),D(document).off("mouseup",c.tmp.events.mouseUp).on("mouseup",c.tmp.events.mouseUp),c.tmp.resize={type:e,x:t.screenX,y:t.screenY,diff_x:0,diff_y:0,value:0};for(var i=0;i<z.length;i++){var s=D(c.el(z[i])).parent().find(".w2ui-lock");0<s.length?s.attr("locked","previous"):c.lock(z[i],{opacity:0})}"left"!=e&&"right"!=e||(c.tmp.resize.value=parseInt(D("#layout_"+c.name+"_resizer_"+e)[0].style.left)),"top"!=e&&"preview"!=e&&"bottom"!=e||(c.tmp.resize.value=parseInt(D("#layout_"+c.name+"_resizer_"+e)[0].style.top))}}function r(e){if(c.box&&(e=e||window.event,D(document).off("mousemove",c.tmp.events.mouseMove),D(document).off("mouseup",c.tmp.events.mouseUp),null!=c.tmp.resize)){for(var t=0;t<z.length;t++){var i=D(c.el(z[t])).parent().find(".w2ui-lock");"previous"==i.attr("locked")?i.removeAttr("locked"):c.unlock(z[t])}if(0!==c.tmp.diff_x||0!==c.tmp.resize.diff_y){var s,n,a=c.get("top"),r=c.get("bottom"),l=c.get(c.tmp.resize.type),o=parseInt(D(c.box).height()),d=parseInt(D(c.box).width()),u=String(l.size);switch(c.tmp.resize.type){case"top":s=parseInt(l.sizeCalculated)+c.tmp.resize.diff_y,n=0;break;case"bottom":s=parseInt(l.sizeCalculated)-c.tmp.resize.diff_y,n=0;break;case"preview":s=parseInt(l.sizeCalculated)-c.tmp.resize.diff_y,n=(a&&!a.hidden?a.sizeCalculated:0)+(r&&!r.hidden?r.sizeCalculated:0);break;case"left":s=parseInt(l.sizeCalculated)+c.tmp.resize.diff_x,n=0;break;case"right":s=parseInt(l.sizeCalculated)-c.tmp.resize.diff_x,n=0}"%"==u.substr(u.length-1)?l.size=Math.floor(100*s/("left"==l.type||"right"==l.type?d:o-n)*100)/100+"%":"-"==String(l.size).substr(0,1)?l.size=parseInt(l.size)-l.sizeCalculated+s:l.size=s,c.resize()}D("#layout_"+c.name+"_resizer_"+c.tmp.resize.type).removeClass("active"),delete c.tmp.resize}}function l(e){if(c.box&&(e=e||window.event,null!=c.tmp.resize)){var t=c.get(c.tmp.resize.type),i=c.tmp.resize,s=c.trigger({phase:"before",type:"resizing",target:c.name,object:t,originalEvent:e,panel:i?i.type:"all",diff_x:i?i.diff_x:0,diff_y:i?i.diff_y:0});if(!0!==s.isCancelled){var n=D("#layout_"+c.name+"_resizer_"+i.type),a=e.screenX-i.x,r=e.screenY-i.y,l=c.get("main");switch(n.hasClass("active")||n.addClass("active"),i.type){case"left":t.minSize-a>t.width&&(a=t.minSize-t.width),t.maxSize&&t.width+a>t.maxSize&&(a=t.maxSize-t.width),l.minSize+a>l.width&&(a=l.width-l.minSize);break;case"right":t.minSize+a>t.width&&(a=t.width-t.minSize),t.maxSize&&t.width-a>t.maxSize&&(a=t.width-t.maxSize),l.minSize-a>l.width&&(a=l.minSize-l.width);break;case"top":t.minSize-r>t.height&&(r=t.minSize-t.height),t.maxSize&&t.height+r>t.maxSize&&(r=t.maxSize-t.height),l.minSize+r>l.height&&(r=l.height-l.minSize);break;case"preview":case"bottom":t.minSize+r>t.height&&(r=t.height-t.minSize),t.maxSize&&t.height-r>t.maxSize&&(r=t.height-t.maxSize),l.minSize-r>l.height&&(r=l.minSize-l.height)}switch(i.diff_x=a,i.diff_y=r,i.type){case"top":case"preview":case"bottom":(i.diff_x=0)<n.length&&(n[0].style.top=i.value+i.diff_y+"px");break;case"left":case"right":(i.diff_y=0)<n.length&&(n[0].style.left=i.value+i.diff_x+"px")}c.trigger(D.extend(s,{phase:"after"}))}}}},refresh:function(e){var t=this;null==e&&(e=null);var i=(new Date).getTime(),s=t.trigger({phase:"before",type:"refresh",target:null!=e?e:t.name,object:t.get(e)});if(!0!==s.isCancelled){if("string"==typeof e){var n=t.get(e);if(null==n)return;var a="#layout_"+t.name+"_panel_"+n.type,r="#layout_"+t.name+"_resizer_"+n.type;D(a).css({display:n.hidden?"none":"block"}),n.resizable?D(r).show():D(r).hide(),"object"==typeof n.content&&"function"==typeof n.content.render?(n.content.box=D(a+"> .w2ui-panel-content")[0],setTimeout(function(){0<D(a+"> .w2ui-panel-content").length&&(D(a+"> .w2ui-panel-content").removeClass().removeAttr("name").addClass("w2ui-panel-content").css("overflow",n.overflow)[0].style.cssText+=";"+n.style),n.content&&"function"==typeof n.content.render&&n.content.render()},1)):0<D(a+"> .w2ui-panel-content").length&&(D(a+"> .w2ui-panel-content").removeClass().removeAttr("name").addClass("w2ui-panel-content").html(n.content).css("overflow",n.overflow)[0].style.cssText+=";"+n.style);var l=D(t.box).find(a+"> .w2ui-panel-tabs");n.show.tabs?0===l.find("[name="+n.tabs.name+"]").length&&null!=n.tabs?l.w2render(n.tabs):n.tabs.refresh():l.html("").removeClass("w2ui-tabs").hide(),l=D(t.box).find(a+"> .w2ui-panel-toolbar"),n.show.toolbar?0===l.find("[name="+n.toolbar.name+"]").length&&null!=n.toolbar?l.w2render(n.toolbar):n.toolbar.refresh():l.html("").removeClass("w2ui-toolbar").hide(),l=D(t.box).find(a+"> .w2ui-panel-title"),n.title?l.html(n.title).show():l.html("").hide()}else{if(0===D("#layout_"+t.name+"_panel_main").length)return void t.render();t.resize();for(var o=0;o<this.panels.length;o++)t.refresh(this.panels[o].type)}return t.trigger(D.extend(s,{phase:"after"})),(new Date).getTime()-i}},resize:function(){if(!this.box)return!1;var e=(new Date).getTime(),t=this.tmp.resize,i=this.trigger({phase:"before",type:"resize",target:this.name,panel:t?t.type:"all",diff_x:t?t.diff_x:0,diff_y:t?t.diff_y:0});if(!0!==i.isCancelled){this.padding<0&&(this.padding=0);var s=parseInt(D(this.box).width()),n=parseInt(D(this.box).height());D(this.box).find(" > div").css({width:s+"px",height:n+"px"});for(var a,r,l,o,d,u=this,c=this.get("main"),h=this.get("preview"),p=this.get("left"),f=this.get("right"),g=this.get("top"),m=this.get("bottom"),w=null!=h&&!0!==h.hidden,v=null!=p&&!0!==p.hidden,y=null!=f&&!0!==f.hidden,b=null!=g&&!0!==g.hidden,x=null!=m&&!0!==m.hidden,_=0;_<z.length;_++)if("main"!==z[_]&&(t=this.get(z[_]))){var k=String(t.size||0);if("%"==k.substr(k.length-1)){var C=n;"preview"==t.type&&(C=C-(g&&!g.hidden?g.sizeCalculated:0)-(m&&!m.hidden?m.sizeCalculated:0)),t.sizeCalculated=parseInt(("left"==t.type||"right"==t.type?s:C)*parseFloat(t.size)/100)}else t.sizeCalculated=parseInt(t.size);t.sizeCalculated=Math.max(t.sizeCalculated,parseInt(t.minSize))}"-"==String(f.size).substr(0,1)&&(v&&"-"==String(p.size).substr(0,1)?console.log("ERROR: you cannot have both left panel.size and right panel.size be negative."):f.sizeCalculated=s-(v?p.sizeCalculated:0)+parseInt(f.size)),"-"==String(p.size).substr(0,1)&&(y&&"-"==f.size.substr(0,1)?console.log("ERROR: you cannot have both left panel.size and right panel.size be negative."):p.sizeCalculated=s-(y?f.sizeCalculated:0)+parseInt(p.size)),null!=g&&!0!==g.hidden?(r=a=0,l=s,o=g.sizeCalculated,D("#layout_"+this.name+"_panel_top").css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px"}).show(),g.width=l,g.height=o,g.resizable&&(r=g.sizeCalculated-(0===this.padding?this.resizer:0),o=this.resizer>this.padding?this.resizer:this.padding,D("#layout_"+this.name+"_resizer_top").show().css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px",cursor:"ns-resize"}).off("mousedown").on("mousedown",function(e){var t=u.trigger({phase:"before",type:"resizerClick",target:"top",originalEvent:e});if(!0!==t.isCancelled)return w2ui[u.name].tmp.events.resizeStart("top",e),u.trigger(D.extend(t,{phase:"after"})),!1}))):(D("#layout_"+this.name+"_panel_top").hide(),D("#layout_"+this.name+"_resizer_top").hide()),null!=p&&!0!==p.hidden?(r=(a=0)+(b?g.sizeCalculated+this.padding:0),l=p.sizeCalculated,o=n-(b?g.sizeCalculated+this.padding:0)-(x?m.sizeCalculated+this.padding:0),d=D("#layout_"+this.name+"_panel_left"),-1!=window.navigator.userAgent.indexOf("MSIE")&&0<d.length&&d[0].clientHeight<d[0].scrollHeight&&(l+=17),d.css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px"}).show(),p.width=l,p.height=o,p.resizable&&(a=p.sizeCalculated-(0===this.padding?this.resizer:0),l=this.resizer>this.padding?this.resizer:this.padding,D("#layout_"+this.name+"_resizer_left").show().css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px",cursor:"ew-resize"}).off("mousedown").on("mousedown",function(e){var t=u.trigger({phase:"before",type:"resizerClick",target:"left",originalEvent:e});if(!0!==t.isCancelled)return w2ui[u.name].tmp.events.resizeStart("left",e),u.trigger(D.extend(t,{phase:"after"})),!1}))):(D("#layout_"+this.name+"_panel_left").hide(),D("#layout_"+this.name+"_resizer_left").hide()),null!=f&&!0!==f.hidden?(a=s-f.sizeCalculated,r=0+(b?g.sizeCalculated+this.padding:0),l=f.sizeCalculated,o=n-(b?g.sizeCalculated+this.padding:0)-(x?m.sizeCalculated+this.padding:0),D("#layout_"+this.name+"_panel_right").css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px"}).show(),f.width=l,f.height=o,f.resizable&&(a-=this.padding,l=this.resizer>this.padding?this.resizer:this.padding,D("#layout_"+this.name+"_resizer_right").show().css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px",cursor:"ew-resize"}).off("mousedown").on("mousedown",function(e){var t=u.trigger({phase:"before",type:"resizerClick",target:"right",originalEvent:e});if(!0!==t.isCancelled)return w2ui[u.name].tmp.events.resizeStart("right",e),u.trigger(D.extend(t,{phase:"after"})),!1}))):(D("#layout_"+this.name+"_panel_right").hide(),D("#layout_"+this.name+"_resizer_right").hide()),null!=m&&!0!==m.hidden?(a=0,r=n-m.sizeCalculated,l=s,o=m.sizeCalculated,D("#layout_"+this.name+"_panel_bottom").css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px"}).show(),m.width=l,m.height=o,m.resizable&&(r-=0===this.padding?0:this.padding,o=this.resizer>this.padding?this.resizer:this.padding,D("#layout_"+this.name+"_resizer_bottom").show().css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px",cursor:"ns-resize"}).off("mousedown").on("mousedown",function(e){var t=u.trigger({phase:"before",type:"resizerClick",target:"bottom",originalEvent:e});if(!0!==t.isCancelled)return w2ui[u.name].tmp.events.resizeStart("bottom",e),u.trigger(D.extend(t,{phase:"after"})),!1}))):(D("#layout_"+this.name+"_panel_bottom").hide(),D("#layout_"+this.name+"_resizer_bottom").hide()),a=0+(v?p.sizeCalculated+this.padding:0),r=0+(b?g.sizeCalculated+this.padding:0),l=s-(v?p.sizeCalculated+this.padding:0)-(y?f.sizeCalculated+this.padding:0),o=n-(b?g.sizeCalculated+this.padding:0)-(x?m.sizeCalculated+this.padding:0)-(w?h.sizeCalculated+this.padding:0),d=D("#layout_"+this.name+"_panel_main"),-1!=window.navigator.userAgent.indexOf("MSIE")&&0<d.length&&d[0].clientHeight<d[0].scrollHeight&&(l+=17),d.css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px"}),c.width=l,c.height=o,null!=h&&!0!==h.hidden?(a=0+(v?p.sizeCalculated+this.padding:0),r=n-(x?m.sizeCalculated+this.padding:0)-h.sizeCalculated,l=s-(v?p.sizeCalculated+this.padding:0)-(y?f.sizeCalculated+this.padding:0),o=h.sizeCalculated,d=D("#layout_"+this.name+"_panel_preview"),-1!=window.navigator.userAgent.indexOf("MSIE")&&0<d.length&&d[0].clientHeight<d[0].scrollHeight&&(l+=17),d.css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px"}).show(),h.width=l,h.height=o,h.resizable&&(r-=0===this.padding?0:this.padding,o=this.resizer>this.padding?this.resizer:this.padding,D("#layout_"+this.name+"_resizer_preview").show().css({display:"block",left:a+"px",top:r+"px",width:l+"px",height:o+"px",cursor:"ns-resize"}).off("mousedown").on("mousedown",function(e){var t=u.trigger({phase:"before",type:"resizerClick",target:"preview",originalEvent:e});if(!0!==t.isCancelled)return w2ui[u.name].tmp.events.resizeStart("preview",e),u.trigger(D.extend(t,{phase:"after"})),!1}))):(D("#layout_"+this.name+"_panel_preview").hide(),D("#layout_"+this.name+"_resizer_preview").hide());for(var T=0;T<z.length;T++){var $=this.get(z[T]),S="#layout_"+this.name+"_panel_"+z[T]+" > .w2ui-panel-",O=0;$&&($.title&&(O+=w2utils.getSize(D(S+"title").css({top:O+"px",display:"block"}),"height")),$.show.tabs&&(null!=$.tabs&&w2ui[this.name+"_"+z[T]+"_tabs"]&&w2ui[this.name+"_"+z[T]+"_tabs"].resize(),O+=w2utils.getSize(D(S+"tabs").css({top:O+"px",display:"block"}),"height")),$.show.toolbar&&(null!=$.toolbar&&w2ui[this.name+"_"+z[T]+"_toolbar"]&&w2ui[this.name+"_"+z[T]+"_toolbar"].resize(),O+=w2utils.getSize(D(S+"toolbar").css({top:O+"px",display:"block"}),"height"))),D(S+"content").css({display:"block"}).css({top:O+"px"})}return clearTimeout(this._resize_timer),this._resize_timer=setTimeout(function(){for(var e in w2ui)if("function"==typeof w2ui[e].resize){null==w2ui[e].panels&&w2ui[e].resize();var t=D(w2ui[e].box).parents(".w2ui-layout");0<t.length&&t.attr("name")==u.name&&w2ui[e].resize()}},100),this.trigger(D.extend(i,{phase:"after"})),(new Date).getTime()-e}},destroy:function(){var e=this.trigger({phase:"before",type:"destroy",target:this.name});if(!0!==e.isCancelled)return null!=w2ui[this.name]&&(0<D(this.box).find("#layout_"+this.name+"_panel_main").length&&D(this.box).removeAttr("name").removeClass("w2ui-layout").html(""),delete w2ui[this.name],this.trigger(D.extend(e,{phase:"after"})),this.tmp.events&&this.tmp.events.resize&&D(window).off("resize",this.tmp.events.resize),!0)},lock:function(e,t,i){if(-1!=z.indexOf(e)){var s=Array.prototype.slice.call(arguments,0);s[0]="#layout_"+this.name+"_panel_"+e,w2utils.lock.apply(window,s)}else console.log("ERROR: First parameter needs to be the a valid panel name.")},unlock:function(e,t){if(-1!=z.indexOf(e)){var i="#layout_"+this.name+"_panel_"+e;w2utils.unlock(i,t)}else console.log("ERROR: First parameter needs to be the a valid panel name.")}},D.extend(d.prototype,w2utils.event),w2obj.layout=d}(jQuery);var w2popup={};!function(g){w2popup={defaults:{title:"",body:"",buttons:"",style:"",color:"#000",opacity:.4,speed:.3,modal:!(g.fn.w2popup=function(e,t){null==e&&(t={},e="open"),g.isPlainObject(e)&&(t=e,e="open"),"load"===(e=e.toLowerCase())&&"string"==typeof t&&(t=g.extend({url:t},2<arguments.length?arguments[2]:{})),"open"===e&&null!=t.url&&(e="load"),t=t||{};var i={};if(0<g(this).length&&"open"==e){if(0<g(this).find("div[rel=title], div[rel=body], div[rel=buttons]").length){if(0<g("#w2ui-popup").length){var s=g("#w2ui-popup").data("options");w2popup._prev={template:w2popup._template,title:s.title,body:s.body,buttons:s.buttons}}w2popup._template=this,0<g(this).find("div[rel=title]").length&&(i.title=g(this).find("div[rel=title]")),0<g(this).find("div[rel=body]").length&&(i.body=g(this).find("div[rel=body]"),i.style=g(this).find("div[rel=body]")[0].style.cssText),0<g(this).find("div[rel=buttons]").length&&(i.buttons=g(this).find("div[rel=buttons]"))}else i.title="&#160;",i.body=g(this).html();0!==parseInt(g(this).css("width"))&&(i.width=parseInt(g(this).css("width")));var n=t.title||t.showClose||void 0===t.showClose||t.showMax||void 0===t.showMax;0!==parseInt(g(this).css("height"))&&(i.height=parseInt(g(this).css("height"))+(n?32:0))}return w2popup[e](g.extend({},i,t))}),maximized:!1,keyboard:!0,width:500,height:300,showClose:!0,showMax:!1,transition:null},status:"closed",handlers:[],onOpen:null,onClose:null,onMax:null,onMin:null,onToggle:null,onKeydown:null,open:function(i){var t=this;if("closing"!=w2popup.status){var e,s,n=g("#w2ui-popup").data("options");i=g.extend({},this.defaults,n,{title:"",body:"",buttons:""},i,{maximized:!1});setTimeout(function(){g("#w2ui-popup").data("options",i)},100),0===g("#w2ui-popup").length&&(w2popup.onMax=null,w2popup.onMin=null,w2popup.onToggle=null,w2popup.onOpen=null,w2popup.onClose=null,w2popup.onKeydown=null,w2popup.onAction=null),i.onOpen&&(w2popup.onOpen=i.onOpen),i.onClose&&(w2popup.onClose=i.onClose),i.onMax&&(w2popup.onMax=i.onMax),i.onMin&&(w2popup.onMin=i.onMin),i.onToggle&&(w2popup.onToggle=i.onToggle),i.onKeydown&&(w2popup.onKeydown=i.onKeydown),i.onAction&&(w2popup.onAction=i.onAction),i.width=parseInt(i.width),i.height=parseInt(i.height),null==window.innerHeight?(e=parseInt(document.documentElement.offsetWidth),s=parseInt(document.documentElement.offsetHeight),"IE7"===w2utils.engine&&(e+=21,s+=4)):(e=parseInt(window.innerWidth),s=parseInt(window.innerHeight)),e-10<i.width&&(i.width=e-10),s-10<i.height&&(i.height=s-10);var a=(s-i.height)/2*.6,r=(e-i.width)/2;if(null!=i.actions&&(i.buttons="",Object.keys(i.actions).forEach(function(e){var t=i.actions[e];"function"==typeof t&&(i.buttons+='<button class="w2ui-btn" onclick="w2popup.action(\''+e+"')\">"+e+"</button>"),"object"==typeof t&&(i.buttons+='<button class="w2ui-btn '+(t.class||"")+'" style="'+(t.style||"")+'"onclick="w2popup.action(\''+e+"')\">"+(t.text||e)+"</button>"),"string"==typeof t&&(i.buttons+=t)})),0===g("#w2ui-popup").length){if(!0===(u=this.trigger({phase:"before",type:"open",target:"popup",options:i,present:!1})).isCancelled)return;w2popup.status="opening",w2popup.lockScreen(i);var l="";i.showClose&&(l+='<div class="w2ui-popup-button w2ui-popup-close" onmousedown="event.stopPropagation()" onclick="w2popup.close()">Close</div>'),i.showMax&&(l+='<div class="w2ui-popup-button w2ui-popup-max" onmousedown="event.stopPropagation()" onclick="w2popup.toggle()">Max</div>');var o='<div id="w2ui-popup" class="w2ui-popup" style="opacity: 0; left: '+r+"px; top: "+a+"px;     width: "+parseInt(i.width)+"px; height: "+parseInt(i.height)+"px; "+w2utils.cssPrefix("transform","scale(0.8)",!0)+'"></div>';g("body").append(o);var d=g("#w2ui-popup");if(0<d.find("div[rel=title], div[rel=body], div[rel=buttons]").length)0<(f=d.find("div[rel=title]")).length&&(i.title=f.html(),f.remove()),0<(f=d.find("div[rel=buttons]")).length&&(i.buttons=f.html(),f.remove()),0<(f=d.find("div[rel=body]")).length?i.body=f.html():i.body=d.html();o='<div class="w2ui-popup-title" style="'+(i.title?"":"display: none")+'">'+l+'</div><div class="w2ui-box" style="'+(i.title?"":"top: 0px !important;")+(i.buttons?"":"bottom: 0px !important;")+'">    <div class="w2ui-popup-body'+(""!==!i.title?" w2ui-popup-no-title":"")+(i.buttons?"":" w2ui-popup-no-buttons")+'" style="'+i.style+'">    </div></div><div class="w2ui-popup-buttons" style="'+(i.buttons?"":"display: none")+'"></div><input class="w2ui-popup-hidden" style="position: absolute; top: -100px"/>';g("#w2ui-popup").html(o),i.title&&g("#w2ui-popup .w2ui-popup-title").append(i.title),i.buttons&&g("#w2ui-popup .w2ui-popup-buttons").append(i.buttons),i.body&&g("#w2ui-popup .w2ui-popup-body").append(i.body),setTimeout(function(){g("#w2ui-popup").css("opacity","1").css(w2utils.cssPrefix({transition:i.speed+"s opacity, "+i.speed+"s -webkit-transform",transform:"scale(1)"})),t.focus()},1),setTimeout(function(){g("#w2ui-popup").css(w2utils.cssPrefix("transform",""))},1e3*i.speed),w2popup.status="open",t.trigger(g.extend(u,{phase:"after"}))}else{var u;if(null==w2popup._prev&&null!=w2popup._template&&t.restoreTemplate(),!0===(u=this.trigger({phase:"before",type:"open",target:"popup",options:i,present:!0})).isCancelled)return;w2popup.status="opening",null!=n&&(n.maximized||n.width==i.width&&n.height==i.height||w2popup.resize(i.width,i.height),i.prevSize=i.width+"px:"+i.height+"px",i.maximized=n.maximized);var c=g("#w2ui-popup .w2ui-box").clone();if(c.removeClass("w2ui-box").addClass("w2ui-box-temp").find(".w2ui-popup-body").empty().append(i.body),"string"==typeof i.body&&0<c.find("div[rel=title], div[rel=body], div[rel=buttons]").length)0<(f=c.find("div[rel=title]")).length&&(i.title=f.html(),f.remove()),0<(f=c.find("div[rel=buttons]")).length&&(i.buttons=f.html(),f.remove()),0<(f=c.find("div[rel=body]")).length?i.body=f.html():i.body=c.html(),c.html(i.body);g("#w2ui-popup .w2ui-box").after(c),i.buttons?(g("#w2ui-popup .w2ui-popup-buttons").show().html("").append(i.buttons),g("#w2ui-popup .w2ui-popup-body").removeClass("w2ui-popup-no-buttons"),g("#w2ui-popup .w2ui-box, #w2ui-popup .w2ui-box-temp").css("bottom","")):(g("#w2ui-popup .w2ui-popup-buttons").hide().html(""),g("#w2ui-popup .w2ui-popup-body").addClass("w2ui-popup-no-buttons"),g("#w2ui-popup .w2ui-box, #w2ui-popup .w2ui-box-temp").css("bottom","0px")),i.title?(g("#w2ui-popup .w2ui-popup-title").show().html((i.showClose?'<div class="w2ui-popup-button w2ui-popup-close" onmousedown="event.stopPropagation()" onclick="w2popup.close()">Close</div>':"")+(i.showMax?'<div class="w2ui-popup-button w2ui-popup-max" onmousedown="event.stopPropagation()" onclick="w2popup.toggle()">Max</div>':"")).append(i.title),g("#w2ui-popup .w2ui-popup-body").removeClass("w2ui-popup-no-title"),g("#w2ui-popup .w2ui-box, #w2ui-popup .w2ui-box-temp").css("top","")):(g("#w2ui-popup .w2ui-popup-title").hide().html(""),g("#w2ui-popup .w2ui-popup-body").addClass("w2ui-popup-no-title"),g("#w2ui-popup .w2ui-box, #w2ui-popup .w2ui-box-temp").css("top","0px"));var h=g("#w2ui-popup .w2ui-box")[0],p=g("#w2ui-popup .w2ui-box-temp")[0];w2utils.transition(h,p,i.transition,function(){t.restoreTemplate(),g(h).remove(),g(p).removeClass("w2ui-box-temp").addClass("w2ui-box");var e=g(p).find(".w2ui-popup-body");1==e.length&&(e[0].style.cssText=i.style),g("#w2ui-popup").data("prev-size",null),t.focus()}),w2popup.status="open",t.trigger(g.extend(u,{phase:"after"}))}i._last_focus=g(":focus"),i.keyboard&&g(document).on("keydown",this.keydown);var f={resizing:!1,mvMove:function(e){if(1!=f.resizing)return;e=e||window.event;f.div_x=e.screenX-f.x,f.div_y=e.screenY-f.y;var t=w2popup.trigger({phase:"before",type:"move",target:"popup",div_x:f.div_x,div_y:f.div_y});if(!0===t.isCancelled)return;g("#w2ui-popup").css(w2utils.cssPrefix({transition:"none",transform:"translate3d("+f.div_x+"px, "+f.div_y+"px, 0px)"})),w2popup.trigger(g.extend(t,{phase:"after"}))},mvStop:function(e){if(1!=f.resizing)return;e=e||window.event;w2popup.status="open",f.div_x=e.screenX-f.x,f.div_y=e.screenY-f.y,g("#w2ui-popup").css({left:f.pos_x+f.div_x+"px",top:f.pos_y+f.div_y+"px"}).css(w2utils.cssPrefix({transition:"none",transform:"translate3d(0px, 0px, 0px)"})),f.resizing=!1,g(document).off("mousemove",f.mvMove),g(document).off("mouseup",f.mvStop),f.isLocked||w2popup.unlock()}};return g("#w2ui-popup .w2ui-popup-title").on("mousedown",function(e){w2popup.get().maximized||function(e){e=e||window.event;w2popup.status="moving",f.resizing=!0,f.isLocked=1==g("#w2ui-popup > .w2ui-lock").length,f.x=e.screenX,f.y=e.screenY,f.pos_x=g("#w2ui-popup").position().left,f.pos_y=g("#w2ui-popup").position().top,f.isLocked||w2popup.lock({opacity:0});g(document).on("mousemove",f.mvMove),g(document).on("mouseup",f.mvStop),e.stopPropagation?e.stopPropagation():e.cancelBubble=!0;{if(!e.preventDefault)return;e.preventDefault()}}(e)}),this}setTimeout(function(){t.open.call(t,i)},100)},action:function(e){var t=g("#w2ui-popup").data("options").actions[e];switch(typeof t){case"function":t(e);break;case"object":"function"==typeof t.onClick&&t.onClick(e)}},keydown:function(e){var t=g("#w2ui-popup").data("options");if(!t||t.keyboard){var i=w2popup.trigger({phase:"before",type:"keydown",target:"popup",options:t,originalEvent:e});if(!0!==i.isCancelled){switch(e.keyCode){case 27:e.preventDefault(),0<g("#w2ui-popup .w2ui-message").length?w2popup.message():w2popup.close()}w2popup.trigger(g.extend(i,{phase:"after"}))}}},close:function(e){var t=this;e=g.extend({},g("#w2ui-popup").data("options"),e);if(0!==g("#w2ui-popup").length&&"closed"!=this.status)if("opening"!=this.status){var i=this.trigger({phase:"before",type:"close",target:"popup",options:e});!0!==i.isCancelled&&(w2popup.status="closing",g("#w2ui-popup").css("opacity","0").css(w2utils.cssPrefix({transition:e.speed+"s opacity, "+e.speed+"s -webkit-transform",transform:"scale(0.9)"})),w2popup.unlockScreen(e),setTimeout(function(){t.restoreTemplate(),g("#w2ui-popup").remove(),w2popup.status="closed",e._last_focus&&0<e._last_focus.length&&e._last_focus.focus(),t.trigger(g.extend(i,{phase:"after"}))},1e3*e.speed),e.keyboard&&g(document).off("keydown",this.keydown))}else setTimeout(function(){w2popup.close()},100)},toggle:function(){var e=this,t=g("#w2ui-popup").data("options"),i=this.trigger({phase:"before",type:"toggle",target:"popup",options:t});!0!==i.isCancelled&&(!0===t.maximized?w2popup.min():w2popup.max(),setTimeout(function(){e.trigger(g.extend(i,{phase:"after"}))},1e3*t.speed+50))},max:function(){var e=this,t=g("#w2ui-popup").data("options");if(!0!==t.maximized){var i=this.trigger({phase:"before",type:"max",target:"popup",options:t});!0!==i.isCancelled&&(w2popup.status="resizing",t.prevSize=g("#w2ui-popup").css("width")+":"+g("#w2ui-popup").css("height"),w2popup.resize(1e4,1e4,function(){w2popup.status="open",t.maximized=!0,e.trigger(g.extend(i,{phase:"after"})),g("#w2ui-popup .w2ui-grid, #w2ui-popup .w2ui-form, #w2ui-popup .w2ui-layout").each(function(){var e=g(this).attr("name");w2ui[e]&&w2ui[e].resize&&w2ui[e].resize()})}))}},min:function(){var e=this,t=g("#w2ui-popup").data("options");if(!0===t.maximized){var i=t.prevSize.split(":"),s=this.trigger({phase:"before",type:"min",target:"popup",options:t});!0!==s.isCancelled&&(w2popup.status="resizing",w2popup.resize(parseInt(i[0]),parseInt(i[1]),function(){w2popup.status="open",t.maximized=!1,t.prevSize=null,e.trigger(g.extend(s,{phase:"after"})),g("#w2ui-popup .w2ui-grid, #w2ui-popup .w2ui-form, #w2ui-popup .w2ui-layout").each(function(){var e=g(this).attr("name");w2ui[e]&&w2ui[e].resize&&w2ui[e].resize()})}))}},get:function(){return g("#w2ui-popup").data("options")},set:function(e){w2popup.open(e)},clear:function(){g("#w2ui-popup .w2ui-popup-title").html(""),g("#w2ui-popup .w2ui-popup-body").html(""),g("#w2ui-popup .w2ui-popup-buttons").html("")},reset:function(){w2popup.open(w2popup.defaults)},load:function(s){if(w2popup.status="loading",null!=s.url){var e=String(s.url).split("#"),n=e[0],a=e[1];null==s&&(s={});var t=g("#w2ui-popup").data(n);null!=t?r(t,a):g.get(n,function(e,t,i){r(i.responseText,a),g("#w2ui-popup").data(n,i.responseText)})}else console.log("ERROR: The url parameter is empty.");function r(e,t){if(delete s.url,g("body").append('<div id="w2ui-tmp" style="display: none">'+e+"</div>"),null!=t&&0<g("#w2ui-tmp #"+t).length?g("#w2ui-tmp #"+t).w2popup(s):g("#w2ui-tmp > div").w2popup(s),0<g("#w2ui-tmp > style").length){var i=g("<div>").append(g("#w2ui-tmp > style").clone()).html();0===g("#w2ui-popup #div-style").length&&g("#w2ui-popup").append('<div id="div-style" style="position: absolute; left: -100; width: 1px"></div>'),g("#w2ui-popup #div-style").html(i)}g("#w2ui-tmp").remove()}},message:function(t){var i=this;g().w2tag(),t=t||{width:200,height:100};var e=parseInt(g("#w2ui-popup").width()),s=parseInt(g("#w2ui-popup").height());t.originalWidth=t.width,t.originalHeight=t.height,parseInt(t.width)<10&&(t.width=10),parseInt(t.height)<10&&(t.height=10),null==t.hideOnClick&&(t.hideOnClick=!1);var n=g("#w2ui-popup").data("options")||{},a=parseInt(g("#w2ui-popup > .w2ui-popup-title").css("height"));(null==t.width||t.width>n.width-10)&&(t.width=n.width-10),(null==t.height||t.height>n.height-a-5)&&(t.height=n.height-a-5),t.originalHeight<0&&(t.height=s+t.originalHeight-a),t.originalWidth<0&&(t.width=e+2*t.originalWidth);var r=g("#w2ui-popup .w2ui-popup-title"),l=g("#w2ui-popup .w2ui-message").length;if(""===g.trim(t.html)&&""===g.trim(t.body)&&""===g.trim(t.buttons)){var o=g("#w2ui-popup #w2ui-message"+(l-1));t=o.data("options")||{};o.css(w2utils.cssPrefix({transition:"0.15s",transform:"translateY(-"+t.height+"px)"})),1==l?w2popup.unlock(150):g("#w2ui-popup #w2ui-message"+(l-2)).css("z-index",1500),setTimeout(function(){var e=o.data("prev_focus");o.remove(),e&&0<e.length?e.focus():i.focus(),"function"==typeof t.onClose&&t.onClose()},150)}else{""===g.trim(t.body)&&""===g.trim(t.buttons)||(t.html='<div class="w2ui-message-body">'+t.body+'</div><div class="w2ui-message-buttons">'+t.buttons+"</div>"),g("#w2ui-popup .w2ui-message").css("z-index",1390),r.css("z-index",1501),g("#w2ui-popup .w2ui-box").before('<div id="w2ui-message'+l+'" class="w2ui-message" style="display: none; z-index: 1500; '+(0===r.length?"top: 0px;":"top: "+w2utils.getSize(r,"height")+"px;")+(null!=t.width?"width: "+t.width+"px; left: "+(e-t.width)/2+"px;":"left: 10px; right: 10px;")+(null!=t.height?"height: "+t.height+"px;":"bottom: 6px;")+w2utils.cssPrefix("transition","0s",!0)+'"'+(!0===t.hideOnClick?'onclick="w2popup.message();"':"")+"></div>"),g("#w2ui-popup #w2ui-message"+l).data("options",t).data("prev_focus",g(":focus"));var d=g("#w2ui-popup #w2ui-message"+l).css("display");g("#w2ui-popup #w2ui-message"+l).css(w2utils.cssPrefix({transform:"none"==d?"translateY(-"+t.height+"px)":"translateY(0px)"})),"none"==d&&(g("#w2ui-popup #w2ui-message"+l).show().html(t.html),setTimeout(function(){g("#w2ui-popup #w2ui-message"+l).css(g.extend(w2utils.cssPrefix("transition",".3s",!1),w2utils.cssPrefix({transform:"none"==d?"translateY(0px)":"translateY(-"+t.height+"px)"})))},1),0===l&&w2popup.lock(),setTimeout(function(){i.focus(),g("#w2ui-popup #w2ui-message"+l).css(w2utils.cssPrefix({transition:"0s"})),"function"==typeof t.onOpen&&t.onOpen()},350))}},focus:function(){var i=null,e=g("#w2ui-popup"),s="input:visible, button:visible, select:visible, textarea:visible, [contentEditable]";g(e).find(s).off(".keep-focus");var t=g("#w2ui-popup .w2ui-message").length-1,n=g("#w2ui-popup #w2ui-message"+t);if(0<n.length)0<(a=g(n[n.length-1]).find("button")).length&&a[0].focus(),i=n;else if(0<e.length){var a;0<(a=e.find(".w2ui-popup-buttons button")).length&&a[0].focus(),i=e}g(i).find(s).on("blur.keep-focus",function(e){setTimeout(function(){var e=g(":focus");if(0<e.length&&!g(i).find(s).is(e)||e.hasClass("w2ui-popup-hidden")){var t=g(i).find(s);0<t.length&&t[0].focus()}},1)})},lock:function(e,t){var i=Array.prototype.slice.call(arguments,0);i.unshift(g("#w2ui-popup")),w2utils.lock.apply(window,i)},unlock:function(e){w2utils.unlock(g("#w2ui-popup"),e)},lockScreen:function(e){return!(0<g("#w2ui-lock").length)&&(null==e&&(e=g("#w2ui-popup").data("options")),null==e&&(e={}),e=g.extend({},w2popup.defaults,e),g("body").append('<div id="w2ui-lock"     onmousewheel="if (event.stopPropagation) event.stopPropagation(); else event.cancelBubble = true; if (event.preventDefault) event.preventDefault(); else return false;"    style="position: '+("IE5"==w2utils.engine?"absolute":"fixed")+"; z-Index: 1199; left: 0px; top: 0px;            padding: 0px; margin: 0px; background-color: "+e.color+'; width: 100%; height: 100%; opacity: 0;"></div>'),setTimeout(function(){g("#w2ui-lock").css("opacity",e.opacity).css(w2utils.cssPrefix("transition",e.speed+"s opacity"))},1),1==e.modal?(g("#w2ui-lock").on("mousedown",function(){g("#w2ui-lock").css("opacity","0.6").css(w2utils.cssPrefix("transition",".1s"))}),g("#w2ui-lock").on("mouseup",function(){setTimeout(function(){g("#w2ui-lock").css("opacity",e.opacity).css(w2utils.cssPrefix("transition",".1s"))},100)})):g("#w2ui-lock").on("mousedown",function(){w2popup.close()}),!0)},unlockScreen:function(e){return 0!==g("#w2ui-lock").length&&(null==e&&(e=g("#w2ui-popup").data("options")),null==e&&(e={}),e=g.extend({},w2popup.defaults,e),g("#w2ui-lock").css("opacity","0").css(w2utils.cssPrefix("transition",e.speed+"s opacity")),setTimeout(function(){g("#w2ui-lock").remove()},1e3*e.speed),!0)},resizeMessages:function(){g("#w2ui-popup").data("options");g("#w2ui-popup .w2ui-message").each(function(){var e=g(this).data("options"),t=g("#w2ui-popup");parseInt(e.width)<10&&(e.width=10),parseInt(e.height)<10&&(e.height=10);var i=parseInt(t.find("> .w2ui-popup-title").css("height")),s=parseInt(t.width()),n=parseInt(t.height());e.width=e.originalWidth,e.width>s-10&&(e.width=s-10),e.height=e.originalHeight,e.height>n-i-5&&(e.height=n-i-5),e.originalHeight<0&&(e.height=n+e.originalHeight-i),e.originalWidth<0&&(e.width=s+2*e.originalWidth),g(this).css({left:(s-e.width)/2+"px",width:e.width+"px",height:e.height+"px"})})},resize:function(e,t,i){var s,n,a=this,r=g("#w2ui-popup").data("options")||{};null==r.speed&&(r.speed=0),e=parseInt(e),t=parseInt(t),null==window.innerHeight?(s=parseInt(document.documentElement.offsetWidth),n=parseInt(document.documentElement.offsetHeight),"IE7"===w2utils.engine&&(s+=21,n+=4)):(s=parseInt(window.innerWidth),n=parseInt(window.innerHeight)),s-10<e&&(e=s-10),n-10<t&&(t=n-10);var l=(n-t)/2*.6,o=(s-e)/2;g("#w2ui-popup").css(w2utils.cssPrefix({transition:r.speed+"s width, "+r.speed+"s height, "+r.speed+"s left, "+r.speed+"s top"})).css({top:l,left:o,width:e,height:t});var d=setInterval(function(){a.resizeMessages()},10);setTimeout(function(){clearInterval(d),r.width=e,r.height=t,a.resizeMessages(),"function"==typeof i&&i()},1e3*r.speed+50)},restoreTemplate:function(){var e=g("#w2ui-popup").data("options");if(null!=e){var t=w2popup._template,i=e.title,s=e.body,n=e.buttons;if(w2popup._prev?(t=w2popup._prev.template,i=w2popup._prev.title,s=w2popup._prev.body,n=w2popup._prev.buttons,delete w2popup._prev):delete w2popup._template,null!=t){var a=g(t);if(0===a.length)return;"body"==g(s).attr("rel")?(i&&a.append(i),s&&a.append(s),n&&a.append(n)):a.append(s)}}}},g.extend(w2popup,w2utils.event)}(jQuery);var w2alert=function(e,t,i){var s=jQuery;return null==t&&(t=w2utils.lang("Notification")),0<s("#w2ui-popup").length&&"closing"!=w2popup.status?w2popup.message({width:400,height:170,body:'<div class="w2ui-centered w2ui-alert-msg" style="font-size: 13px;">'+e+"</div>",buttons:'<button onclick="w2popup.message();" class="w2ui-popup-btn w2ui-btn">'+w2utils.lang("Ok")+"</button>",onOpen:function(){s("#w2ui-popup .w2ui-message .w2ui-popup-btn").focus()},onClose:function(){"function"==typeof i&&i()}}):w2popup.open({width:450,height:220,showMax:!1,showClose:!1,title:t,body:'<div class="w2ui-centered w2ui-alert-msg" style="font-size: 13px;">'+e+"</div>",buttons:'<button onclick="w2popup.close();" class="w2ui-popup-btn w2ui-btn">'+w2utils.lang("Ok")+"</button>",onOpen:function(e){setTimeout(function(){s("#w2ui-popup .w2ui-popup-btn").focus()},1)},onKeydown:function(e){s("#w2ui-popup .w2ui-popup-btn").focus().addClass("clicked")},onClose:function(){"function"==typeof i&&i()}}),{ok:function(e){return i=e,this},done:function(e){return i=e,this}}},w2confirm=function(e,t,i){var s=jQuery,n={},a={msg:"",title:w2utils.lang("Confirmation"),width:0<s("#w2ui-popup").length?400:450,height:0<s("#w2ui-popup").length?170:220,yes_text:"Yes",yes_class:"",yes_style:"",yes_callBack:null,no_text:"No",no_class:"",no_style:"",no_callBack:null,focus_to_no:!1,callBack:null};return 1==arguments.length&&"object"==typeof e?s.extend(n,a,e):"function"==typeof t?s.extend(n,a,{msg:e,callBack:t}):s.extend(n,a,{msg:e,title:t,callBack:i}),"object"==typeof n.btn_yes&&(n.yes_text=n.btn_yes.text||n.yes_text,n.yes_class=n.btn_yes.class||n.yes_class,n.yes_style=n.btn_yes.style||n.yes_style,n.yes_callBack=n.btn_yes.callBack||n.yes_callBack),"object"==typeof n.btn_no&&(n.no_text=n.btn_no.text||n.no_text,n.no_class=n.btn_no.class||n.no_class,n.no_style=n.btn_no.style||n.no_style,n.no_callBack=n.btn_no.callBack||n.no_callBack),0<s("#w2ui-popup").length&&"closing"!=w2popup.status&&w2popup.get()?(n.width>w2popup.get().width&&(n.width=w2popup.get().width),n.height>w2popup.get().height-50&&(n.height=w2popup.get().height-50),w2popup.message({width:n.width,height:n.height,body:'<div class="w2ui-centered w2ui-confirm-msg" style="font-size: 13px;">'+n.msg+"</div>",buttons:w2utils.settings.macButtonOrder?'<button id="No" class="w2ui-popup-btn w2ui-btn '+n.no_class+'" style="'+n.no_style+'">'+w2utils.lang(n.no_text)+'</button><button id="Yes" class="w2ui-popup-btn w2ui-btn '+n.yes_class+'" style="'+n.yes_style+'">'+w2utils.lang(n.yes_text)+"</button>":'<button id="Yes" class="w2ui-popup-btn w2ui-btn '+n.yes_class+'" style="'+n.yes_style+'">'+w2utils.lang(n.yes_text)+'</button><button id="No" class="w2ui-popup-btn w2ui-btn '+n.no_class+'" style="'+n.no_style+'">'+w2utils.lang(n.no_text)+"</button>",onOpen:function(e){s("#w2ui-popup .w2ui-message .w2ui-btn").on("click.w2confirm",function(e){w2popup._confirm_btn=e.target.id,w2popup.message()}),"function"==typeof n.onOpen&&n.onOpen()},onClose:function(e){s("#w2ui-popup .w2ui-message .w2ui-btn").off("click.w2confirm"),setTimeout(function(){"function"==typeof n.callBack&&n.callBack(w2popup._confirm_btn),"Yes"==w2popup._confirm_btn&&"function"==typeof n.yes_callBack&&n.yes_callBack(),"No"==w2popup._confirm_btn&&"function"==typeof n.no_callBack&&n.no_callBack()},300),"function"==typeof n.onClose&&n.onClose()}})):(w2utils.isInt(n.height)||(n.height=n.height+50),w2popup.open({width:n.width,height:n.height,title:n.title,modal:!0,showClose:!1,body:'<div class="w2ui-centered w2ui-confirm-msg" style="font-size: 13px;">'+n.msg+"</div>",buttons:w2utils.settings.macButtonOrder?'<button id="No" class="w2ui-popup-btn w2ui-btn '+n.no_class+'" style="'+n.no_style+'">'+w2utils.lang(n.no_text)+'</button><button id="Yes" class="w2ui-popup-btn w2ui-btn '+n.yes_class+'" style="'+n.yes_style+'">'+w2utils.lang(n.yes_text)+"</button>":'<button id="Yes" class="w2ui-popup-btn w2ui-btn '+n.yes_class+'" style="'+n.yes_style+'">'+w2utils.lang(n.yes_text)+'</button><button id="No" class="w2ui-popup-btn w2ui-btn '+n.no_class+'" style="'+n.no_style+'">'+w2utils.lang(n.no_text)+"</button>",onOpen:function(e){setTimeout(function(){s("#w2ui-popup .w2ui-popup-btn").on("click",function(e){w2popup.close(),"function"==typeof n.callBack&&n.callBack(e.target.id),"Yes"==e.target.id&&"function"==typeof n.yes_callBack&&n.yes_callBack(),"No"==e.target.id&&"function"==typeof n.no_callBack&&n.no_callBack()}),n.focus_to_no?s("#w2ui-popup .w2ui-popup-btn#No").focus():s("#w2ui-popup .w2ui-popup-btn#Yes").focus(),"function"==typeof n.onOpen&&n.onOpen()},1)},onClose:function(e){"function"==typeof n.onClose&&n.onClose()},onKeydown:function(e){if(0===s("#w2ui-popup .w2ui-message").length)switch(e.originalEvent.keyCode){case 13:s("#w2ui-popup .w2ui-popup-btn#Yes").focus().addClass("clicked"),w2popup.close();break;case 27:s("#w2ui-popup .w2ui-popup-btn#No").focus().click(),w2popup.close()}}})),{yes:function(e){return n.yes_callBack=e,this},no:function(e){return n.no_callBack=e,this}}},w2prompt=function(e,t,i){var s=jQuery,n={},a={label:"",value:"",attrs:"",textarea:!1,title:w2utils.lang("Notification"),ok_text:w2utils.lang("Ok"),cancel_text:w2utils.lang("Cancel"),width:0<s("#w2ui-popup").length?400:450,height:0<s("#w2ui-popup").length?170:220,callBack:null};return 1==arguments.length&&"object"==typeof e?s.extend(n,a,e):"function"==typeof t?s.extend(n,a,{label:e,callBack:t}):s.extend(n,a,{label:e,title:t,callBack:i}),0<s("#w2ui-popup").length&&"closing"!=w2popup.status&&w2popup.get()?(n.width>w2popup.get().width&&(n.width=w2popup.get().width),n.height>w2popup.get().height-50&&(n.height=w2popup.get().height-50),w2popup.message({width:n.width,height:n.height,body:n.textarea?'<div class="w2ui-prompt" style="font-size: 13px; padding: 15px 10px 0 10px;">  <div style="padding-bottom: 5px">'+n.label+'</div>  <textarea id="w2prompt" '+n.attrs+"></textarea></div>":'<div class="w2ui-prompt w2ui-centered" style="font-size: 13px;">  <label style="margin-right: 10px;">'+n.label+'</label>  <input id="w2prompt" '+n.attrs+"></div>",buttons:w2utils.settings.macButtonOrder?'<button id="Cancel" class="w2ui-popup-btn w2ui-btn '+n.cancel_class+'">'+n.cancel_text+'</button><button id="Ok" class="w2ui-popup-btn w2ui-btn '+n.ok_class+'">'+n.ok_text+"</button>":'<button id="Ok" class="w2ui-popup-btn w2ui-btn '+n.ok_class+'">'+n.ok_text+'</button><button id="Cancel" class="w2ui-popup-btn w2ui-btn '+n.cancel_class+'">'+n.cancel_text+"</button>",onOpen:function(){s("#w2prompt").val(n.value),s("#w2ui-popup .w2ui-message .w2ui-btn#Ok").on("click.w2prompt",function(e){w2popup._prompt_value=s("#w2prompt").val(),w2popup.message()}),s("#w2ui-popup .w2ui-message .w2ui-btn#Cancel").on("click.w2prompt",function(e){w2popup._prompt_value=null,w2popup.message()}),setTimeout(function(){s("#w2prompt").focus()},100),"function"==typeof n.onOpen&&n.onOpen()},onClose:function(){s("#w2ui-popup .w2ui-message .w2ui-btn").off("click.w2prompt"),setTimeout(function(){"function"==typeof n.callBack&&null!=w2popup._prompt_value&&n.callBack(w2popup._prompt_value)},300),"function"==typeof n.onClose&&n.onClose()}})):(w2utils.isInt(n.height)||(n.height=n.height+50),w2popup.open({width:n.width,height:n.height,title:n.title,modal:!0,showClose:!1,body:n.textarea?'<div class="w2ui-prompt" style="font-size: 13px; padding: 15px 10px 0 10px;">  <div style="padding-bottom: 5px">'+n.label+'</div>  <textarea id="w2prompt" '+n.attrs+"></textarea></div>":'<div class="w2ui-prompt w2ui-centered" style="font-size: 13px;">  <label style="margin-right: 10px;">'+n.label+'</label>  <input id="w2prompt" '+n.attrs+"></div>",buttons:w2utils.settings.macButtonOrder?'<button id="Cancel" class="w2ui-popup-btn w2ui-btn">'+n.cancel_text+'</button><button id="Ok" class="w2ui-popup-btn w2ui-btn">'+n.ok_text+"</button>":'<button id="Ok" class="w2ui-popup-btn w2ui-btn">'+n.ok_text+'</button><button id="Cancel" class="w2ui-popup-btn w2ui-btn">'+n.cancel_text+"</button>",onOpen:function(e){setTimeout(function(){s("#w2prompt").val(n.value),s("#w2prompt").w2field("text"),s("#w2ui-popup .w2ui-popup-btn#Ok").on("click",function(e){w2popup._prompt_value=s("#w2prompt").val(),w2popup.close(),"function"==typeof n.callBack&&n.callBack(w2popup._prompt_value)}),s("#w2ui-popup .w2ui-popup-btn#Cancel").on("click",function(e){w2popup._prompt_value=null,w2popup.close()}),s("#w2ui-popup .w2ui-popup-btn#Ok"),setTimeout(function(){s("#w2prompt").focus()},100),"function"==typeof n.onOpen&&n.onOpen()},1)},onClose:function(e){"function"==typeof n.onClose&&n.onClose()},onKeydown:function(e){if(0===s("#w2ui-popup .w2ui-message").length)switch(e.originalEvent.keyCode){case 13:s("#w2ui-popup .w2ui-popup-btn#Ok").focus().addClass("clicked"),w2popup.close();break;case 27:w2popup.close()}}})),{change:function(e){return s("#w2prompt").on("keyup",e).keyup(),this},ok:function(e){return n.callBack=e,this}}};!function(c){function a(e){this.box=null,this.name=null,this.active=null,this.flow="down",this.tooltip="top|left",this.tabs=[],this.routeData={},this.right="",this.style="",c.extend(this,{handlers:[]}),c.extend(!0,this,w2obj.tabs,e)}c.fn.w2tabs=function(e){if(c.isPlainObject(e)){if(!w2utils.checkName(e,"w2tabs"))return;for(var t=e.tabs||[],i=new a(e),s=0;s<t.length;s++)i.tabs[s]=c.extend({},a.prototype.tab,t[s]);return 0!==c(this).length&&i.render(c(this)[0]),w2ui[i.name]=i}var n=w2ui[c(this).attr("name")];return n?0<arguments.length?(n[e]&&n[e].apply(n,Array.prototype.slice.call(arguments,1)),this):n:null},a.prototype={onClick:null,onClose:null,onRender:null,onRefresh:null,onResize:null,onDestroy:null,tab:{id:null,text:null,route:null,hidden:!1,disabled:!1,closable:!1,tooltip:null,style:"",onClick:null,onRefresh:null,onClose:null},add:function(e){return this.insert(null,e)},insert:function(e,t){c.isArray(t)||(t=[t]);for(var i=0;i<t.length;i++){if(null==t[i].id)return void console.log('ERROR: The parameter "id" is required but not supplied. (obj: '+this.name+")");if(!w2utils.checkUniqueId(t[i].id,this.tabs,"tabs",this.name))return;var s=c.extend({},a.prototype.tab,t[i]);if(null==e)this.tabs.push(s);else{var n=this.get(e,!0);this.tabs=this.tabs.slice(0,n).concat([s],this.tabs.slice(n))}this.refresh(t[i].id),this.resize()}},remove:function(){for(var e=0,t=0;t<arguments.length;t++){var i=this.get(arguments[t]);if(!i)return!1;e++,this.tabs.splice(this.get(i.id,!0),1),c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(i.id)).remove()}return this.resize(),e},select:function(e){return this.active!=e&&null!=this.get(e)&&(this.active=e,this.refresh(),!0)},set:function(e,t){var i=this.get(e,!0);return null!=i&&(c.extend(this.tabs[i],t),this.refresh(e),!0)},get:function(e,t){if(0===arguments.length){for(var i=[],s=0;s<this.tabs.length;s++)null!=this.tabs[s].id&&i.push(this.tabs[s].id);return i}for(var n=0;n<this.tabs.length;n++)if(this.tabs[n].id==e)return!0===t?n:this.tabs[n];return null},show:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&!1!==n.hidden&&(e++,n.hidden=!1,i.push(n.id))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e]);t.resize()},15),e},hide:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&!0!==n.hidden&&(e++,n.hidden=!0,i.push(n.id))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e]);t.resize()},15),e},enable:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&!1!==n.disabled&&(e++,n.disabled=!1,i.push(n.id))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e])},15),e},disable:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&!0!==n.disabled&&(e++,n.disabled=!0,i.push(n.id))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e])},15),e},tooltipShow:function(e,t,i){if(null!=this.tooltip){var s=c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(e)),n=this.get(e),a=this.tooltip,r=n.tooltip;"function"==typeof r&&(r=r.call(this,n)),s.prop("_mouse_over",!0),setTimeout(function(){!0===s.prop("_mouse_over")&&!0!==s.prop("_mouse_tooltip")&&(s.prop("_mouse_tooltip",!0),s.w2tag(w2utils.lang(r),{position:a})),1==i&&s.w2tag(w2utils.lang(r),{position:a})},1)}},tooltipHide:function(e){if(null!=this.tooltip){var t=c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(e));this.get(e);t.removeProp("_mouse_over"),setTimeout(function(){!0!==t.prop("_mouse_over")&&!0===t.prop("_mouse_tooltip")&&(t.removeProp("_mouse_tooltip"),t.w2tag())},1)}},refresh:function(e){var t=(new Date).getTime();"up"==this.flow?c(this.box).addClass("w2ui-tabs-up"):c(this.box).removeClass("w2ui-tabs-up");var i=this.trigger({phase:"before",type:"refresh",target:null!=e?e:this.name,object:this.get(e)});if(!0!==i.isCancelled){if(null==e)for(var s=0;s<this.tabs.length;s++)this.refresh(this.tabs[s].id);else{var n=this.get(e);if(null==n)return!1;null==n.text&&null!=n.caption&&(n.text=n.caption),null==n.tooltip&&null!=n.hint&&(n.tooltip=n.hint),null!=n.caption&&console.log("NOTICE: tabs tab.caption property is deprecated, please use tab.text. Tab -> ",n),null!=n.hint&&console.log("NOTICE: tabs tab.hint property is deprecated, please use tab.tooltip. Tab -> ",n);var a=n.text;"function"==typeof a&&(a=a.call(this,n)),null==a&&(a="");var r=c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(n.id)),l="";n.closable&&!n.disabled&&(l='<div class="w2ui-tab-close"     onmouseover = "w2ui[\''+this.name+"'].tooltipShow('"+n.id+"', event);\"    onmouseout  = \"w2ui['"+this.name+"'].tooltipHide('"+n.id+"', event);\"    onclick=\"w2ui['"+this.name+"'].animateClose('"+n.id+"', event);\"></div>");var o=l+'    <div class="w2ui-tab'+(this.active===n.id?" active":"")+(n.closable?" closable":"")+(n.class?" "+n.class:"")+'" style="'+n.style+'"         onmouseover = "'+(n.disabled?"":"w2ui['"+this.name+"'].tooltipShow('"+n.id+"', event);")+'"        onmouseout  = "'+(n.disabled?"":"w2ui['"+this.name+"'].tooltipHide('"+n.id+"', event);")+'"        onclick="w2ui[\''+this.name+"'].click('"+n.id+"', event);\">"+w2utils.lang(a)+"</div>";if(0===r.length){var d="";n.hidden&&(d+="display: none;"),n.disabled&&(d+="opacity: 0.2;");var u='<td id="tabs_'+this.name+"_tab_"+n.id+'" style="'+d+'" valign="middle">'+o+"</td>";this.get(e,!0)!==this.tabs.length-1&&0<c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(this.tabs[parseInt(this.get(e,!0))+1].id)).length?c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(this.tabs[parseInt(this.get(e,!0))+1].id)).before(u):c(this.box).find("#tabs_"+this.name+"_right").before(u)}else r.html(o),n.hidden?r.css("display","none"):r.css("display",""),n.disabled?r.css({opacity:"0.2"}):r.css({opacity:"1"})}return c("#tabs_"+this.name+"_right").html(this.right),this.trigger(c.extend(i,{phase:"after"})),(new Date).getTime()-t}},render:function(e){var t=(new Date).getTime(),i=this.trigger({phase:"before",type:"render",target:this.name,box:e});if(!0!==i.isCancelled){if(null!=e&&(0<c(this.box).find("> table #tabs_"+this.name+"_right").length&&c(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-tabs").html(""),this.box=e),!this.box)return!1;var s='<div class="w2ui-scroll-wrapper" onmousedown="var el=w2ui[\''+this.name+'\']; if (el) el.resize();"><table cellspacing="0" cellpadding="1" width="100%"><tbody>    <tr><td width="100%" id="tabs_'+this.name+'_right" align="right">'+this.right+'</td></tr></tbody></table></div><div class="w2ui-scroll-left" onclick="var el=w2ui[\''+this.name+"']; if (el) el.scroll('left');\"></div><div class=\"w2ui-scroll-right\" onclick=\"var el=w2ui['"+this.name+"']; if (el) el.scroll('right');\"></div>";return c(this.box).attr("name",this.name).addClass("w2ui-reset w2ui-tabs").html(s),0<c(this.box).length&&(c(this.box)[0].style.cssText+=this.style),this.trigger(c.extend(i,{phase:"after"})),this.refresh(),this.resize(),(new Date).getTime()-t}},scroll:function(e){var t,i,s,n=c(this.box),a=this,r=n.find(".w2ui-scroll-wrapper"),l=r.scrollLeft();switch(e){case"left":t=r.outerWidth(),i=r.find(":first").outerWidth(),(s=l-t+50)<=0&&(s=0),r.animate({scrollLeft:s},300);break;case"right":t=r.outerWidth(),(i=r.find(":first").outerWidth())-t<=(s=l+t-50)&&(s=i-t),r.animate({scrollLeft:s},300)}setTimeout(function(){a.resize()},350)},resize:function(){var e=(new Date).getTime(),t=this.trigger({phase:"before",type:"resize",target:this.name});if(!0!==t.isCancelled){var i=c(this.box);i.find(".w2ui-scroll-left, .w2ui-scroll-right").hide();var s=i.find(".w2ui-scroll-wrapper");return s.find(":first").outerWidth()>s.outerWidth()&&(0<s.scrollLeft()&&i.find(".w2ui-scroll-left").show(),s.scrollLeft()<s.find(":first").outerWidth()-s.outerWidth()&&i.find(".w2ui-scroll-right").show()),this.trigger(c.extend(t,{phase:"after"})),(new Date).getTime()-e}},destroy:function(){var e=this.trigger({phase:"before",type:"destroy",target:this.name});!0!==e.isCancelled&&(0<c(this.box).find("> table #tabs_"+this.name+"_right").length&&c(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-tabs").html(""),delete w2ui[this.name],this.trigger(c.extend(e,{phase:"after"})))},click:function(e,t){var i=this.get(e);if(null==i||i.disabled)return!1;var s=this.trigger({phase:"before",type:"click",target:e,tab:i,object:i,originalEvent:t});if(!0!==s.isCancelled){if(c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(this.active)+" .w2ui-tab").removeClass("active"),this.active=i.id,"string"==typeof i.route){var n=""!==i.route?String("/"+i.route).replace(/\/{2,}/g,"/"):"",a=w2utils.parseRoute(n);if(0<a.keys.length)for(var r=0;r<a.keys.length;r++)null!=this.routeData[a.keys[r].name]&&(n=n.replace(new RegExp(":"+a.keys[r].name,"g"),this.routeData[a.keys[r].name]));setTimeout(function(){window.location.hash=n},1)}this.trigger(c.extend(s,{phase:"after"})),this.refresh(e)}},animateClose:function(e,t){var i=this.get(e);if(null==i||i.disabled)return!1;var s=this.trigger({phase:"before",type:"close",target:e,object:this.get(e),originalEvent:t});if(!0!==s.isCancelled){var n=this;c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(i.id)).css(w2utils.cssPrefix("transition",".2s")).css("opacity","0"),setTimeout(function(){var e=c(n.box).find("#tabs_"+n.name+"_tab_"+w2utils.escapeId(i.id)).width();c(n.box).find("#tabs_"+n.name+"_tab_"+w2utils.escapeId(i.id)).html('<div style="width: '+e+"px; "+w2utils.cssPrefix("transition",".2s",!0)+'"></div>'),setTimeout(function(){c(n.box).find("#tabs_"+n.name+"_tab_"+w2utils.escapeId(i.id)).find(":first-child").css({width:"0px"})},50)},200),setTimeout(function(){n.remove(e)},450),this.trigger(c.extend(s,{phase:"after"})),this.refresh()}},animateInsert:function(e,t){if(null!=this.get(e)&&(c.isPlainObject(t)&&w2utils.checkUniqueId(t.id,this.tabs,"tabs",this.name)&&0===c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(t.id)).length)){null==t.text&&null!=t.caption&&(t.text=t.caption);var i='<div id="_tmp_tabs" class="w2ui-reset w2ui-tabs" style="position: absolute; top: -1000px;"><table cellspacing="0" cellpadding="1" width="100%"><tbody><tr><td id="_tmp_simple_tab" style="" valign="middle">'+(t.closable?'<div class="w2ui-tab-close"></div>':"")+'    <div class="w2ui-tab '+(this.active===t.id?"active":"")+'">'+t.text+"</div></td></tr></tbody></table></div>";c("body").append(i);var s='<div style="width: 1px; '+w2utils.cssPrefix("transition",".2s",!0)+'">&#160;</div>',n="";t.hidden&&(n+="display: none;"),t.disabled&&(n+="opacity: 0.2;");var a='<td id="tabs_'+this.name+"_tab_"+t.id+'" style="'+n+'" valign="middle">'+s+"</td>";this.get(e,!0)!==this.tabs.length&&0<c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(this.tabs[parseInt(this.get(e,!0))].id)).length?c(this.box).find("#tabs_"+this.name+"_tab_"+w2utils.escapeId(this.tabs[parseInt(this.get(e,!0))].id)).before(a):c(this.box).find("#tabs_"+this.name+"_right").before(a);var r=this;setTimeout(function(){var e=c("#_tmp_simple_tab").width();c("#_tmp_tabs").remove(),c("#tabs_"+r.name+"_tab_"+w2utils.escapeId(t.id)+" > div").css("width",e+"px")},1),setTimeout(function(){r.insert(e,t)},200)}}},c.extend(a.prototype,w2utils.event),w2obj.tabs=a}(jQuery),function(f){function o(e){this.box=null,this.name=null,this.routeData={},this.items=[],this.right="",this.tooltip="top|left",f.extend(!0,this,w2obj.toolbar,e)}f.fn.w2toolbar=function(e){if(f.isPlainObject(e)){if(!w2utils.checkName(e,"w2toolbar"))return;var t=e.items||[],i=new o(e);f.extend(i,{items:[],handlers:[]});for(var s=0;s<t.length;s++)if(i.items[s]=f.extend({},o.prototype.item,t[s]),"menu-check"==i.items[s].type){var n=i.items[s];if(Array.isArray(n.selected)||(n.selected=[]),Array.isArray(n.items))for(var a=0;a<n.items.length;a++){(r=n.items[a]).checked&&-1==n.selected.indexOf(r.id)&&n.selected.push(r.id),r.checked||-1==n.selected.indexOf(r.id)||(r.checked=!0),null==r.checked&&(r.checked=!1)}}else if("menu-radio"==i.items[s].type){n=i.items[s];if(Array.isArray(n.items))for(a=0;a<n.items.length;a++){var r;(r=n.items[a]).checked&&null==n.selected?n.selected=r.id:r.checked=!1,r.checked||n.selected!=r.id||(r.checked=!0),null==r.checked&&(r.checked=!1)}}return 0!==f(this).length&&i.render(f(this)[0]),w2ui[i.name]=i}var l=w2ui[f(this).attr("name")];return l?0<arguments.length?(l[e]&&l[e].apply(l,Array.prototype.slice.call(arguments,1)),this):l:null},o.prototype={onClick:null,onRender:null,onRefresh:null,onResize:null,onDestroy:null,item:{id:null,type:"button",text:null,html:"",tooltip:null,count:null,hidden:!1,disabled:!1,checked:!1,img:null,icon:null,route:null,arrow:!0,style:null,group:null,items:null,selected:null,overlay:{},color:null,options:{advanced:!1,transparent:!0,html:""},onClick:null,onRefresh:null},add:function(e){this.insert(null,e)},insert:function(e,t){f.isArray(t)||(t=[t]);for(var i=0;i<t.length;i++){if(null==t[i].type)return void console.log('ERROR: The parameter "type" is required but not supplied in w2toolbar.add() method.');if(-1==f.inArray(String(t[i].type),["button","check","radio","drop","menu","menu-radio","menu-check","color","text-color","break","html","spacer"]))return void console.log('ERROR: The parameter "type" should be one of the following [button, check, radio, drop, menu, break, html, spacer] in w2toolbar.add() method.');if(null==t[i].id&&"break"!=t[i].type&&"spacer"!=t[i].type)return void console.log('ERROR: The parameter "id" is required but not supplied in w2toolbar.add() method.');if(!w2utils.checkUniqueId(t[i].id,this.items,"toolbar items",this.name))return;var s=f.extend({},o.prototype.item,t[i]);if(null==e)this.items.push(s);else{var n=this.get(e,!0);this.items=this.items.slice(0,n).concat([s],this.items.slice(n))}this.refresh(s.id),this.resize()}},remove:function(){for(var e=0,t=0;t<arguments.length;t++){var i=this.get(arguments[t]);if(i&&-1==String(arguments[t]).indexOf(":")){e++,f(this.box).find("#tb_"+this.name+"_item_"+w2utils.escapeId(i.id)).remove();var s=this.get(i.id,!0);null!=s&&this.items.splice(s,1)}}return this.resize(),e},set:function(e,t){var i=this.get(e);return null!=i&&(f.extend(i,t),this.refresh(String(e).split(":")[0]),!0)},get:function(e,t){if(0===arguments.length){for(var i=[],s=0;s<this.items.length;s++)null!=this.items[s].id&&i.push(this.items[s].id);return i}for(var n=String(e).split(":"),a=0;a<this.items.length;a++){var r=this.items[a];if(-1!=["menu","menu-radio","menu-check"].indexOf(r.type)&&2==n.length&&r.id==n[0])for(var l=0;l<r.items.length;l++){var o=r.items[l];if(o.id==n[1]||null==o.id&&o.text==n[1])return 1==t?l:o}else if(r.id==n[0])return 1==t?a:r}return null},show:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&(e++,n.hidden=!1,i.push(String(arguments[s]).split(":")[0]))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e]);t.resize()},15),e},hide:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&(e++,n.hidden=!0,i.push(String(arguments[s]).split(":")[0]))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e]),t.tooltipHide(i[e]);t.resize()},15),e},enable:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&(e++,n.disabled=!1,i.push(String(arguments[s]).split(":")[0]))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e])},15),e},disable:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&(e++,n.disabled=!0,i.push(String(arguments[s]).split(":")[0]))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e]),t.tooltipHide(i[e])},15),e},check:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&-1==String(arguments[s]).indexOf(":")&&(e++,n.checked=!0,i.push(String(arguments[s]).split(":")[0]))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e])},15),e},uncheck:function(){for(var t=this,e=0,i=[],s=0;s<arguments.length;s++){var n=this.get(arguments[s]);n&&-1==String(arguments[s]).indexOf(":")&&(-1!=["menu","menu-radio","menu-check","drop","color","text-color"].indexOf(n.type)&&n.checked&&setTimeout(function(){f("#tb_"+t.name+"_item_"+w2utils.escapeId(n.id)).w2overlay({name:t.name})},1),e++,n.checked=!1,i.push(String(arguments[s]).split(":")[0]))}return setTimeout(function(){for(var e=0;e<i.length;e++)t.refresh(i[e])},15),e},click:function(e,t){var n=this,i=String(e).split(":"),a=this.get(i[0]),r=a&&a.items?w2obj.field.prototype.normMenu.call(this,a.items,a):[];if(1<i.length){var s=this.get(e);s&&!s.disabled&&n.menuClick({name:n.name,item:a,subItem:s,originalEvent:t})}else if(a&&!a.disabled){var l=this.trigger({phase:"before",type:"click",target:null!=e?e:this.name,item:a,object:a,originalEvent:t});if(!0===l.isCancelled)return;var o="#tb_"+this.name+"_item_"+w2utils.escapeId(a.id)+" table.w2ui-button";if(f(o).removeClass("down"),"radio"==a.type){for(var d=0;d<this.items.length;d++){var u=this.items[d];null!=u&&u.id!=a.id&&"radio"===u.type&&u.group==a.group&&u.checked&&(u.checked=!1,this.refresh(u.id))}a.checked=!0,f(o).addClass("checked")}if(-1!=["menu","menu-radio","menu-check","drop","color","text-color"].indexOf(a.type)&&(n.tooltipHide(e),a.checked?setTimeout(function(){f("#tb_"+n.name+"_item_"+w2utils.escapeId(a.id)).w2overlay({name:n.name}),a.checked=!1,n.refresh(a.id)},1):setTimeout(function(){var e=f("#tb_"+n.name+"_item_"+w2utils.escapeId(a.id));f.isPlainObject(a.overlay)||(a.overlay={});var t=(e.width()-50)/2;if(19<t&&(t=19),"drop"==a.type&&e.w2overlay(a.html,f.extend({name:n.name,left:t,top:3},a.overlay,{onHide:function(e){s()}})),-1!=["menu","menu-radio","menu-check"].indexOf(a.type)){var i="normal";"menu-radio"==a.type&&(i="radio",r.forEach(function(e){a.selected==e.id?e.checked=!0:e.checked=!1})),"menu-check"==a.type&&(i="check",r.forEach(function(e){f.isArray(a.selected)&&-1!=a.selected.indexOf(e.id)?e.checked=!0:e.checked=!1})),e.w2menu(f.extend({name:n.name,items:r,left:t,top:3},a.overlay,{type:i,remove:function(e){n.menuClick({name:n.name,remove:!0,item:a,subItem:e.item,originalEvent:e.originalEvent,keepOpen:e.keepOpen})},select:function(e){n.menuClick({name:n.name,item:a,subItem:e.item,originalEvent:e.originalEvent,keepOpen:e.keepOpen})},onHide:function(e){s()}}))}function s(){a.checked=!1,f(o).removeClass("checked")}-1!=["color","text-color"].indexOf(a.type)&&f(e).w2color(f.extend({color:a.color,onHide:function(e){s(),n._tmpColor&&n.colorClick({name:n.name,item:a,color:n._tmpColor,final:!0}),delete n._tmpColor},onSelect:function(e){null!=e&&(n.colorClick({name:n.name,item:a,color:e}),n._tmpColor=e)}},a.options))},1)),-1!=["check","menu","menu-radio","menu-check","drop","color","text-color"].indexOf(a.type)&&(a.checked=!a.checked,a.checked?f(o).addClass("checked"):f(o).removeClass("checked")),a.route){var c=String("/"+a.route).replace(/\/{2,}/g,"/"),h=w2utils.parseRoute(c);if(0<h.keys.length)for(var p=0;p<h.keys.length;p++)c=c.replace(new RegExp(":"+h.keys[p].name,"g"),this.routeData[h.keys[p].name]);setTimeout(function(){window.location.hash=c},1)}t&&-1!=["button","check","radio"].indexOf(a.type)&&this.tooltipShow(e,t,!0),this.trigger(f.extend(l,{phase:"after"}))}},scroll:function(e){var t,i,s,n=f(this.box),a=this,r=n.find(".w2ui-scroll-wrapper"),l=r.scrollLeft();switch(e){case"left":t=r.outerWidth(),i=r.find(":first").outerWidth(),(s=l-t+50)<=0&&(s=0),r.animate({scrollLeft:s},300);break;case"right":t=r.outerWidth(),(i=r.find(":first").outerWidth())-t<=(s=l+t-50)&&(s=i-t),r.animate({scrollLeft:s},300)}setTimeout(function(){a.resize()},350)},render:function(e){var t=(new Date).getTime(),i=this.trigger({phase:"before",type:"render",target:this.name,box:e});if(!0!==i.isCancelled&&(null!=e&&(0<f(this.box).find("> table #tb_"+this.name+"_right").length&&f(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-toolbar").html(""),this.box=e),this.box)){for(var s='<div class="w2ui-scroll-wrapper" onmousedown="var el=w2ui[\''+this.name+'\']; if (el) el.resize();"><table cellspacing="0" cellpadding="0" width="100%"><tbody><tr>',n=0;n<this.items.length;n++){var a=this.items[n];null!=a&&(null==a.id&&(a.id="item_"+n),null!=a.caption&&console.log("NOTICE: toolbar item.caption property is deprecated, please use item.text. Item -> ",a),null!=a.hint&&console.log("NOTICE: toolbar item.hint property is deprecated, please use item.tooltip. Item -> ",a),"spacer"==a.type?s+='<td width="100%" id="tb_'+this.name+"_item_"+a.id+'" align="right"></td>':s+='<td id="tb_'+this.name+"_item_"+a.id+'" style="'+(a.hidden?"display: none":"")+'"     class="'+(a.disabled?"disabled":"")+'" valign="middle"></td>')}return s+='<td width="100%" id="tb_'+this.name+'_right" align="right">'+this.right+"</td>",s+='</tr></tbody></table></div><div class="w2ui-scroll-left" onclick="var el=w2ui[\''+this.name+"']; if (el) el.scroll('left');\"></div><div class=\"w2ui-scroll-right\" onclick=\"var el=w2ui['"+this.name+"']; if (el) el.scroll('right');\"></div>",f(this.box).attr("name",this.name).addClass("w2ui-reset w2ui-toolbar").html(s),0<f(this.box).length&&(f(this.box)[0].style.cssText+=this.style),this.refresh(),this.resize(),this.trigger(f.extend(i,{phase:"after"})),(new Date).getTime()-t}},refresh:function(e){var t=(new Date).getTime(),i=this.trigger({phase:"before",type:"refresh",target:null!=e?e:this.name,item:this.get(e)});if(!0!==i.isCancelled){if(null!=e){var s=this.get(e);if(null==s)return!1;if("function"==typeof s.onRefresh){var n=this.trigger({phase:"before",type:"refresh",target:e,item:s,object:s});if(!0===n.isCancelled)return}var a=f(this.box).find("#tb_"+this.name+"_item_"+w2utils.escapeId(s.id)),r=this.getItemHTML(s);return this.tooltipHide(e,{}),0===a.length?(r="spacer"==s.type?'<td width="100%" id="tb_'+this.name+"_item_"+s.id+'" align="right"></td>':'<td id="tb_'+this.name+"_item_"+s.id+'" style="'+(s.hidden?"display: none":"")+'"     class="'+(s.disabled?"disabled":"")+'" valign="middle">'+r+"</td>",this.get(e,!0)==this.items.length-1?f(this.box).find("#tb_"+this.name+"_right").before(r):f(this.box).find("#tb_"+this.name+"_item_"+w2utils.escapeId(this.items[parseInt(this.get(e,!0))+1].id)).before(r)):(-1!=["menu","menu-radio","menu-check","drop","color","text-color"].indexOf(s.type)&&0==s.checked&&0<f("#w2ui-overlay-"+this.name).length&&f("#w2ui-overlay-"+this.name)[0].hide(),a.html(r),s.hidden?a.css("display","none"):a.css("display",""),s.disabled?a.addClass("disabled"):a.removeClass("disabled")),"function"==typeof s.onRefresh&&this.trigger(f.extend(n,{phase:"after"})),this.trigger(f.extend(i,{phase:"after"})),(new Date).getTime()-t}for(var l=0;l<this.items.length;l++){var o=this.items[l];null==o.id&&(o.id="item_"+l),this.refresh(o.id)}}},resize:function(){var e=(new Date).getTime(),t=this.trigger({phase:"before",type:"resize",target:this.name});if(!0!==t.isCancelled){var i=f(this.box);i.find(".w2ui-scroll-left, .w2ui-scroll-right").hide();var s=i.find(".w2ui-scroll-wrapper");return s.find(":first").outerWidth()>s.outerWidth()&&(0<s.scrollLeft()&&i.find(".w2ui-scroll-left").show(),s.scrollLeft()<s.find(":first").outerWidth()-s.outerWidth()&&i.find(".w2ui-scroll-right").show()),this.trigger(f.extend(t,{phase:"after"})),(new Date).getTime()-e}},destroy:function(){var e=this.trigger({phase:"before",type:"destroy",target:this.name});!0!==e.isCancelled&&(0<f(this.box).find("> table #tb_"+this.name+"_right").length&&f(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-toolbar").html(""),f(this.box).html(""),delete w2ui[this.name],this.trigger(f.extend(e,{phase:"after"})))},getItemHTML:function(e){var t="";null!=e.caption&&null==e.text&&(e.text=e.caption),null==e.text&&(e.text=""),null==e.tooltip&&null!=e.hint&&(e.tooltip=e.hint),null==e.tooltip&&(e.tooltip=""),"function"!=typeof e.get&&Array.isArray(e.items)&&(e.get=function(t){return e.items.find(function(e){return e.id==t})});var i="<td>&#160;</td>",s="function"==typeof e.text?e.text.call(this,e):e.text;if(e.img&&(i='<td><div class="w2ui-tb-image w2ui-icon '+e.img+'"></div></td>'),e.icon&&(i='<td><div class="w2ui-tb-image"><span class="'+("function"==typeof e.icon?e.icon.call(this,e):e.icon)+'"></span></div></td>'),""===t)switch(e.type){case"color":case"text-color":"string"==typeof e.color&&("#"==e.color.substr(0,1)&&(e.color=e.color.substr(1)),3!=e.color.length&&6!=e.color.length||(e.color="#"+e.color)),"color"==e.type&&(s='<div style="height: 12px; width: 12px; margin-top: 1px; border: 1px solid #8A8A8A; border-radius: 1px; box-shadow: 0px 0px 1px #fff;         background-color: '+(null!=e.color?e.color:"#fff")+'; float: left;"></div>'+(e.text?'<div style="margin-left: 17px;">'+w2utils.lang(e.text)+"</div>":"")),"text-color"==e.type&&(s='<div style="color: '+(null!=e.color?e.color:"#444")+';">'+(e.text?w2utils.lang(e.text):"<b>Aa</b>")+"</div>");case"menu":case"menu-check":case"menu-radio":case"button":case"check":case"radio":case"drop":t+='<table cellpadding="0" cellspacing="0"        class="w2ui-button '+(e.checked?"checked":"")+'"        onclick     = "var el=w2ui[\''+this.name+"']; if (el) el.click('"+e.id+'\', event);"        onmouseenter = "'+(e.disabled?"":"jQuery(this).addClass('over'); w2ui['"+this.name+"'].tooltipShow('"+e.id+"', event);")+'"       onmouseleave = "'+(e.disabled?"":"jQuery(this).removeClass('over').removeClass('down'); w2ui['"+this.name+"'].tooltipHide('"+e.id+"', event);")+'"       onmousedown = "'+(e.disabled?"":"jQuery(this).addClass('down');")+'"       onmouseup   = "'+(e.disabled?"":"jQuery(this).removeClass('down');")+'"><tbody><tr><td>  <table cellpadding="1" cellspacing="0"><tbody>  <tr>'+i+(""!==s?'<td class="w2ui-tb-text w2ui-tb-caption" nowrap="nowrap" style="'+(e.style?e.style:"")+'">'+w2utils.lang(s)+"</td>":"")+(null!=e.count?'<td class="w2ui-tb-count" nowrap="nowrap"><span>'+e.count+"</span></td>":"")+(-1!=["menu","menu-radio","menu-check","drop","color","text-color"].indexOf(e.type)&&!1!==e.arrow?'<td class="w2ui-tb-down" nowrap="nowrap"><div></div></td>':"")+"  </tr></tbody></table></td></tr></tbody></table>";break;case"break":t+='<table cellpadding="0" cellspacing="0"><tbody><tr>    <td><div class="w2ui-break">&#160;</div></td></tr></tbody></table>';break;case"html":t+='<table cellpadding="0" cellspacing="0"><tbody><tr>    <td nowrap="nowrap">'+("function"==typeof e.html?e.html.call(this,e):e.html)+"</td></tr></tbody></table>"}return"<div>"+t+"</div>"},tooltipShow:function(e,t,i){if(null!=this.tooltip){var s=f(this.box).find("#tb_"+this.name+"_item_"+w2utils.escapeId(e)),n=this.get(e),a=this.tooltip,r=n.tooltip;"function"==typeof r&&(r=r.call(this,n)),clearTimeout(this._tooltipTimer),this._tooltipTimer=setTimeout(function(){if(!0!==s.prop("_mouse_tooltip")){if(s.prop("_mouse_tooltip",!0),-1!=["menu","menu-radio","menu-check","drop","color","text-color"].indexOf(n.type)&&1==n.checked)return;s.w2tag(w2utils.lang(r),{position:a})}},0),s.prop("_mouse_tooltip")&&1==i&&s.w2tag(w2utils.lang(r),{position:a})}},tooltipHide:function(e,t){if(null!=this.tooltip){var i=f(this.box).find("#tb_"+this.name+"_item_"+w2utils.escapeId(e));this.get(e);clearTimeout(this._tooltipTimer),setTimeout(function(){!0===i.prop("_mouse_tooltip")&&(i.removeProp("_mouse_tooltip"),i.w2tag())},1)}},menuClick:function(e){if(e.item&&!e.item.disabled){var t=this.trigger({phase:"before",type:!0!==e.remove?"click":"remove",target:e.item.id+":"+e.subItem.id,item:e.item,subItem:e.subItem,originalEvent:e.originalEvent});if(!0===t.isCancelled)return;var s=e.subItem,n=this.get(e.item.id),i=n.items;if("function"==typeof i&&(i=n.items()),"menu-radio"==n.type&&(n.selected=s.id,Array.isArray(i)&&i.forEach(function(e){!0===e.checked&&delete e.checked,Array.isArray(e.items)&&e.items.forEach(function(e){!0===e.checked&&delete e.checked})}),s.checked=!0),"menu-check"==n.type)if(f.isArray(n.selected)||(n.selected=[]),null==s.group){-1==(a=n.selected.indexOf(s.id))?(n.selected.push(s.id),s.checked=!0):(n.selected.splice(a,1),s.checked=!1)}else{var a,r=[];!function i(e){e.forEach(function(e){if(e.group===s.group){var t=n.selected.indexOf(e.id);-1!=t&&(e.id!=s.id&&r.push(e.id),n.selected.splice(t,1))}Array.isArray(e.items)&&i(e.items)})}(i),-1==(a=n.selected.indexOf(s.id))&&(n.selected.push(s.id),s.checked=!0)}if("string"==typeof s.route){var l=""!==s.route?String("/"+s.route).replace(/\/{2,}/g,"/"):"",o=w2utils.parseRoute(l);if(0<o.keys.length)for(var d=0;d<o.keys.length;d++)null!=this.routeData[o.keys[d].name]&&(l=l.replace(new RegExp(":"+o.keys[d].name,"g"),this.routeData[o.keys[d].name]));setTimeout(function(){window.location.hash=l},1)}this.refresh(e.item.id),this.trigger(f.extend(t,{phase:"after"}))}},colorClick:function(e){if(e.item&&!e.item.disabled){var t=this.trigger({phase:"before",type:"click",target:e.item.id,item:e.item,color:e.color,final:e.final,originalEvent:e.originalEvent});if(!0===t.isCancelled)return;e.item.color=e.color,this.refresh(e.item.id),this.trigger(f.extend(t,{phase:"after"}))}}},f.extend(o.prototype,w2utils.event),w2obj.toolbar=o}(jQuery),function(p){function d(e){this.name=null,this.box=null,this.sidebar=null,this.parent=null,this.nodes=[],this.menu=[],this.routeData={},this.selected=null,this.img=null,this.icon=null,this.style="",this.topHTML="",this.bottomHTML="",this.flatButton=!1,this.keyboard=!0,this.flat=!1,this.hasFocus=!1,p.extend(!0,this,w2obj.sidebar,e)}p.fn.w2sidebar=function(e){if(p.isPlainObject(e)){if(!w2utils.checkName(e,"w2sidebar"))return;var t=e.nodes,i=new d(e);return p.extend(i,{handlers:[],nodes:[]}),null!=t&&i.add(i,t),0!==p(this).length&&i.render(p(this)[0]),i.sidebar=i,w2ui[i.name]=i}var s=w2ui[p(this).attr("name")];return s?0<arguments.length?(s[e]&&s[e].apply(s,Array.prototype.slice.call(arguments,1)),this):s:null},d.prototype={onClick:null,onDblClick:null,onContextMenu:null,onMenuClick:null,onExpand:null,onCollapse:null,onKeydown:null,onRender:null,onRefresh:null,onResize:null,onDestroy:null,onFocus:null,onBlur:null,onFlat:null,node:{id:null,text:"",count:null,img:null,icon:null,nodes:[],style:"",route:null,selected:!1,expanded:!1,hidden:!1,disabled:!1,group:!1,groupShowHide:!0,collapsible:!1,plus:!1,onClick:null,onDblClick:null,onContextMenu:null,onExpand:null,onCollapse:null,parent:null,sidebar:null},add:function(e,t){return 1==arguments.length&&(t=e,e=this),"string"==typeof e&&(e=this.get(e)),this.insert(e,null,t)},insert:function(e,t,i){var s,n,a,r,l;if(2==arguments.length)if(i=t,null!=(t=e)){if(null==(n=this.get(t)))return p.isArray(i)||(i=[i]),null!=i[0].caption&&null==i[0].text&&(console.log("NOTICE: sidebar node.caption property is deprecated, please use node.text. Node -> ",i[0]),i[0].text=i[0].caption),s=i[0].text,console.log('ERROR: Cannot insert node "'+s+'" because cannot find node "'+t+'" to insert before.'),null;e=this.get(t).parent}else e=this;"string"==typeof e&&(e=this.get(e)),p.isArray(i)||(i=[i]);for(var o=0;o<i.length;o++)if(null!=typeof(r=i[o]).id)if(null==this.get(this,r.id)){if((a=p.extend({},d.prototype.node,r)).sidebar=this,a.parent=e,l=a.nodes||[],a.nodes=[],null==t)e.nodes.push(a);else{if(null==(n=this.get(e,t,!0)))return console.log('ERROR: Cannot insert node "'+r.text+'" because cannot find node "'+t+'" to insert before.'),null;e.nodes.splice(n,0,a)}0<l.length&&this.insert(a,null,l)}else console.log("ERROR: Cannot insert node with id="+r.id+" (text: "+r.text+") because another node with the same id already exists.");else null!=r.caption&&null==r.text&&(console.log("NOTICE: sidebar node.caption property is deprecated, please use node.text"),r.text=r.caption),s=r.text,console.log('ERROR: Cannot insert node "'+s+'" because it has no id.');return this.refresh(e.id),a},remove:function(){for(var e,t=0,i=0;i<arguments.length;i++)if(null!=(e=this.get(arguments[i]))){null!=this.selected&&this.selected===e.id&&(this.selected=null);var s=this.get(e.parent,arguments[i],!0);null!=s&&(e.parent.nodes[s].selected&&e.sidebar.unselect(e.id),e.parent.nodes.splice(s,1),t++)}return 0<t&&1==arguments.length?this.refresh(e.parent.id):this.refresh(),t},set:function(e,t,i){if(2==arguments.length&&(i=t,t=e,e=this),"string"==typeof e&&(e=this.get(e)),null==e.nodes)return null;for(var s=0;s<e.nodes.length;s++){if(e.nodes[s].id===t){var n=i.nodes;return p.extend(e.nodes[s],i,{nodes:[]}),null!=n&&this.add(e.nodes[s],n),this.refresh(t),!0}if(this.set(e.nodes[s],t,i))return!0}return!1},get:function(e,t,i){if(0===arguments.length){for(var s=[],n=this.find({}),a=0;a<n.length;a++)null!=n[a].id&&s.push(n[a].id);return s}if((1==arguments.length||2==arguments.length&&!0===t)&&(i=t,t=e,e=this),"string"==typeof e&&(e=this.get(e)),null==e.nodes)return null;for(var r=0;r<e.nodes.length;r++){if(e.nodes[r].id==t)return!0===i?r:e.nodes[r];var l=this.get(e.nodes[r],t,i);if(l||0===l)return l}return null},find:function(e,t,i){if(1==arguments.length&&(t=e,e=this),i=i||[],"string"==typeof e&&(e=this.get(e)),null==e.nodes)return i;for(var s=0;s<e.nodes.length;s++){var n=!0;for(var a in t)e.nodes[s][a]!=t[a]&&(n=!1);n&&i.push(e.nodes[s]),0<e.nodes[s].nodes.length&&(i=this.find(e.nodes[s],t,i))}return i},hide:function(){for(var e=0,t=0;t<arguments.length;t++){var i=this.get(arguments[t]);null!=i&&(i.hidden=!0,e++)}return 1==arguments.length?this.refresh(arguments[0]):this.refresh(),e},show:function(){for(var e=0,t=0;t<arguments.length;t++){var i=this.get(arguments[t]);null!=i&&(i.hidden=!1,e++)}return 1==arguments.length?this.refresh(arguments[0]):this.refresh(),e},disable:function(){for(var e=0,t=0;t<arguments.length;t++){var i=this.get(arguments[t]);null!=i&&(i.disabled=!0,i.selected&&this.unselect(i.id),e++)}return 1==arguments.length?this.refresh(arguments[0]):this.refresh(),e},enable:function(){for(var e=0,t=0;t<arguments.length;t++){var i=this.get(arguments[t]);null!=i&&(i.disabled=!1,e++)}return 1==arguments.length?this.refresh(arguments[0]):this.refresh(),e},select:function(e){var t=this.get(e);return!!t&&((this.selected!=e||!t.selected)&&(this.unselect(this.selected),p(this.box).find("#node_"+w2utils.escapeId(e)).addClass("w2ui-selected").find(".w2ui-icon").addClass("w2ui-icon-selected"),t.selected=!0,this.selected=e,!0))},unselect:function(e){0===arguments.length&&(e=this.selected);var t=this.get(e);return!!t&&(t.selected=!1,p(this.box).find("#node_"+w2utils.escapeId(e)).removeClass("w2ui-selected").find(".w2ui-icon").removeClass("w2ui-icon-selected"),this.selected==e&&(this.selected=null),!0)},toggle:function(e){var t=this.get(e);return null!=t&&(t.plus?(this.set(e,{plus:!1}),this.expand(e),void this.refresh(e)):0!==t.nodes.length&&(!!t.collapsible&&(this.get(e).expanded?this.collapse(e):this.expand(e))))},collapse:function(e){var t=this,i=this.get(e),s=this.trigger({phase:"before",type:"collapse",target:e,object:i});if(!0!==s.isCancelled)return p(this.box).find("#node_"+w2utils.escapeId(e)+"_sub").slideUp(200),p(this.box).find("#node_"+w2utils.escapeId(e)+" .w2ui-expanded").removeClass("w2ui-expanded").addClass("w2ui-collapsed"),i.expanded=!1,this.trigger(p.extend(s,{phase:"after"})),setTimeout(function(){t.refresh(e)},200),!0},collapseAll:function(e){if(null==e&&(e=this),"string"==typeof e&&(e=this.get(e)),null==e.nodes)return!1;for(var t=0;t<e.nodes.length;t++)!0===e.nodes[t].expanded&&(e.nodes[t].expanded=!1),e.nodes[t].nodes&&0<e.nodes[t].nodes.length&&this.collapseAll(e.nodes[t]);return this.refresh(e.id),!0},expand:function(e){var t=this,i=this.get(e),s=this.trigger({phase:"before",type:"expand",target:e,object:i});if(!0!==s.isCancelled)return p(this.box).find("#node_"+w2utils.escapeId(e)+"_sub").slideDown(200),p(this.box).find("#node_"+w2utils.escapeId(e)+" .w2ui-collapsed").removeClass("w2ui-collapsed").addClass("w2ui-expanded"),i.expanded=!0,this.trigger(p.extend(s,{phase:"after"})),setTimeout(function(){t.refresh(e)},200),!0},expandAll:function(e){if(null==e&&(e=this),"string"==typeof e&&(e=this.get(e)),null==e.nodes)return!1;for(var t=0;t<e.nodes.length;t++)!1===e.nodes[t].expanded&&(e.nodes[t].expanded=!0),e.nodes[t].nodes&&0<e.nodes[t].nodes.length&&this.expandAll(e.nodes[t]);this.refresh(e.id)},expandParents:function(e){var t=this.get(e);return null!=t&&(t.parent&&(t.parent.expanded||(t.parent.expanded=!0,this.refresh(t.parent.id)),this.expandParents(t.parent.id)),!0)},click:function(n,a){var r=this,l=this.get(n);if(null!=l&&!l.disabled&&!l.group){p(r.box).find(".w2ui-node.w2ui-selected").each(function(e,t){var i=p(t).attr("id").replace("node_",""),s=r.get(i);null!=s&&(s.selected=!1),p(t).removeClass("w2ui-selected").find(".w2ui-icon").removeClass("w2ui-icon-selected")});var o=p(r.box).find("#node_"+w2utils.escapeId(n)),d=p(r.box).find("#node_"+w2utils.escapeId(r.selected));o.addClass("w2ui-selected").find(".w2ui-icon").addClass("w2ui-icon-selected"),setTimeout(function(){var e=r.trigger({phase:"before",type:"click",target:n,originalEvent:a,node:l,object:l});if(!0===e.isCancelled)return o.removeClass("w2ui-selected").find(".w2ui-icon").removeClass("w2ui-icon-selected"),void d.addClass("w2ui-selected").find(".w2ui-icon").addClass("w2ui-icon-selected");if(null!=d&&(d.selected=!1),r.get(n).selected=!0,r.selected=n,"string"==typeof l.route){var t=""!==l.route?String("/"+l.route).replace(/\/{2,}/g,"/"):"",i=w2utils.parseRoute(t);if(0<i.keys.length)for(var s=0;s<i.keys.length;s++)null!=r.routeData[i.keys[s].name]&&(t=t.replace(new RegExp(":"+i.keys[s].name,"g"),r.routeData[i.keys[s].name]));setTimeout(function(){window.location.hash=t},1)}r.trigger(p.extend(e,{phase:"after"}))},1)}},focus:function(e){var t=this,i=this.trigger({phase:"before",type:"focus",target:this.name,originalEvent:e});if(!0===i.isCancelled)return!1;this.hasFocus=!0,p(this.box).find(".w2ui-sidebar-body").addClass("w2ui-focus"),setTimeout(function(){var e=p(t.box).find("#sidebar_"+t.name+"_focus");e.is(":focus")||e.focus()},10),this.trigger(p.extend(i,{phase:"after"}))},blur:function(e){var t=this.trigger({phase:"before",type:"blur",target:this.name,originalEvent:e});if(!0===t.isCancelled)return!1;this.hasFocus=!1,p(this.box).find(".w2ui-sidebar-body").removeClass("w2ui-focus"),this.trigger(p.extend(t,{phase:"after"}))},keydown:function(e){var l=this,t=l.get(l.selected);if(!0===l.keyboard){t=t||l.nodes[0];var i=l.trigger({phase:"before",type:"keydown",target:l.name,originalEvent:e});!0!==i.isCancelled&&(13!=e.keyCode&&32!=e.keyCode||0<t.nodes.length&&l.toggle(l.selected),37==e.keyCode&&(0<t.nodes.length&&t.expanded?l.collapse(l.selected):(s(t.parent),t.parent.group||l.collapse(t.parent.id))),39==e.keyCode&&(0<t.nodes.length||t.plus)&&!t.expanded&&l.expand(l.selected),38==e.keyCode&&(null==l.get(l.selected)?s(this.nodes[0]||null):s(n(t,a))),40==e.keyCode&&(null==l.get(l.selected)?s(this.nodes[0]||null):s(n(t,function e(t,i){if(null==t)return null;var s=t.parent;var n=l.get(t.id,!0);var a=null;if(t.expanded&&0<t.nodes.length&&!0!==i){var r=t.nodes[0];a=r.hidden||r.disabled||r.group?e(r):r}else a=s&&n+1<s.nodes.length?s.nodes[n+1]:e(s,!0);null!=a&&(a.hidden||a.disabled||a.group)&&(a=e(a));return a}))),-1!=p.inArray(e.keyCode,[13,32,37,38,39,40])&&(e.preventDefault&&e.preventDefault(),e.stopPropagation&&e.stopPropagation()),l.trigger(p.extend(i,{phase:"after"})))}function s(e,t){null==e||e.hidden||e.disabled||e.group||(l.click(e.id,t),setTimeout(function(){l.scrollIntoView()},50))}function n(e,t){for(e=t(e);null!=e&&(e.hidden||e.disabled)&&!e.group;)e=t(e);return e}function a(e){if(null==e)return null;var t=e.parent,i=l.get(e.id,!0),s=0<i?function e(t){if(t.expanded&&0<t.nodes.length){var i=t.nodes[t.nodes.length-1];return i.hidden||i.disabled||i.group?a(i):e(i)}return t}(t.nodes[i-1]):t;return null!=s&&(s.hidden||s.disabled||s.group)&&(s=a(s)),s}},scrollIntoView:function(e){if(null==e&&(e=this.selected),null!=this.get(e)){var t=p(this.box).find(".w2ui-sidebar-body"),i=p(this.box).find("#node_"+w2utils.escapeId(e)),s=i.offset().top-t.offset().top;(s+i.height()>t.height()||s<=0)&&t.animate({scrollTop:t.scrollTop()+s-t.height()/2+i.height()},250,"linear")}},dblClick:function(e,t){var i=this.get(e),s=this.trigger({phase:"before",type:"dblClick",target:e,originalEvent:t,object:i});!0!==s.isCancelled&&(this.toggle(e),this.trigger(p.extend(s,{phase:"after"})))},contextMenu:function(t,e){var i=this,s=i.get(t);t!=i.selected&&i.click(t);var n=i.trigger({phase:"before",type:"contextMenu",target:t,originalEvent:e,object:s,allowOnDisabled:!1});!0!==n.isCancelled&&(s.disabled&&!n.allowOnDisabled||(0<i.menu.length&&p(i.box).find("#node_"+w2utils.escapeId(t)).w2menu({items:i.menu,contextMenu:!0,originalEvent:e,onSelect:function(e){i.menuClick(t,parseInt(e.index),e.originalEvent)}}),e.preventDefault&&e.preventDefault(),i.trigger(p.extend(n,{phase:"after"}))))},menuClick:function(e,t,i){var s=this.trigger({phase:"before",type:"menuClick",target:e,originalEvent:i,menuIndex:t,menuItem:this.menu[t]});!0!==s.isCancelled&&this.trigger(p.extend(s,{phase:"after"}))},goFlat:function(){var e=this.trigger({phase:"before",type:"flat",goFlat:!this.flat});!0!==e.isCancelled&&(this.flat=!this.flat,this.refresh(),this.trigger(p.extend(e,{phase:"after"})))},render:function(e){var t=(new Date).getTime(),s=this,i=this.trigger({phase:"before",type:"render",target:this.name,box:e});if(!0!==i.isCancelled&&(null!=e&&(0<p(this.box).find("> div > div.w2ui-sidebar-body").length&&p(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-sidebar").html(""),this.box=e),this.box)){p(this.box).attr("name",this.name).addClass("w2ui-reset w2ui-sidebar").html('<div><input id="sidebar_'+this.name+'_focus" style="position: absolute; top: 0; right: 0; width: 1px; z-index: -1; opacity: 0" '+(w2utils.isIOS?"readonly":"")+'/><div class="w2ui-sidebar-top"></div><div class="w2ui-sidebar-body"></div><div class="w2ui-sidebar-bottom"></div></div>'),p(this.box).find("> div").css({width:p(this.box).width()+"px",height:p(this.box).height()+"px"}),0<p(this.box).length&&(p(this.box)[0].style.cssText+=this.style);var n,a="";return 1==this.flatButton&&(a='<div class="w2ui-flat-'+(this.flat?"right":"left")+'" onclick="w2ui[\''+this.name+"'].goFlat()\"></div>"),""===this.topHTML&&""===a||(p(this.box).find(".w2ui-sidebar-top").html(this.topHTML+a),p(this.box).find(".w2ui-sidebar-body").css("top",p(this.box).find(".w2ui-sidebar-top").height()+"px")),""!==this.bottomHTML&&(p(this.box).find(".w2ui-sidebar-bottom").html(this.bottomHTML),p(this.box).find(".w2ui-sidebar-body").css("bottom",p(this.box).find(".w2ui-sidebar-bottom").height()+"px")),p(this.box).find("#sidebar_"+this.name+"_focus").on("focus",function(e){clearTimeout(n),s.hasFocus||s.focus(e)}).on("blur",function(e){n=setTimeout(function(){s.hasFocus&&s.blur(e)},100)}).on("keydown",function(e){9!=e.keyCode&&w2ui[s.name].keydown.call(w2ui[s.name],e)}),p(this.box).off("mousedown").on("mousedown",function(i){setTimeout(function(){if(-1==["INPUT","TEXTAREA","SELECT"].indexOf(i.target.tagName.toUpperCase())){var e=p(s.box).find("#sidebar_"+s.name+"_focus");if(!e.is(":focus")){if(p(i.target).hasClass("w2ui-node")){var t=p(i.target).position().top+p(s.box).find(".w2ui-sidebar-top").height()+i.offsetY;e.css({top:t+"px",left:"0px"})}e.focus()}}},1)}),this.trigger(p.extend(i,{phase:"after"})),this.refresh(),(new Date).getTime()-t}},refresh:function(e){var t=(new Date).getTime(),i=this.trigger({phase:"before",type:"refresh",target:null!=e?e:this.name,fullRefresh:null==e});if(!0!==i.isCancelled){var s="";if(1==this.flatButton&&(s='<div class="w2ui-flat-'+(this.flat?"right":"left")+'" onclick="w2ui[\''+this.name+"'].goFlat()\"></div>"),""===this.topHTML&&""===s||(p(this.box).find(".w2ui-sidebar-top").html(this.topHTML+s),p(this.box).find(".w2ui-sidebar-body").css("top",p(this.box).find(".w2ui-sidebar-top").height()+"px")),""!==this.bottomHTML&&(p(this.box).find(".w2ui-sidebar-bottom").html(this.bottomHTML),p(this.box).find(".w2ui-sidebar-body").css("bottom",p(this.box).find(".w2ui-sidebar-bottom").height()+"px")),p(this.box).find("> div").removeClass("w2ui-sidebar-flat").addClass(this.flat?"w2ui-sidebar-flat":"").css({width:p(this.box).width()+"px",height:p(this.box).height()+"px"}),0<this.nodes.length&&null==this.nodes[0].parent){var n=this.nodes;this.nodes=[],this.add(this,n)}var a,r,l,o,d=this;if(null==e)a=this,l=".w2ui-sidebar-body";else{if(null==(a=this.get(e)))return;l="#node_"+w2utils.escapeId(a.id)+"_sub"}if(a!==this){n="#node_"+w2utils.escapeId(a.id);o=h(a),p(this.box).find(n).before('<div id="sidebar_'+this.name+'_tmp"></div>'),p(this.box).find(n).remove(),p(this.box).find(l).remove(),p("#sidebar_"+this.name+"_tmp").before(o),p("#sidebar_"+this.name+"_tmp").remove()}p(this.box).find(l).html("");for(var u=0;u<a.nodes.length;u++)if(o=h(r=a.nodes[u]),p(this.box).find(l).append(o),0!==r.nodes.length)this.refresh(r.id);else{var c=this.trigger({phase:"before",type:"refresh",target:r.id});if(!0===c.isCancelled)return;this.trigger(p.extend(c,{phase:"after"}))}return this.trigger(p.extend(i,{phase:"after"})),(new Date).getTime()-t}function h(e){var t="",i=e.img,s=e.icon;null==s&&null==i&&(null==s&&(s=d.icon),null==i&&(i=d.img));for(var n=e.parent,a=0;n&&null!=n.parent;)n=n.parent,a++;if(null!=e.caption&&null==e.text&&(e.text=e.caption),null!=e.caption&&(console.log("NOTICE: sidebar node.caption property is deprecated, please use node.text. Node -> ",e),e.text=e.caption),Array.isArray(e.nodes)&&0<e.nodes.length&&(e.collapsible=!0),e.group)t='<div class="w2ui-node-group w2ui-level-'+a+(e.class?" "+e.class:"")+'" id="node_'+e.id+'"   style="'+(e.hidden?"display: none":"")+'" onclick="w2ui[\''+d.name+"'].toggle('"+e.id+"')\"   oncontextmenu=\"w2ui['"+d.name+"'].contextMenu('"+e.id+"', event);\"   onmouseout=\"jQuery(this).find('span:nth-child(1)').css('color', 'transparent')\"    onmouseover=\"jQuery(this).find('span:nth-child(1)').css('color', 'inherit')\">"+(e.groupShowHide&&e.collapsible?"<span>"+(!e.hidden&&e.expanded?w2utils.lang("Hide"):w2utils.lang("Show"))+"</span>":"<span></span>")+("function"==typeof e.text?e.text.call(d,e):"<span>"+e.text+"</span>")+'</div><div class="w2ui-node-sub" id="node_'+e.id+'_sub" style="'+e.style+";"+(!e.hidden&&e.expanded?"":"display: none;")+'"></div>',d.flat&&(t='<div class="w2ui-node-group" id="node_'+e.id+'"><span>&#160;</span></div><div id="node_'+e.id+'_sub" style="'+e.style+";"+(!e.hidden&&e.expanded?"":"display: none;")+'"></div>');else{e.selected&&!e.disabled&&(d.selected=e.id),n="",i&&(n='<div class="w2ui-node-image w2ui-icon '+i+(e.selected&&!e.disabled?" w2ui-icon-selected":"")+'"></div>'),s&&(n='<div class="w2ui-node-image"><span class="'+("function"==typeof s?s.call(d,e):s)+'"></span></div>');var r=e.text,l=null!=e.count?'<div class="w2ui-node-count">'+e.count+"</div>":"";!0===e.collapsible&&(l='<div class="w2ui-'+(e.expanded?"expanded":"collapsed")+'"><span></span></div>'),console.log(e,l),"function"==typeof e.text&&(r=e.text.call(d,e)),t='<div class="w2ui-node w2ui-level-'+a+(e.selected?" w2ui-selected":"")+(e.disabled?" w2ui-disabled":"")+(e.class?" "+e.class:"")+'" id="node_'+e.id+'" style="'+(e.hidden?"display: none;":"")+'"    ondblclick="w2ui[\''+d.name+"'].dblClick('"+e.id+"', event);\"    oncontextmenu=\"w2ui['"+d.name+"'].contextMenu('"+e.id+"', event);\"    onClick=\"w2ui['"+d.name+"'].click('"+e.id+'\', event); ">   <div class="w2ui-node-data" style="margin-left:'+12*a+'px">'+n+l+'<div class="w2ui-node-text w2ui-node-caption">'+r+'</div>   </div></div><div class="w2ui-node-sub" id="node_'+e.id+'_sub" style="'+e.style+";"+(!e.hidden&&e.expanded?"":"display: none;")+'"></div>',d.flat&&(t='<div class="w2ui-node w2ui-level-'+a+" "+(e.selected?"w2ui-selected":"")+" "+(e.disabled?"w2ui-disabled":"")+(e.class?" "+e.class:"")+'" id="node_'+e.id+'" style="'+(e.hidden?"display: none;":"")+"\"    onmouseover=\"jQuery(this).find('.w2ui-node-data').w2tag(w2utils.base64decode('"+w2utils.base64encode(r+(e.count||0===e.count?' - <span class="w2ui-node-count">'+e.count+"</span>":""))+"'),                { id: '"+e.id+"', left: -5 })\"    onmouseout=\"jQuery(this).find('.w2ui-node-data').w2tag(null, { id: '"+e.id+"' })\"    ondblclick=\"w2ui['"+d.name+"'].dblClick('"+e.id+"', event);\"    oncontextmenu=\"w2ui['"+d.name+"'].contextMenu('"+e.id+"', event);\"    onClick=\"w2ui['"+d.name+"'].click('"+e.id+'\', event); "><div class="w2ui-node-data w2ui-node-flat">'+n+'</div></div><div class="w2ui-node-sub" id="node_'+e.id+'_sub" style="'+e.style+";"+(!e.hidden&&e.expanded?"":"display: none;")+'"></div>')}return t}},resize:function(){var e=(new Date).getTime(),t=this.trigger({phase:"before",type:"resize",target:this.name});if(!0!==t.isCancelled)return p(this.box).css("overflow","hidden"),p(this.box).find("> div").css({width:p(this.box).width()+"px",height:p(this.box).height()+"px"}),this.trigger(p.extend(t,{phase:"after"})),(new Date).getTime()-e},destroy:function(){var e=this.trigger({phase:"before",type:"destroy",target:this.name});!0!==e.isCancelled&&(0<p(this.box).find("> div > div.w2ui-sidebar-body").length&&p(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-sidebar").html(""),delete w2ui[this.name],this.trigger(p.extend(e,{phase:"after"})))},lock:function(e,t){var i=Array.prototype.slice.call(arguments,0);i.unshift(this.box),w2utils.lock.apply(window,i)},unlock:function(e){w2utils.unlock(this.box,e)}},p.extend(d.prototype,w2utils.event),w2obj.sidebar=d}(jQuery),function(b){function n(e){this.el=null,this.helpers={},this.type=e.type||"text",this.options=b.extend(!0,{},e),this.onSearch=e.onSearch||null,this.onRequest=e.onRequest||null,this.onLoad=e.onLoad||null,this.onError=e.onError||null,this.onClick=e.onClick||null,this.onAdd=e.onAdd||null,this.onNew=e.onNew||null,this.onRemove=e.onRemove||null,this.onMouseOver=e.onMouseOver||null,this.onMouseOut=e.onMouseOut||null,this.onIconClick=e.onIconClick||null,this.onScroll=e.onScroll||null,this.tmp={},delete this.options.type,delete this.options.onSearch,delete this.options.onRequest,delete this.options.onLoad,delete this.options.onError,delete this.options.onClick,delete this.options.onMouseOver,delete this.options.onMouseOut,delete this.options.onIconClick,delete this.options.onScroll,b.extend(!0,this,w2obj.field)}b.fn.w2field=function(s,e){if(0!==this.length)return 0===arguments.length?b(this).data("w2field"):("string"==typeof s&&"object"==typeof e&&(s=b.extend(!0,{},e,{type:s})),"string"==typeof s&&null==e&&(s={type:s}),s&&(s.type=String(s.type).toLowerCase()),this.each(function(e,t){var i=b(t).data("w2field");return null==i?(i=new n(s),b.extend(i,{handlers:[]}),t&&(i.el=b(t)[0]),i.init(),b(t).data("w2field",i),i):(i.clear(),"clear"!==s.type?(i=new n(s),b.extend(i,{handlers:[]}),t&&(i.el=b(t)[0]),i.init(),b(t).data("w2field",i),i):void 0)}));var t=n.prototype;return t[s]?t[s].apply(t,Array.prototype.slice.call(arguments,1)):void 0},n.prototype={custom:{},addType:function(e,t){return e=String(e).toLowerCase(),this.custom[e]=t,!0},removeType:function(e){return e=String(e).toLowerCase(),!!this.custom[e]&&(delete this.custom[e],!0)},init:function(){var e,t=this,i=this.options;if("function"!=typeof this.custom[this.type])if(-1!=["INPUT","TEXTAREA"].indexOf(this.el.tagName.toUpperCase())){switch(this.type){case"text":case"int":case"float":case"money":case"currency":case"percent":case"alphanumeric":case"bin":case"hex":e={min:null,max:null,step:1,autoFormat:!0,currencyPrefix:w2utils.settings.currencyPrefix,currencySuffix:w2utils.settings.currencySuffix,currencyPrecision:w2utils.settings.currencyPrecision,decimalSymbol:w2utils.settings.decimalSymbol,groupSymbol:w2utils.settings.groupSymbol,arrows:!1,keyboard:!0,precision:null,silent:!0,prefix:"",suffix:""},this.options=b.extend(!0,{},e,i),(i=this.options).numberRE=new RegExp("["+i.groupSymbol+"]","g"),i.moneyRE=new RegExp("["+i.currencyPrefix+i.currencySuffix+i.groupSymbol+"]","g"),i.percentRE=new RegExp("["+i.groupSymbol+"%]","g"),-1!==["text","alphanumeric","hex","bin"].indexOf(this.type)&&(i.arrows=!1,i.keyboard=!1),this.addPrefix(),this.addSuffix();break;case"color":e={prefix:"",suffix:'<div style="width: '+(parseInt(b(this.el).css("font-size"))||12)+'px">&#160;</div>',arrows:!1,keyboard:!1,advanced:null,transparent:!0},b.extend(i,e),this.addPrefix(),this.addSuffix(),""!==b(this.el).val()&&setTimeout(function(){t.change()},1);break;case"date":e={format:w2utils.settings.dateFormat,keyboard:!0,silent:!0,start:"",end:"",blocked:{},colored:{},blockWeekDays:null},this.options=b.extend(!0,{},e,i),i=this.options,null==b(this.el).attr("placeholder")&&b(this.el).attr("placeholder",i.format);break;case"time":e={format:w2utils.settings.timeFormat,keyboard:!0,silent:!0,start:"",end:"",noMinutes:!1},this.options=b.extend(!0,{},e,i),i=this.options,null==b(this.el).attr("placeholder")&&b(this.el).attr("placeholder",i.format);break;case"datetime":e={format:w2utils.settings.dateFormat+" | "+w2utils.settings.timeFormat,keyboard:!0,silent:!0,start:"",end:"",blocked:[],colored:{},placeholder:null,btn_now:!0,noMinutes:!1},this.options=b.extend(!0,{},e,i),i=this.options,null==b(this.el).attr("placeholder")&&b(this.el).attr("placeholder",i.placeholder||i.format);break;case"list":case"combo":if(e={items:[],selected:{},url:null,recId:null,recText:null,method:null,interval:350,postData:{},minLength:1,cacheMax:250,maxDropHeight:350,maxDropWidth:null,match:"begins",silent:!0,icon:null,iconStyle:"",align:"both",altRows:!0,onSearch:null,onRequest:null,onLoad:null,onError:null,onIconClick:null,renderDrop:null,compare:null,filter:!0,prefix:"",suffix:"",openOnFocus:!1,markSearch:!1},"function"==typeof i.items&&(i._items_fun=i.items),i.items=w2obj.field.prototype.normMenu.call(this,i.items),"list"===this.type){if(e.openOnFocus=!0,b(this.el).addClass("w2ui-select"),!b.isPlainObject(i.selected)&&Array.isArray(i.items))for(var s=0;s<i.items.length;s++){var n=i.items[s];if(n&&n.id===i.selected){i.selected=b.extend(!0,{},n);break}}this.watchSize()}i=b.extend({},e,i),this.options=i,b.isPlainObject(i.selected)||(i.selected={}),b(this.el).data("selected",i.selected),i.url&&(i.items=[],this.request(0)),"list"===this.type&&this.addFocus(),this.addPrefix(),this.addSuffix(),setTimeout(function(){t.refresh()},10),b(this.el).attr("autocomplete","off"),null!=i.selected.text&&b(this.el).val(i.selected.text);break;case"enum":e={items:[],selected:[],max:0,url:null,recId:null,recText:null,interval:350,method:null,postData:{},minLength:1,cacheMax:250,maxWidth:250,maxHeight:350,maxDropHeight:350,maxDropWidth:null,match:"contains",silent:!0,align:"both",altRows:!0,openOnFocus:!1,markSearch:!0,renderDrop:null,renderItem:null,compare:null,filter:!0,style:"",onSearch:null,onRequest:null,onLoad:null,onError:null,onClick:null,onAdd:null,onNew:null,onRemove:null,onMouseOver:null,onMouseOut:null,onScroll:null},"function"==typeof(i=b.extend({},e,i,{suffix:""})).items&&(i._items_fun=i.items),i.items=w2obj.field.prototype.normMenu.call(this,i.items),i.selected=w2obj.field.prototype.normMenu.call(this,i.selected),this.options=i,b.isArray(i.selected)||(i.selected=[]),b(this.el).data("selected",i.selected),i.url&&(i.items=[],this.request(0)),this.addSuffix(),this.addMulti(),this.watchSize();break;case"file":e={selected:[],max:0,maxSize:0,maxFileSize:0,maxWidth:250,maxHeight:350,maxDropHeight:350,maxDropWidth:null,readContent:!0,silent:!0,align:"both",altRows:!0,renderItem:null,style:"",onClick:null,onAdd:null,onRemove:null,onMouseOver:null,onMouseOut:null},i=b.extend({},e,i),this.options=i,b.isArray(i.selected)||(i.selected=[]),b(this.el).data("selected",i.selected),null==b(this.el).attr("placeholder")&&b(this.el).attr("placeholder",w2utils.lang("Attach files by dragging and dropping or Click to Select")),this.addMulti(),this.watchSize()}this.tmp={onChange:function(e){t.change.call(t,e)},onClick:function(e){t.click.call(t,e)},onFocus:function(e){t.focus.call(t,e)},onBlur:function(e){t.blur.call(t,e)},onKeydown:function(e){t.keyDown.call(t,e)},onKeyup:function(e){t.keyUp.call(t,e)},onKeypress:function(e){t.keyPress.call(t,e)}},b(this.el).addClass("w2field w2ui-input").data("w2field",this).on("change.w2field",this.tmp.onChange).on("click.w2field",this.tmp.onClick).on("focus.w2field",this.tmp.onFocus).on("blur.w2field",this.tmp.onBlur).on("keydown.w2field",this.tmp.onKeydown).on("keyup.w2field",this.tmp.onKeyup).on("keypress.w2field",this.tmp.onKeypress).css(w2utils.cssPrefix("box-sizing","border-box")),this.change(b.Event("change"))}else console.log("ERROR: w2field could only be applied to INPUT or TEXTAREA.",this.el);else this.custom[this.type].call(this,i)},watchSize:function(){var e=this,t=b(e.el).data("tmp")||{};t.sizeTimer=setInterval(function(){0<b(e.el).parents("body").length?e.resize():clearInterval(t.sizeTimer)},200),b(e.el).data("tmp",t)},get:function(){return-1!==["list","enum","file"].indexOf(this.type)?b(this.el).data("selected"):b(this.el).val()},set:function(e,t){if(-1!==["list","enum","file"].indexOf(this.type)){if("list"!==this.type&&t)null==b(this.el).data("selected")&&b(this.el).data("selected",[]),b(this.el).data("selected").push(e),b(this.el).change();else{var i="enum"===this.type?[e]:e;b(this.el).data("selected",i).change()}this.refresh()}else b(this.el).val(e)},setIndex:function(e,t){if(-1!==["list","enum"].indexOf(this.type)){var i=this.options.items;if(i&&i[e]){if("list"!==this.type&&t)null==b(this.el).data("selected")&&b(this.el).data("selected",[]),b(this.el).data("selected").push(i[e]),b(this.el).change();else{var s="enum"===this.type?[i[e]]:i[e];b(this.el).data("selected",s).change()}return this.refresh(),!0}}return!1},clear:function(){var e=this.options;-1!==["money","currency"].indexOf(this.type)&&b(this.el).val(b(this.el).val().replace(e.moneyRE,"")),"percent"===this.type&&b(this.el).val(b(this.el).val().replace(/%/g,"")),"list"===this.type&&b(this.el).removeClass("w2ui-select"),this.type="clear";var t=b(this.el).data("tmp");if(this.tmp){for(var i in null!=t&&(b(this.el).height("auto"),t&&t["old-padding-left"]&&b(this.el).css("padding-left",t["old-padding-left"]),t&&t["old-padding-right"]&&b(this.el).css("padding-right",t["old-padding-right"]),t&&t["old-background-color"]&&b(this.el).css("background-color",t["old-background-color"]),t&&t["old-border-color"]&&b(this.el).css("border-color",t["old-border-color"]),clearInterval(t.sizeTimer)),b(this.el).val(this.clean(b(this.el).val())).removeClass("w2field").removeData().off(".w2field"),this.helpers)b(this.helpers[i]).remove();this.helpers={}}},refresh:function(){var l=this,i=this.options,o=b(this.el).data("selected"),e=(new Date).getTime();if(-1!==["list"].indexOf(this.type)&&(b(l.el).parent().css("white-space","nowrap"),l.helpers.prefix&&l.helpers.prefix.hide(),setTimeout(function(){if(l.helpers.focus){!b.isEmptyObject(o)&&i.icon?i.prefix='<span class="w2ui-icon '+i.icon+'"style="cursor: pointer; font-size: 14px; display: inline-block; margin-top: -1px; color: #7F98AD;'+i.iconStyle+'"></span>':i.prefix="",l.addPrefix();var t=l.helpers.focus.find("input");""===b(t).val()?(b(t).css("text-indent","-9999em").prev().css("opacity",0),b(l.el).val(o&&null!=o.text?w2utils.lang(o.text):"")):(b(t).css("text-indent",0).prev().css("opacity",1),b(l.el).val(""),setTimeout(function(){l.helpers.prefix&&l.helpers.prefix.hide();var e="position: absolute; opacity: 0; margin: 4px 0px 0px 2px; background-position: left !important;";i.icon?(b(t).css("margin-left","17px"),b(l.helpers.focus).find(".icon-search").attr("style",e+"width: 11px !important; opacity: 1; display: block")):(b(t).css("margin-left","0px"),b(l.helpers.focus).find(".icon-search").attr("style",e+"width: 0px !important; opacity: 0; display: none"))},1)),b(l.el).prop("readonly")||b(l.el).prop("disabled")?setTimeout(function(){b(l.helpers.prefix).css("opacity","0.6"),b(l.helpers.suffix).css("opacity","0.6")},1):setTimeout(function(){b(l.helpers.prefix).css("opacity","1"),b(l.helpers.suffix).css("opacity","1")},1)}},1)),-1!==["enum","file"].indexOf(this.type)){var t="";if(o)for(var s=0;s<o.length;s++){var n=o[s],a="";a="function"==typeof i.renderItem?i.renderItem(n,s,'<div class="w2ui-list-remove" title="'+w2utils.lang("Remove")+'" index="'+s+'">&#160;&#160;</div>'):'<div class="w2ui-list-remove" title="'+w2utils.lang("Remove")+'" index="'+s+'">&#160;&#160;</div>'+("enum"===l.type?n.text:n.name+'<span class="file-size"> - '+w2utils.formatSize(n.size)+"</span>"),t+='<li index="'+s+'" style="max-width: '+parseInt(i.maxWidth)+"px; "+(n.style?n.style:"")+'">'+a+"</li>"}var r=l.helpers.multi,d=r.find("ul");if(r.attr("style",r.attr("style")+";"+i.style),b(l.el).css("z-index","-1"),b(l.el).prop("readonly")||b(l.el).prop("disabled")?setTimeout(function(){r[0].scrollTop=0,r.addClass("w2ui-readonly").find("li").css("opacity","0.9").parent().find("li.nomouse").hide().find("input").prop("readonly",!0).parents("ul").find(".w2ui-list-remove").hide()},1):setTimeout(function(){r.removeClass("w2ui-readonly").find("li").css("opacity","1").parent().find("li.nomouse").show().find("input").prop("readonly",!1).parents("ul").find(".w2ui-list-remove").show()},1),r.find(".w2ui-enum-placeholder").remove(),d.find("li").not("li.nomouse").remove(),""!==t)d.prepend(t);else if(null!=b(l.el).attr("placeholder")&&""===r.find("input").val()){var u="padding-top: "+b(this.el).css("padding-top")+";padding-left: "+b(this.el).css("padding-left")+"; box-sizing: "+b(this.el).css("box-sizing")+"; line-height: "+b(this.el).css("line-height")+"; font-size: "+b(this.el).css("font-size")+"; font-family: "+b(this.el).css("font-family")+"; ";r.prepend('<div class="w2ui-enum-placeholder" style="'+u+'">'+b(l.el).attr("placeholder")+"</div>")}r.off("scroll.w2field").on("scroll.w2field",function(e){var t=l.trigger({phase:"before",type:"scroll",target:l.el,originalEvent:e});!0!==t.isCancelled&&l.trigger(b.extend(t,{phase:"after"}))}).find("li").data("mouse","out").on("click",function(e){var t="LI"===e.target.tagName.toUpperCase()?e.target:b(e.target).parents("LI"),i=o[b(t).attr("index")];if(!b(t).hasClass("nomouse"))if(e.stopPropagation(),b(e.target).hasClass("w2ui-list-remove")){if(b(l.el).prop("readonly")||b(l.el).prop("disabled"))return;if(!0===(s=l.trigger({phase:"before",type:"remove",target:l.el,originalEvent:e.originalEvent,item:i})).isCancelled)return;b().w2overlay(),o.splice(b(e.target).attr("index"),1),b(l.el).trigger("input").trigger("change"),b(e.target).parent().fadeOut("fast"),setTimeout(function(){l.refresh(),l.trigger(b.extend(s,{phase:"after"}))},300)}else{var s;if(!0===(s=l.trigger({phase:"before",type:"click",target:l.el,originalEvent:e.originalEvent,item:i})).isCancelled)return;if("file"===l.type){var n="";/image/i.test(i.type)&&(n='<div style="padding: 3px;">    <img src="'+(i.content?"data:"+i.type+";base64,"+i.content:"")+'" style="max-width: 300px;"         onload="var w = jQuery(this).width(); var h = jQuery(this).height();             if (w < 300 & h < 300) return;             if (w >= h && w > 300) jQuery(this).width(300);            if (w < h && h > 300) jQuery(this).height(300);"        onerror="this.style.display = \'none\'"    ></div>');var a='style="padding: 3px; text-align: right; color: #777;"',r='style="padding: 3px"';n+='<div style="padding: 8px;">    <table cellpadding="2"><tbody>    <tr><td '+a+">"+w2utils.lang("Name")+":</td><td "+r+">"+i.name+"</td></tr>    <tr><td "+a+">"+w2utils.lang("Size")+":</td><td "+r+">"+w2utils.formatSize(i.size)+"</td></tr>    <tr><td "+a+">"+w2utils.lang("Type")+":</td><td "+r+'>        <span style="width: 200px; display: block-inline; overflow: hidden; text-overflow: ellipsis; white-space: nowrap="nowrap";">'+i.type+"</span>    </td></tr>    <tr><td "+a+">"+w2utils.lang("Modified")+":</td><td "+r+">"+w2utils.date(i.modified)+"</td></tr>    </tbody></table></div>",b("#w2ui-overlay").remove(),b(t).w2overlay(n)}l.trigger(b.extend(s,{phase:"after"}))}}).on("mouseover",function(e){var t="LI"===e.target.tagName.toUpperCase()?e.target:b(e.target).parents("LI");if(!b(t).hasClass("nomouse")){if("out"===b(t).data("mouse")){var i=o[b(e.target).attr("index")],s=l.trigger({phase:"before",type:"mouseOver",target:l.el,originalEvent:e.originalEvent,item:i});if(!0===s.isCancelled)return;l.trigger(b.extend(s,{phase:"after"}))}b(t).data("mouse","over")}}).on("mouseout",function(i){var s="LI"===i.target.tagName.toUpperCase()?i.target:b(i.target).parents("LI");b(s).hasClass("nomouse")||(b(s).data("mouse","leaving"),setTimeout(function(){if("leaving"===b(s).data("mouse")){b(s).data("mouse","out");var e=o[b(i.target).attr("index")],t=l.trigger({phase:"before",type:"mouseOut",target:l.el,originalEvent:i.originalEvent,item:e});if(!0===t.isCancelled)return;l.trigger(b.extend(t,{phase:"after"}))}},0))}),b(this.el).height("auto");var c=b(r).find("> div.w2ui-multi-items").height()+2*w2utils.getSize(r,"+height");c<26&&(c=26),c>i.maxHeight&&(c=i.maxHeight),0<r.length&&(r[0].scrollTop=1e3);var h=w2utils.getSize(b(this.el),"height")-2;if(c<h&&(c=h),b(r).css({height:c+"px",overflow:c==i.maxHeight?"auto":"hidden"}),c<i.maxHeight&&b(r).prop("scrollTop",0),b(this.el).css({height:c+0+"px"}),"enum"===l.type){var p=l.helpers.multi.find("input");p.width(8*(p.val().length+2)+"px")}}return(new Date).getTime()-e},reset:function(){var e=this.type;this.clear(),this.type=e,this.init()},resize:function(){var e=this,t=b(e.el).width(),i=b(e.el).height();if(!(e.tmp.current_width==t&&0<i)){var s=this.helpers.focus,n=this.helpers.multi,a=this.helpers.suffix,r=this.helpers.prefix;if(s&&s.width(b(e.el).width()),n){var l=w2utils.getSize(e.el,"width")-parseInt(b(e.el).css("margin-left"),10)-parseInt(b(e.el).css("margin-right"),10);b(n).width(l)}a&&(e.options.suffix='<div class="arrow-down" style="margin-top: '+(parseInt(b(e.el).height())-6)/2+'px;"></div>',e.addSuffix()),r&&e.addPrefix(),e.tmp.current_width=t}},clean:function(e){if("number"==typeof e)return e;var t=this.options;return e=String(e).trim(),-1!==["int","float","money","currency","percent"].indexOf(this.type)&&("string"==typeof e&&(t.autoFormat&&-1!==["money","currency"].indexOf(this.type)&&(e=String(e).replace(t.moneyRE,"")),t.autoFormat&&"percent"===this.type&&(e=String(e).replace(t.percentRE,"")),t.autoFormat&&-1!==["int","float"].indexOf(this.type)&&(e=String(e).replace(t.numberRE,"")),e=e.replace(/\s+/g,"").replace(w2utils.settings.groupSymbol,"").replace(w2utils.settings.decimalSymbol,".")),parseFloat(e)==e&&(null!=t.min&&e<t.min&&(e=t.min,b(this.el).val(t.min)),null!=t.max&&e>t.max&&(e=t.max,b(this.el).val(t.max))),e=""!==e&&w2utils.isFloat(e)?Number(e):""),e},format:function(e){var t=this.options;if(t.autoFormat&&""!==e)switch(this.type){case"money":case"currency":""!==(e=w2utils.formatNumber(e,t.currencyPrecision,t.groupSymbol))&&(e=t.currencyPrefix+e+t.currencySuffix);break;case"percent":""!==(e=w2utils.formatNumber(e,t.precision,t.groupSymbol))&&(e+="%");break;case"float":e=w2utils.formatNumber(e,t.precision,t.groupSymbol);break;case"int":e=w2utils.formatNumber(e,0,t.groupSymbol)}return e},change:function(e){var t=this,i=t.options;if(-1!==["int","float","money","currency","percent"].indexOf(this.type)){var s=b(this.el).val(),n=this.format(this.clean(b(this.el).val()));if(""!==s&&s!=n)return b(this.el).val(n).change(),e.stopPropagation(),e.preventDefault(),!1}if("color"===this.type){var a=b(this.el).val();"rgb"!==a.substr(0,3).toLowerCase()&&(a="#"+a,6!==b(this.el).val().length&&3!==b(this.el).val().length&&(a="")),b(this.el).next().find("div").css("background-color",a),b(this.el).is(":focus")&&!0!==b(this.el).data("skipInit")&&this.updateOverlay()}if(-1!==["list","enum","file"].indexOf(this.type)&&(t.refresh(),setTimeout(function(){t.refresh()},5)),-1!==["date","time","datetime"].indexOf(this.type)){var r=parseInt(t.el.value);w2utils.isInt(t.el.value)&&3e3<r&&("time"===this.type&&b(t.el).val(w2utils.formatTime(new Date(r),i.format)).change(),"date"===this.type&&b(t.el).val(w2utils.formatDate(new Date(r),i.format)).change(),"datetime"===this.type&&b(t.el).val(w2utils.formatDateTime(new Date(r),i.format)).change())}},click:function(e){e.stopPropagation(),-1!==["list","combo","enum"].indexOf(this.type)&&(b(this.el).is(":focus")||this.focus(e)),-1!==["date","time","color","datetime"].indexOf(this.type)&&this.updateOverlay()},focus:function(e){var t=this;if(-1!==["color","date","time","datetime"].indexOf(t.type)){if(b(t.el).prop("readonly")||b(t.el).prop("disabled"))return;0<b("#w2ui-overlay").length&&b("#w2ui-overlay")[0].hide(),setTimeout(function(){t.updateOverlay()},150)}if(-1!==["list","combo","enum"].indexOf(t.type)){if(b(t.el).prop("readonly")||b(t.el).prop("disabled"))return;0<b("#w2ui-overlay").length&&b("#w2ui-overlay")[0].hide(),t.resize(),setTimeout(function(){"list"===t.type&&b(t.el).is(":focus")?b(t.helpers.focus).find("input").focus():(t.search(),setTimeout(function(){t.updateOverlay()},1))},1),"function"==typeof t.options._items_fun&&(t.options.items=w2obj.field.prototype.normMenu.call(this,t.options._items_fun))}"file"===t.type&&b(t.helpers.multi).css({outline:"auto 5px #7DB4F3","outline-offset":"-2px"})},blur:function(e){var t=this,i=t.options,s=b(t.el).val().trim(),n=b("#w2ui-overlay");if(-1!==["color","date","time","list","combo","enum","datetime"].indexOf(t.type)){var a=window.setTimeout(function(){!0!==n.data("keepOpen")&&n.hide()},0);b(".menu",n).one("focus",function(){clearTimeout(a),b(this).one("focusout",function(e){n.hide()})})}-1!==["int","float","money","currency","percent"].indexOf(t.type)&&(""===s||t.checkType(s)||(b(t.el).val("").change(),!1===i.silent&&(b(t.el).w2tag("Not a valid number"),setTimeout(function(){b(t.el).w2tag("")},3e3)))),-1!==["date","time","datetime"].indexOf(t.type)&&(""===s||t.inRange(t.el.value)?"date"!==t.type||""===s||w2utils.isDate(t.el.value,i.format)?"time"!==t.type||""===s||w2utils.isTime(t.el.value)?"datetime"!==t.type||""===s||w2utils.isDateTime(t.el.value,i.format)||(b(t.el).val("").removeData("selected").change(),!1===i.silent&&(b(t.el).w2tag("Not a valid date"),setTimeout(function(){b(t.el).w2tag("")},3e3))):(b(t.el).val("").removeData("selected").change(),!1===i.silent&&(b(t.el).w2tag("Not a valid time"),setTimeout(function(){b(t.el).w2tag("")},3e3))):(b(t.el).val("").removeData("selected").change(),!1===i.silent&&(b(t.el).w2tag("Not a valid date"),setTimeout(function(){b(t.el).w2tag("")},3e3))):(b(t.el).val("").removeData("selected").change(),!1===i.silent&&(b(t.el).w2tag("Not in range"),setTimeout(function(){b(t.el).w2tag("")},3e3)))),"enum"===t.type&&b(t.helpers.multi).find("input").val("").width(20),"file"===t.type&&b(t.helpers.multi).css({outline:"none"})},keyPress:function(e){var t=this;t.options;if(-1!==["int","float","money","currency","percent","hex","bin","color","alphanumeric"].indexOf(t.type)){if(e.metaKey||e.ctrlKey||e.altKey||e.charCode!=e.keyCode&&0<e.keyCode)return;var i=String.fromCharCode(e.charCode);if(!t.checkType(i,!0)&&13!=e.keyCode)return e.preventDefault(),e.stopPropagation?e.stopPropagation():e.cancelBubble=!0,!1}-1!==["date","time","datetime"].indexOf(t.type)&&9!==e.keyCode&&setTimeout(function(){t.updateOverlay()},1)},keyDown:function(e,t){var i=this,s=i.options,n=e.keyCode||t&&t.keyCode,a=!1;if(-1!==["int","float","money","currency","percent"].indexOf(i.type)){if(!s.keyboard||b(i.el).prop("readonly")||b(i.el).prop("disabled"))return;var r=parseFloat(b(i.el).val().replace(s.moneyRE,""))||0,l=s.step;switch((e.ctrlKey||e.metaKey)&&(l=10),n){case 38:if(e.shiftKey)break;b(i.el).val(r+l<=s.max||null==s.max?Number((r+l).toFixed(12)):s.max).change(),a=!0;break;case 40:if(e.shiftKey)break;b(i.el).val(r-l>=s.min||null==s.min?Number((r-l).toFixed(12)):s.min).change(),a=!0}a&&(e.preventDefault(),setTimeout(function(){i.el.setSelectionRange(i.el.value.length,i.el.value.length)},0))}if("date"===i.type){if(!s.keyboard||b(i.el).prop("readonly")||b(i.el).prop("disabled"))return;var o=864e5;l=1;switch((e.ctrlKey||e.metaKey)&&(l=10),(c=w2utils.isDate(b(i.el).val(),s.format,!0))||(c=new Date,o=0),n){case 38:if(e.shiftKey)break;var d=w2utils.formatDate(c.getTime()+o,s.format);10==l&&(d=w2utils.formatDate(new Date(c.getFullYear(),c.getMonth()+1,c.getDate()),s.format)),b(i.el).val(d).trigger("input").change(),a=!0;break;case 40:if(e.shiftKey)break;d=w2utils.formatDate(c.getTime()-o,s.format);10==l&&(d=w2utils.formatDate(new Date(c.getFullYear(),c.getMonth()-1,c.getDate()),s.format)),b(i.el).val(d).trigger("input").change(),a=!0}a&&(e.preventDefault(),setTimeout(function(){i.el.setSelectionRange(i.el.value.length,i.el.value.length),i.updateOverlay()},0))}if("time"===i.type){if(!s.keyboard||b(i.el).prop("readonly")||b(i.el).prop("disabled"))return;l=e.ctrlKey||e.metaKey?60:1,r=b(i.el).val();var u=i.toMin(r)||i.toMin((new Date).getHours()+":"+((new Date).getMinutes()-1));switch(n){case 38:if(e.shiftKey)break;u+=l,a=!0;break;case 40:if(e.shiftKey)break;u-=l,a=!0}a&&(b(i.el).val(i.fromMin(u)).trigger("input").change(),e.preventDefault(),setTimeout(function(){i.el.setSelectionRange(i.el.value.length,i.el.value.length)},0))}if("datetime"===i.type){if(!s.keyboard||b(i.el).prop("readonly")||b(i.el).prop("disabled"))return;o=864e5,l=1;(e.ctrlKey||e.metaKey)&&(l=10);var c,h=b(i.el).val();switch((c=w2utils.isDateTime(h,this.options.format,!0))||(c=new Date,o=0),n){case 38:if(e.shiftKey)break;d=w2utils.formatDateTime(c.getTime()+o,s.format);10==l&&(d=w2utils.formatDateTime(new Date(c.getFullYear(),c.getMonth()+1,c.getDate()),s.format)),b(i.el).val(d).trigger("input").change(),a=!0;break;case 40:if(e.shiftKey)break;d=w2utils.formatDateTime(c.getTime()-o,s.format);10==l&&(d=w2utils.formatDateTime(new Date(c.getFullYear(),c.getMonth()-1,c.getDate()),s.format)),b(i.el).val(d).trigger("input").change(),a=!0}a&&(e.preventDefault(),setTimeout(function(){i.el.setSelectionRange(i.el.value.length,i.el.value.length),i.updateOverlay()},0))}if("color"===i.type){if(b(i.el).prop("readonly")||b(i.el).prop("disabled"))return;if((e.ctrlKey||e.metaKey)&&!e.shiftKey){var p=null,f=null;switch(n){case 38:p="up";break;case 40:p="down";break;case 39:p="right";break;case 37:p="left"}i.el.nav&&null!=p&&(f=i.el.nav(p),b(i.el).val(f).change(),e.preventDefault())}}if(-1!==["list","combo","enum"].indexOf(i.type)){if(b(i.el).prop("readonly")||b(i.el).prop("disabled"))return;var g=b(i.el).data("selected"),m=b(i.el),w=!1;switch(-1!==["list","enum"].indexOf(i.type)&&("list"===i.type&&(m=b(i.helpers.focus).find("input")),"enum"===i.type&&(m=b(i.helpers.multi).find("input")),-1==[37,38,39,40].indexOf(n)&&setTimeout(function(){i.refresh()},1),86==e.keyCode&&(e.ctrlKey||e.metaKey)&&setTimeout(function(){i.refresh(),i.search(),i.request()},50)),n){case 27:"list"===i.type&&(""!==m.val()&&m.val(""),e.stopPropagation());break;case 37:case 39:break;case 13:if(0===b("#w2ui-overlay").length)break;var v=s.items[s.index];if("enum"===i.type)if(null!=v){if(!0===(y=i.trigger({phase:"before",type:"add",target:i.el,originalEvent:e.originalEvent,item:v})).isCancelled)return;v=y.item,g.length>=s.max&&0<s.max&&g.pop(),delete v.hidden,delete i.tmp.force_open,g.push(v),b(i.el).change(),m.val("").width(20),i.refresh(),i.trigger(b.extend(y,{phase:"after"}))}else{if(v={id:m.val(),text:m.val()},!0===(y=i.trigger({phase:"before",type:"new",target:i.el,originalEvent:e.originalEvent,item:v})).isCancelled)return;v=y.item,"function"==typeof i.onNew&&(g.length>=s.max&&0<s.max&&g.pop(),delete i.tmp.force_open,g.push(v),b(i.el).change(),m.val("").width(20),i.refresh()),i.trigger(b.extend(y,{phase:"after"}))}else v&&b(i.el).data("selected",v).val(v.text).change(),""===b(i.el).val()&&b(i.el).data("selected")&&b(i.el).removeData("selected").val("").change(),"list"===i.type&&(m.val(""),i.refresh()),i.tmp.force_hide=!0;break;case 8:case 46:if("enum"===i.type&&8===n&&""===m.val()&&0<g.length){var y;v=g[g.length-1];if(!0===(y=i.trigger({phase:"before",type:"remove",target:i.el,originalEvent:e.originalEvent,item:v})).isCancelled)return;g.pop(),b(i.el).trigger("input").trigger("change"),i.refresh(),i.trigger(b.extend(y,{phase:"after"}))}"list"===i.type&&""===m.val()&&(b(i.el).data("selected",{}).change(),i.refresh());break;case 38:for(s.index=w2utils.isInt(s.index)?parseInt(s.index):0,s.index--;0<s.index&&s.items[s.index].hidden;)s.index--;if(0===s.index&&s.items[s.index].hidden)for(;s.items[s.index]&&s.items[s.index].hidden;)s.index++;w=!0;break;case 40:for(s.index=w2utils.isInt(s.index)?parseInt(s.index):-1,s.index++;s.index<s.items.length-1&&s.items[s.index].hidden;)s.index++;if(s.index==s.items.length-1&&s.items[s.index].hidden)for(;s.items[s.index]&&s.items[s.index].hidden;)s.index--;""===m.val()&&0===b("#w2ui-overlay").length?i.tmp.force_open=!0:w=!0}if(w)return s.index<0&&(s.index=0),s.index>=s.items.length&&(s.index=s.items.length-1),i.updateOverlay(w),e.preventDefault(),void setTimeout(function(){if("enum"===i.type)(e=m.get(0)).setSelectionRange(e.value.length,e.value.length);else if("list"===i.type){var e;(e=m.get(0)).setSelectionRange(e.value.length,e.value.length)}else i.el.setSelectionRange(i.el.value.length,i.el.value.length)},0);"enum"===i.type&&m.width(8*(m.val().length+2)+"px")}},keyUp:function(e){if(-1!==["list","combo","enum"].indexOf(this.type)){if(b(this.el).prop("readonly")||b(this.el).prop("disabled"))return;if(-1==[16,17,18,20,37,39,91].indexOf(e.keyCode)){var t=b(this.helpers.focus).find("input");0===t.length&&(t=b(this.el));var i=this.trigger({phase:"before",type:"search",originalEvent:e,target:t,search:t.val()});if(!0===i.isCancelled)return;this.tmp.force_hide||this.request(),1==t.val().length&&this.refresh(),0!==b("#w2ui-overlay").length&&-1!=[38,40].indexOf(e.keyCode)||this.search(),this.trigger(b.extend(i,{phase:"after"}))}}},clearCache:function(){this.options.items=[],this.tmp.xhr_loading=!1,this.tmp.xhr_search="",this.tmp.xhr_total=-1},request:function(e){var l=this,o=this.options,d=b(l.el).val()||"";if(o.url){if("enum"===l.type){var t=b(l.helpers.multi).find("input");d=0===t.length?"":t.val()}if("list"===l.type){t=b(l.helpers.focus).find("input");d=0===t.length?"":t.val()}if(0!==o.minLength&&d.length<o.minLength)return o.items=[],void this.updateOverlay();null==e&&(e=o.interval),null==l.tmp.xhr_search&&(l.tmp.xhr_search=""),null==l.tmp.xhr_total&&(l.tmp.xhr_total=-1),o.url&&(0===o.items.length&&0!==l.tmp.xhr_total||l.tmp.xhr_total==o.cacheMax&&d.length>l.tmp.xhr_search.length||d.length>=l.tmp.xhr_search.length&&d.substr(0,l.tmp.xhr_search.length)!==l.tmp.xhr_search||d.length<l.tmp.xhr_search.length)&&(l.tmp.xhr&&l.tmp.xhr.abort(),l.tmp.xhr_loading=!0,l.search(),clearTimeout(l.tmp.timeout),l.tmp.timeout=setTimeout(function(){var e=o.url,r={search:d,max:o.cacheMax};b.extend(r,o.postData);var t=l.trigger({phase:"before",type:"request",search:d,target:l.el,url:e,postData:r});if(!0!==t.isCancelled){var i={type:"GET",url:e=t.url,data:r=t.postData,dataType:"JSON"};o.method&&(i.type=o.method),"JSON"===w2utils.settings.dataType&&(i.type="POST",i.data=JSON.stringify(i.data),i.contentType="application/json"),"HTTPJSON"===w2utils.settings.dataType&&(i.data={request:JSON.stringify(i.data)}),null!=o.method&&(i.type=o.method),l.tmp.xhr=b.ajax(i).done(function(e,t,i){var s=l.trigger({phase:"before",type:"load",target:l.el,search:r.search,data:e,xhr:i});if(!0!==s.isCancelled)if("string"==typeof(e=s.data)&&(e=JSON.parse(e)),null==e.records&&null!=e.items&&(e.records=e.items,delete e.items),"success"===e.status&&null==e.records&&(e.records=[]),"success"===e.status&&Array.isArray(e.records)){e.records.length>o.cacheMax&&e.records.splice(o.cacheMax,1e5),null==o.recId&&null!=o.recid&&(o.recId=o.recid),(o.recId||o.recText)&&e.records.forEach(function(e){"string"==typeof o.recId&&(e.id=e[o.recId]),"function"==typeof o.recId&&(e.id=o.recId(e)),"string"==typeof o.recText&&(e.text=e[o.recText]),"function"==typeof o.recText&&(e.text=o.recText(e))}),l.tmp.xhr_loading=!1,l.tmp.xhr_search=d,l.tmp.xhr_total=e.records.length,l.tmp.lastError="",o.items=l.normMenu(e.records),""===d&&0===e.records.length?l.tmp.emptySet=!0:l.tmp.emptySet=!1;var n,a=b(l.el).data("find_selected");if(a)Array.isArray(a)?(n=[],a.forEach(function(t){o.items.forEach(function(e){e.id==t&&n.push(b.extend(!0,{},e))})})):o.items.forEach(function(e){e.id==a&&(n=e)}),b(l.el).data("selected",n).removeData("find_selected").change();l.search(),l.trigger(b.extend(s,{phase:"after"}))}else console.log("ERROR: server did not return proper structure. It should return",{status:"success",records:[{id:1,text:"item"}]})}).fail(function(e,t,i){var s={status:t,error:i,rawResponseText:e.responseText},n=l.trigger({phase:"before",type:"error",target:l.el,search:d,error:s,xhr:e});if(!0!==n.isCancelled){if("abort"!==t){var a;try{a=b.parseJSON(e.responseText)}catch(e){}console.log("ERROR: Server communication failed.","\n   EXPECTED:",{status:"success",records:[{id:1,text:"item"}]},"\n         OR:",{status:"error",message:"error message"},"\n   RECEIVED:","object"==typeof a?a:e.responseText)}l.tmp.xhr_loading=!1,l.tmp.xhr_search=d,l.tmp.xhr_total=0,l.tmp.emptySet=!0,l.tmp.lastError=n.error||"Server communication failed",o.items=[],l.clearCache(),l.search(),l.updateOverlay(!1),l.trigger(b.extend(n,{phase:"after"}))}}),l.trigger(b.extend(t,{phase:"after"}))}},e))}},search:function(){var e=this,t=this.options,i=b(e.el).val(),s=e.el,n=[],a=b(e.el).data("selected");if("enum"===e.type)for(var r in s=b(e.helpers.multi).find("input"),i=s.val(),a)a[r]&&n.push(a[r].id);else if("list"===e.type)for(var r in s=b(e.helpers.focus).find("input"),i=s.val(),a)a[r]&&n.push(a[r].id);var l=t.items;if(!0!==e.tmp.xhr_loading){for(var o=0,d=0;d<l.length;d++){var u=l[d];if(null!=t.compare)"function"==typeof t.compare&&(u.hidden=!1===t.compare.call(this,u,i));else{var c="",h="";-1!==["is","begins"].indexOf(t.match)&&(c="^"),-1!==["is","ends"].indexOf(t.match)&&(h="$");try{new RegExp(c+i+h,"i").test(u.text)||"..."===u.text?u.hidden=!1:u.hidden=!0}catch(e){}}!1===t.filter&&(u.hidden=!1),"enum"===e.type&&-1!==b.inArray(u.id,n)&&(u.hidden=!0),!0!==u.hidden&&(o++,delete u.hidden)}for(t.index=-1;l[t.index]&&l[t.index].hidden;)t.index++;o<=0&&(t.index=-1),t.spinner=!1,e.updateOverlay(),setTimeout(function(){var e=b("#w2ui-overlay").html()||"";t.markSearch&&-1!==e.indexOf("$.fn.w2menuHandler")&&b("#w2ui-overlay").w2marker(i)},1)}else l.splice(0,t.cacheMax),t.spinner=!0,e.updateOverlay()},updateOverlay:function(e){var s=this,n=this.options;if("color"===this.type){if(b(s.el).prop("readonly")||b(s.el).prop("disabled"))return;b(this.el).w2color({color:b(this.el).val(),transparent:n.transparent,advanced:n.advanced},function(e){null!=e&&b(s.el).val(e).trigger("input").change()})}if("date"===this.type){if(b(s.el).prop("readonly")||b(s.el).prop("disabled"))return;0===b("#w2ui-overlay").length&&b(s.el).w2overlay('<div class="w2ui-reset w2ui-calendar"></div>',{css:{"background-color":"#f5f5f5"},onShow:function(e){w2utils.isIE&&(console.log("IE"),b(".w2ui-calendar").on("mousedown",function(e){var t=b(e.target);1===t.length&&"w2ui-jump-year"===t[0].id&&b("#w2ui-overlay").data("keepOpen",!0)}))}}),(r=w2utils.isDate(b(s.el).val(),s.options.format,!0))&&(t=r.getMonth()+1,a=r.getFullYear()),function i(e,t){b("#w2ui-overlay > div > div").html(s.getMonthHTML(e,t,b(s.el).val())),b("#w2ui-overlay .w2ui-calendar-title").on("mousedown",function(){var e,t;b(this).next().hasClass("w2ui-calendar-jump")?b(this).next().remove():(b(this).after('<div class="w2ui-calendar-jump" style=""></div>'),b(this).next().hide().html(s.getYearHTML()).fadeIn(200),setTimeout(function(){b("#w2ui-overlay .w2ui-calendar-jump").find(".w2ui-jump-month, .w2ui-jump-year").on("click",function(){b(this).hasClass("w2ui-jump-month")&&(b(this).parent().find(".w2ui-jump-month").removeClass("selected"),b(this).addClass("selected"),t=b(this).attr("name")),b(this).hasClass("w2ui-jump-year")&&(b(this).parent().find(".w2ui-jump-year").removeClass("selected"),b(this).addClass("selected"),e=b(this).attr("name")),null!=e&&null!=t&&(b("#w2ui-overlay .w2ui-calendar-jump").fadeOut(100),setTimeout(function(){i(parseInt(t)+1,e)},100))}),b("#w2ui-overlay .w2ui-calendar-jump >:last-child").prop("scrollTop",2e3)},1))}),b("#w2ui-overlay .w2ui-date").on("mousedown",function(){var e=b(this).attr("date");b(s.el).val(e).trigger("input").change(),b(this).css({"background-color":"#B6D5FB","border-color":"#aaa"})}).on("mouseup",function(){setTimeout(function(){0<b("#w2ui-overlay").length&&b("#w2ui-overlay").removeData("keepOpen")[0].hide()},10)}),b("#w2ui-overlay .previous").on("mousedown",function(){var e=s.options.current.split("/");e[0]=parseInt(e[0])-1,i(e[0],e[1])}),b("#w2ui-overlay .next").on("mousedown",function(){var e=s.options.current.split("/");e[0]=parseInt(e[0])+1,i(e[0],e[1])})}(t,a)}if("time"===this.type){if(b(s.el).prop("readonly")||b(s.el).prop("disabled"))return;0===b("#w2ui-overlay").length&&b(s.el).w2overlay('<div class="w2ui-reset w2ui-calendar-time" onclick="event.stopPropagation();"></div>',{css:{"background-color":"#fff"}});var i="h24"===this.options.format;b("#w2ui-overlay > div").html(s.getHourHTML()),b("#w2ui-overlay .w2ui-time").on("mousedown",function(e){b(this).css({"background-color":"#B6D5FB","border-color":"#aaa"});var t=b(this).attr("hour");b(s.el).val((12<t&&!i?t-12:t)+":00"+(i?"":t<12?" am":" pm")).trigger("input").change()}),null==this.options.noMinutes||!1===this.options.noMinutes?b("#w2ui-overlay .w2ui-time").on("mouseup",function(){var t=b(this).attr("hour");0<b("#w2ui-overlay").length&&b("#w2ui-overlay")[0].hide(),b(s.el).w2overlay('<div class="w2ui-reset w2ui-calendar-time"></div>',{css:{"background-color":"#fff"}}),b("#w2ui-overlay > div").html(s.getMinHTML(t)),b("#w2ui-overlay .w2ui-time").on("mousedown",function(){b(this).css({"background-color":"#B6D5FB","border-color":"#aaa"});var e=b(this).attr("min");b(s.el).val((12<t&&!i?t-12:t)+":"+(e<10?0:"")+e+(i?"":t<12?" am":" pm")).trigger("input").change()}).on("mouseup",function(){setTimeout(function(){0<b("#w2ui-overlay").length&&b("#w2ui-overlay").removeData("keepOpen")[0].hide()},10)})}):b("#w2ui-overlay .w2ui-time").on("mouseup",function(){setTimeout(function(){0<b("#w2ui-overlay").length&&b("#w2ui-overlay").removeData("keepOpen")[0].hide()},10)})}if("datetime"===this.type){if(b(s.el).prop("readonly")||b(s.el).prop("disabled"))return;var t,a,r;0<b("#w2ui-overlay .w2ui-time").length&&b("#w2ui-overlay")[0].hide(),0===b("#w2ui-overlay").length&&b(s.el).w2overlay('<div class="w2ui-reset w2ui-calendar" onclick="event.stopPropagation();"></div>',{css:{"background-color":"#f5f5f5"},onShow:function(e){w2utils.isIE&&(console.log("IE"),b(".w2ui-calendar").on("mousedown",function(e){var t=b(e.target);1===t.length&&"w2ui-jump-year"===t[0].id&&b("#w2ui-overlay").data("keepOpen",!0)}))}}),(r=w2utils.isDateTime(b(s.el).val(),s.options.format,!0))&&(t=r.getMonth()+1,a=r.getFullYear());var l=null;!function i(e,t){b("#w2ui-overlay > div > div").html(s.getMonthHTML(e,t,b(s.el).val())+(n.btn_now?'<div class="w2ui-calendar-now now">'+w2utils.lang("Current Date & Time")+"</div>":"")),b("#w2ui-overlay .w2ui-calendar-title").on("mousedown",function(){var e,t;b(this).next().hasClass("w2ui-calendar-jump")?b(this).next().remove():(b(this).after('<div class="w2ui-calendar-jump" style=""></div>'),b(this).next().hide().html(s.getYearHTML()).fadeIn(200),setTimeout(function(){b("#w2ui-overlay .w2ui-calendar-jump").find(".w2ui-jump-month, .w2ui-jump-year").on("click",function(){b(this).hasClass("w2ui-jump-month")&&(b(this).parent().find(".w2ui-jump-month").removeClass("selected"),b(this).addClass("selected"),t=b(this).attr("name")),b(this).hasClass("w2ui-jump-year")&&(b(this).parent().find(".w2ui-jump-year").removeClass("selected"),b(this).addClass("selected"),e=b(this).attr("name")),null!=e&&null!=t&&(b("#w2ui-overlay .w2ui-calendar-jump").fadeOut(100),setTimeout(function(){i(parseInt(t)+1,e)},100))}),b("#w2ui-overlay .w2ui-calendar-jump >:last-child").prop("scrollTop",2e3)},1))}),b("#w2ui-overlay .w2ui-date").on("mousedown",function(){var e=b(this).attr("date");b(s.el).val(e).trigger("input").change(),b(this).css({"background-color":"#B6D5FB","border-color":"#aaa"}),l=new Date(b(this).attr("data-date"))}).on("mouseup",function(){var i,t;0<b("#w2ui-overlay").length&&b("#w2ui-overlay")[0].hide(),b(s.el).w2overlay('<div class="w2ui-reset w2ui-calendar-time"></div>',{css:{"background-color":"#fff"}});s.options.format;b("#w2ui-overlay > div").html(s.getHourHTML()),b("#w2ui-overlay .w2ui-time").on("mousedown",function(e){b(this).css({"background-color":"#B6D5FB","border-color":"#aaa"}),i=b(this).attr("hour"),l.setHours(i);var t=w2utils.formatDateTime(l,s.options.format);b(s.el).val(t).trigger("input").change()}),null==s.options.noMinutes||!1===s.options.noMinutes?b("#w2ui-overlay .w2ui-time").on("mouseup",function(){var e=b(this).attr("hour");0<b("#w2ui-overlay").length&&b("#w2ui-overlay")[0].hide(),b(s.el).w2overlay('<div class="w2ui-reset w2ui-calendar-time"></div>',{css:{"background-color":"#fff"}}),b("#w2ui-overlay > div").html(s.getMinHTML(e)),b("#w2ui-overlay .w2ui-time").on("mousedown",function(){b(this).css({"background-color":"#B6D5FB","border-color":"#aaa"}),t=b(this).attr("min"),l.setHours(i,t);var e=w2utils.formatDateTime(l,s.options.format);b(s.el).val(e).trigger("input").change()}).on("mouseup",function(){setTimeout(function(){0<b("#w2ui-overlay").length&&b("#w2ui-overlay").removeData("keepOpen")[0].hide()},10)})}):b("#w2ui-overlay .w2ui-time").on("mouseup",function(){setTimeout(function(){0<b("#w2ui-overlay").length&&b("#w2ui-overlay").removeData("keepOpen")[0].hide()},10)})}),b("#w2ui-overlay .previous").on("mousedown",function(){var e=s.options.current.split("/");e[0]=parseInt(e[0])-1,i(e[0],e[1])}),b("#w2ui-overlay .next").on("mousedown",function(){var e=s.options.current.split("/");e[0]=parseInt(e[0])+1,i(e[0],e[1])}),b("#w2ui-overlay .now").on("mousedown",function(){var e=w2utils.formatDateTime(new Date,s.options.format);return b(s.el).val(e).trigger("input").change(),!1}).on("mouseup",function(){setTimeout(function(){0<b("#w2ui-overlay").length&&b("#w2ui-overlay").removeData("keepOpen")[0].hide()},10)})}(t,a)}if(-1!==["list","combo","enum"].indexOf(this.type)){var o=this.el,d=this.el;if("enum"===this.type&&(o=b(this.helpers.multi),d=b(o).find("input")),"list"===this.type){var u=b(d).data("selected");b.isPlainObject(u)&&!b.isEmptyObject(u)&&-1==n.index&&n.items.forEach(function(e,t){e.id===u.id&&(n.index=t)}),d=b(this.helpers.focus).find("input")}if(b(d).is(":focus")){if(!1===n.openOnFocus&&""===b(d).val()&&!0!==s.tmp.force_open)return void b().w2overlay();if(s.tmp.force_hide)return b().w2overlay(),void setTimeout(function(){delete s.tmp.force_hide},1);""!==b(d).val()&&delete s.tmp.force_open;var c=w2utils.lang("No matches");null!=n.url&&b(d).val().length<n.minLength&&!0!==s.tmp.emptySet&&(c=n.minLength+" "+w2utils.lang("letters or more...")),null!=n.url&&""===b(d).val()&&!0!==s.tmp.emptySet&&(c=w2utils.lang(n.msgSearch||"Type to search...")),null==n.url&&0===n.items.length&&(c=w2utils.lang("Empty list")),null!=n.msgNoItems&&(c="function"==typeof c?c(n):n.msgNoItems),s.tmp.lastError&&(c=s.tmp.lastError),c='<div style="white-space: normal; line-height: 1.3">'+c+"</div>";var h=b.extend(!0,{},n,{search:!1,render:n.renderDrop,maxHeight:n.maxDropHeight,maxWidth:n.maxDropWidth,msgNoItems:c,onSelect:function(e){if("enum"===s.type){var t=b(s.el).data("selected");if(e.item){var i=s.trigger({phase:"before",type:"add",target:s.el,originalEvent:e.originalEvent,item:e.item});if(!0===i.isCancelled)return;t.length>=n.max&&0<n.max&&t.pop(),delete e.item.hidden,t.push(e.item),b(s.el).data("selected",t).trigger("input").change(),b(s.helpers.multi).find("input").val("").width(20),s.refresh(),0<b("#w2ui-overlay").length&&b("#w2ui-overlay")[0].hide(),s.trigger(b.extend(i,{phase:"after"}))}}else b(s.el).data("selected",e.item).val(e.item.text).trigger("input").change(),s.helpers.focus&&s.helpers.focus.find("input").val("")}});b(o).w2menu(e?"refresh-index":"refresh",h)}}},inRange:function(e,t){var i=!1;if("date"===this.type){if(p=w2utils.isDate(e,this.options.format,!0)){if(this.options.start||this.options.end){var s="string"==typeof this.options.start?this.options.start:b(this.options.start).val(),n="string"==typeof this.options.end?this.options.end:b(this.options.end).val(),a=w2utils.isDate(s,this.options.format,!0),r=w2utils.isDate(n,this.options.format,!0),l=new Date(p);r=r||l,(a=a||l)<=l&&l<=r&&(i=!0)}else i=!0;if(this.options.blocked&&-1!==b.inArray(e,this.options.blocked)&&(i=!1),null!==this.options.blockWeekDays&&void 0!==this.options.blockWeekDays&&null!=this.options.blockWeekDays.length)for(var o=this.options.blockWeekDays.length,d=0;d<o;d++)p.getDay()==this.options.blockWeekDays[d]&&(i=!1)}}else if("time"===this.type)if(this.options.start||this.options.end){var u=this.toMin(e),c=this.toMin(this.options.start),h=this.toMin(this.options.end);h=h||u,(c=c||u)<=u&&u<=h&&(i=!0)}else i=!0;else if("datetime"===this.type){var p;if(p=w2utils.isDateTime(e,this.options.format,!0)){if(this.options.start||this.options.end){if("object"==typeof this.options.start&&this.options.start instanceof Date)a=this.options.start;else a=""!==(s="string"==typeof this.options.start?this.options.start:b(this.options.start).val()).trim()?w2utils.isDateTime(s,this.options.format,!0):"";if("object"==typeof this.options.end&&this.options.end instanceof Date)r=this.options.end;else r=""!==(n="string"==typeof this.options.end?this.options.end:b(this.options.end).val()).trim()?w2utils.isDateTime(n,this.options.format,!0):"";l=p;a=a||l,r=r||l,t&&a instanceof Date&&(a.setHours(0),a.setMinutes(0),a.setSeconds(0)),a<=l&&l<=r&&(i=!0)}else i=!0;if(i&&this.options.blocked)for(d=0;d<this.options.blocked.length;d++){var f=this.options.blocked[d];if("string"==typeof f&&(f=w2utils.isDateTime(f,this.options.format,!0)),"object"==typeof f&&f instanceof Date&&f.getFullYear()==p.getFullYear()&&f.getMonth()==p.getMonth()&&f.getDate()==p.getDate()){i=!1;break}}}}return i},checkType:function(e,t){var i=this;switch(i.type){case"int":return!(!t||-1===["-",i.options.groupSymbol].indexOf(e))||w2utils.isInt(e.replace(i.options.numberRE,""));case"percent":e=e.replace(/%/g,"");case"float":return!(!t||-1===["-",w2utils.settings.decimalSymbol,i.options.groupSymbol].indexOf(e))||w2utils.isFloat(e.replace(i.options.numberRE,""));case"money":case"currency":return!(!t||-1===["-",i.options.decimalSymbol,i.options.groupSymbol,i.options.currencyPrefix,i.options.currencySuffix].indexOf(e))||w2utils.isFloat(e.replace(i.options.moneyRE,""));case"bin":return w2utils.isBin(e);case"hex":return w2utils.isHex(e);case"alphanumeric":return w2utils.isAlphaNumeric(e)}return!0},addPrefix:function(){var i=this;setTimeout(function(){if("clear"!==i.type){var e,t=b(i.el).data("tmp")||{};t["old-padding-left"]&&b(i.el).css("padding-left",t["old-padding-left"]),t["old-padding-left"]=b(i.el).css("padding-left"),b(i.el).data("tmp",t),i.helpers.prefix&&b(i.helpers.prefix).remove(),""!==i.options.prefix&&(b(i.el).before('<div class="w2ui-field-helper">'+i.options.prefix+"</div>"),(e=b(i.el).prev()).css({color:b(i.el).css("color"),"font-family":b(i.el).css("font-family"),"font-size":b(i.el).css("font-size"),"padding-top":b(i.el).css("padding-top"),"padding-bottom":b(i.el).css("padding-bottom"),"padding-left":b(i.el).css("padding-left"),"padding-right":0,"margin-top":parseInt(b(i.el).css("margin-top"),10)+2+"px","margin-bottom":parseInt(b(i.el).css("margin-bottom"),10)+1+"px","margin-left":b(i.el).css("margin-left"),"margin-right":0}).on("click",function(e){if(i.options.icon&&"function"==typeof i.onIconClick){var t=i.trigger({phase:"before",type:"iconClick",target:i.el,el:b(this).find("span.w2ui-icon")[0]});if(!0===t.isCancelled)return;i.trigger(b.extend(t,{phase:"after"}))}else"list"===i.type?b(i.helpers.focus).find("input").focus():b(i.el).focus()}),b(i.el).css("padding-left",e.width()+parseInt(b(i.el).css("padding-left"),10)+"px"),i.helpers.prefix=e)}},1)},addSuffix:function(){var t,i,n=this;setTimeout(function(){if("clear"!==n.type){var e=b(n.el).data("tmp")||{};e["old-padding-right"]&&b(n.el).css("padding-right",e["old-padding-right"]),e["old-padding-right"]=b(n.el).css("padding-right"),b(n.el).data("tmp",e),i=parseInt(b(n.el).css("padding-right"),10),n.options.arrows&&(n.helpers.arrows&&b(n.helpers.arrows).remove(),b(n.el).after('<div class="w2ui-field-helper" style="border: 1px solid transparent">&#160;    <div class="w2ui-field-up" type="up">        <div class="arrow-up" type="up"></div>    </div>    <div class="w2ui-field-down" type="down">        <div class="arrow-down" type="down"></div>    </div></div>'),(t=b(n.el).next()).css({color:b(n.el).css("color"),"font-family":b(n.el).css("font-family"),"font-size":b(n.el).css("font-size"),height:b(n.el).height()+parseInt(b(n.el).css("padding-top"),10)+parseInt(b(n.el).css("padding-bottom"),10)+"px",padding:0,"margin-top":parseInt(b(n.el).css("margin-top"),10)+1+"px","margin-bottom":0,"border-left":"1px solid silver"}).css("margin-left","-"+(t.width()+parseInt(b(n.el).css("margin-right"),10)+12)+"px").on("mousedown",function(t){var i=b("body");function s(e){b(n.el).focus(),n.keyDown(b.Event("keydown"),{keyCode:"up"===b(t.target).attr("type")?38:40}),!1!==e&&b("body").data("_field_update_timer",setTimeout(s,60))}i.on("mouseup",function e(){clearTimeout(i.data("_field_update_timer"));i.off("mouseup",e)}),i.data("_field_update_timer",setTimeout(s,700)),s(!1)}),i+=t.width()+12,b(n.el).css("padding-right",i+"px"),n.helpers.arrows=t),""!==n.options.suffix&&(n.helpers.suffix&&b(n.helpers.suffix).remove(),b(n.el).after('<div class="w2ui-field-helper">'+n.options.suffix+"</div>"),(t=b(n.el).next()).css({color:b(n.el).css("color"),"font-family":b(n.el).css("font-family"),"font-size":b(n.el).css("font-size"),"padding-top":b(n.el).css("padding-top"),"padding-bottom":b(n.el).css("padding-bottom"),"padding-left":"3px","padding-right":b(n.el).css("padding-right"),"margin-top":parseInt(b(n.el).css("margin-top"),10)+2+"px","margin-bottom":parseInt(b(n.el).css("margin-bottom"),10)+1+"px"}).on("click",function(e){"list"===n.type?b(n.helpers.focus).find("input").focus():b(n.el).focus()}),t.css("margin-left","-"+(w2utils.getSize(t,"width")+parseInt(b(n.el).css("margin-right"),10)+2)+"px"),i+=t.width()+3,b(n.el).css("padding-right",i+"px"),n.helpers.suffix=t)}},1)},addFocus:function(){var i,s=this;this.options;b(s.helpers.focus).remove();var e=parseInt(b(s.el).attr("tabIndex"));isNaN(e)||-1===e||(s.el._tabIndex=e),s.el._tabIndex&&(e=s.el._tabIndex),null==e&&(e=-1);var t='<div class="w2ui-field-helper">    <div class="w2ui-icon icon-search" style="opacity: 0; display: none"></div>    <input type="text" autocomplete="off" tabIndex="'+e+'"/></div>';b(s.el).attr("tabindex",-1).before(t);var n=b(s.el).prev();(s.helpers.focus=n).css({width:b(s.el).width(),"margin-top":b(s.el).css("margin-top"),"margin-left":parseInt(b(s.el).css("margin-left"))+parseInt(b(s.el).css("padding-left"))+"px","margin-bottom":b(s.el).css("margin-bottom"),"margin-right":b(s.el).css("margin-right")}).find("input").css({cursor:"default",width:"100%",outline:"none",opacity:1,margin:0,border:"1px solid transparent",padding:b(s.el).css("padding-top"),"padding-left":0,"margin-left":0,"background-color":"transparent"}),n.find("input").on("click",function(e){0===b("#w2ui-overlay").length&&s.focus(e),e.stopPropagation()}).on("focus",function(e){i=b(s.el).attr("placeholder"),b(s.el).css({outline:"auto 5px #7DB4F3","outline-offset":"-2px"}),b(this).val(""),b(s.el).triggerHandler("focus"),e.stopPropagation?e.stopPropagation():e.cancelBubble=!0}).on("blur",function(e){b(s.el).css("outline","none"),b(this).val(""),s.refresh(),b(s.el).triggerHandler("blur"),e.stopPropagation?e.stopPropagation():e.cancelBubble=!0,null!=i&&b(s.el).attr("placeholder",i)}).on("keydown",function(e){var t=this;s.keyDown(e),setTimeout(function(){""===t.value?b(s.el).attr("placeholder",i):b(s.el).attr("placeholder","")},10)}).on("keyup",function(e){s.keyUp(e)}).on("keypress",function(e){s.keyPress(e)}),n.on("click",function(e){b(this).find("input").focus()}),s.refresh()},addMulti:function(){var n=this;this.options;b(n.helpers.multi).remove();var e="",t="margin-top     : 0px; margin-bottom  : 0px; margin-left    : "+b(n.el).css("margin-left")+"; margin-right   : "+b(n.el).css("margin-right")+"; width          : "+(w2utils.getSize(n.el,"width")-parseInt(b(n.el).css("margin-left"),10)-parseInt(b(n.el).css("margin-right"),10))+"px;";if("enum"===n.type){var i=b(n.el).attr("tabIndex");i&&-1!==i&&(n.el._tabIndex=i),n.el._tabIndex&&(i=n.el._tabIndex),null==i&&(i=-1),e='<div class="w2ui-field-helper w2ui-list" style="'+t+'; box-sizing: border-box">    <div style="padding: 0px; margin: 0px; display: inline-block" class="w2ui-multi-items">    <ul>        <li style="padding-left: 0px; padding-right: 0px" class="nomouse">            <input type="text" style="width: 20px; margin: -3px 0 0; padding: 2px 0; border-color: white" autocomplete="off"'+(b(n.el).prop("readonly")?' readonly="readonly"':"")+(b(n.el).prop("disabled")?' disabled="disabled"':"")+' tabindex="'+i+'"/>        </li>    </ul>    </div></div>'}"file"===n.type&&(e='<div class="w2ui-field-helper w2ui-list" style="'+t+'; box-sizing: border-box">   <div style="position: absolute; left: 0px; right: 0px; top: 0px; bottom: 0px;">       <input class="file-input" type="file" style="width: 100%; height: 100%; opacity: 0;" name="attachment" tabindex="-1"'+(1!==n.options.max?' multiple="multiple"':"")+(b(n.el).prop("readonly")?' readonly="readonly"':"")+(b(n.el).prop("disabled")?' disabled="disabled"':"")+(b(n.el).attr("accept")?' accept="'+b(n.el).attr("accept")+'"':"")+'/>   </div>    <div style="position: absolute; padding: 0px; margin: 0px; display: inline-block" class="w2ui-multi-items">        <ul><li style="padding-left: 0px; padding-right: 0px" class="nomouse"></li></ul>    </div></div>');var s=b(n.el).data("tmp")||{};s["old-background-color"]=b(n.el).css("background-color"),s["old-border-color"]=b(n.el).css("border-color"),b(n.el).data("tmp",s),b(n.el).before(e).css({"background-color":"transparent","border-color":"transparent"});var a=b(n.el).prev();n.helpers.multi=a,"enum"===n.type&&(b(n.el).attr("tabindex",-1),a.find("input").on("click",function(e){0===b("#w2ui-overlay").length&&n.focus(e),b(n.el).triggerHandler("click")}).on("focus",function(e){b(a).css({outline:"auto 5px #7DB4F3","outline-offset":"-2px"}),b(n.el).triggerHandler("focus"),e.stopPropagation?e.stopPropagation():e.cancelBubble=!0}).on("blur",function(e){b(a).css("outline","none"),b(n.el).triggerHandler("blur"),e.stopPropagation?e.stopPropagation():e.cancelBubble=!0}).on("keyup",function(e){n.keyUp(e)}).on("keydown",function(e){n.keyDown(e)}).on("keypress",function(e){n.keyPress(e)}),a.on("click",function(e){b(this).find("input").focus()})),"file"===n.type&&(b(n.el).css("outline","none"),a.on("click",function(e){b(n.el).focus(),b(n.el).prop("readonly")||b(n.el).prop("disabled")||(n.blur(e),n.resize(),setTimeout(function(){a.find("input").click()},10))}).on("dragenter",function(e){b(n.el).prop("readonly")||b(n.el).prop("disabled")||b(a).addClass("w2ui-file-dragover")}).on("dragleave",function(e){b(n.el).prop("readonly")||b(n.el).prop("disabled")||0===b(e.target).parents(".w2ui-field-helper").length&&b(a).removeClass("w2ui-file-dragover")}).on("drop",function(e){if(!b(n.el).prop("readonly")&&!b(n.el).prop("disabled")){b(a).removeClass("w2ui-file-dragover");for(var t=e.originalEvent.dataTransfer.files,i=0,s=t.length;i<s;i++)n.addFile.call(n,t[i]);e.preventDefault(),e.stopPropagation()}}).on("dragover",function(e){e.preventDefault(),e.stopPropagation()}),a.find("input").on("click",function(e){e.stopPropagation()}).on("change",function(){if(void 0!==this.files)for(var e=0,t=this.files.length;e<t;e++)n.addFile.call(n,this.files[e])})),n.refresh()},addFile:function(e){var t,s=this,i=this.options,n=b(s.el).data("selected"),a={name:e.name,type:e.type,modified:e.lastModifiedDate,size:e.size,content:null,file:e},r=0,l=0;if(n)for(var o=0;o<n.length;o++){if(n[o].name==e.name&&n[o].size==e.size)return;r+=n[o].size,l++}var d=s.trigger({phase:"before",type:"add",target:s.el,file:a,total:l,totalSize:r});if(!0!==d.isCancelled){if(0!==i.maxFileSize&&a.size>i.maxFileSize)return t="Maximum file size is "+w2utils.formatSize(i.maxFileSize),!1===i.silent&&b(s.el).w2tag(t),void console.log("ERROR: "+t);if(0!==i.maxSize&&r+a.size>i.maxSize)return t=w2utils.lang("Maximum total size is")+" "+w2utils.formatSize(i.maxSize),void(!1===i.silent?b(s.el).w2tag(t):console.log("ERROR: "+t));if(0!==i.max&&l>=i.max)return t=w2utils.lang("Maximum number of files is")+" "+i.max,void(!1===i.silent?b(s.el).w2tag(t):console.log("ERROR: "+t));if(n.push(a),"undefined"!=typeof FileReader&&!0===i.readContent){var u=new FileReader;u.onload=function(e){var t=e.target.result,i=t.indexOf(",");a.content=t.substr(i+1),s.refresh(),b(s.el).trigger("input").trigger("change"),s.trigger(b.extend(d,{phase:"after"}))},u.readAsDataURL(e)}else s.refresh(),b(s.el).trigger("input").trigger("change"),s.trigger(b.extend(d,{phase:"after"}))}},normMenu:function(e,t){if(b.isArray(e)){for(var i=0;i<e.length;i++)"string"==typeof e[i]?e[i]={id:e[i],text:e[i]}:null!=e[i]?(null!=e[i].text&&null==e[i].id&&(e[i].id=e[i].text),null==e[i].text&&null!=e[i].id&&(e[i].text=e[i].id),null!=e[i].caption&&(e[i].text=e[i].caption)):e[i]={id:null,text:"null"};return e}if("function"==typeof e)return w2obj.field.prototype.normMenu.call(this,e.call(this,t));if("object"==typeof e){var s=[];for(var i in e)s.push({id:i,text:e[i]});return s}},getMonthHTML:function(e,t,i){var s=new Date,n=w2utils.settings.fullmonths,a=["31","28","31","30","31","30","31","31","30","31","30","31"],r=s.getFullYear()+"/"+(Number(s.getMonth())+1)+"/"+s.getDate(),l=w2utils.settings.fulldays.slice(),o=w2utils.settings.shortdays.slice();"M"!==w2utils.settings.weekStarts&&(l.unshift(l.pop()),o.unshift(o.pop()));var d=this.options;null==d&&(d={}),t=w2utils.isInt(t)?parseInt(t):s.getFullYear(),12<(e=w2utils.isInt(e)?parseInt(e):s.getMonth()+1)&&(e-=12,t++),(e<1||0===e)&&(e+=12,t--),t/4==Math.floor(t/4)?a[1]="29":a[1]="28",d.current=e+"/"+t;for(var u=(s=new Date(t,e-1,1)).getDay(),c="",h=0;h<o.length;h++)c+='<td title="'+l[h]+'">'+o[h]+"</td>";var p='<div class="w2ui-calendar-title title">    <div class="w2ui-calendar-previous previous"> <div></div> </div>    <div class="w2ui-calendar-next next"> <div></div> </div> '+n[e-1]+", "+t+'</div><table class="w2ui-calendar-days" cellspacing="0"><tbody>    <tr class="w2ui-day-title">'+c+"</tr>    <tr>",f=1;if("M"!==w2utils.settings.weekStarts&&u++,"datetime"===this.type){var g=w2utils.isDateTime(i,d.format,!0);i=w2utils.formatDate(g,w2utils.settings.dateFormat)}for(var m=1;m<43;m++){if(0===u&&1==m){for(var w=0;w<6;w++)p+='<td class="w2ui-day-empty">&#160;</td>';m+=6}else if(m<u||f>a[e-1]){p+='<td class="w2ui-day-empty">&#160;</td>',m%7==0&&(p+="</tr><tr>");continue}var v=t+"/"+e+"/"+f,y=new Date(v),b="";6===y.getDay()&&(b=" w2ui-saturday"),0===y.getDay()&&(b=" w2ui-sunday"),v==r&&(b+=" w2ui-today");var x,_,k=f,C="",T="";if(_="datetime"===this.type?(x=w2utils.formatDateTime(v,d.format),w2utils.formatDate(v,w2utils.settings.dateFormat)):x=w2utils.formatDate(v,d.format),d.colored&&void 0!==d.colored[_]){var $=d.colored[_].split(":");T="background-color: "+$[0]+";",C="color: "+$[1]+";"}p+='<td class="'+(this.inRange(x,!0)?"w2ui-date "+(_==i?"w2ui-date-selected":""):"w2ui-blocked")+b+'"    style="'+C+T+'" date="'+x+'" data-date="'+y+'">'+k+"</td>",(m%7==0||0===u&&1==m)&&(p+="</tr><tr>"),f++}return p+="</tr></tbody></table>"},getYearHTML:function(){for(var e=w2utils.settings.shortmonths,t=w2utils.settings.dateStartYear,i=w2utils.settings.dateEndYear,s="",n="",a=0;a<e.length;a++)s+='<div class="w2ui-jump-month" name="'+a+'">'+e[a]+"</div>";for(var r=t;r<=i;r++)n+='<div class="w2ui-jump-year" name="'+r+'">'+r+"</div>";return'<div id="w2ui-jump-month">'+s+'</div><div id="w2ui-jump-year">'+n+"</div>"},getHourHTML:function(){var e=[],t=this.options;null==t&&(t={format:w2utils.settings.timeFormat});for(var i=-1<t.format.indexOf("h24"),s=0;s<24;s++){var n=(12<=s&&!i?s-12:s)+":00"+(i?"":s<12?" am":" pm");12!=s||i||(n="12:00 pm"),e[Math.floor(s/8)]||(e[Math.floor(s/8)]="");var a=this.fromMin(this.toMin(n)),r=this.fromMin(this.toMin(n)+59);if("datetime"===this.type){var l=w2utils.isDateTime(this.el.value,t.format,!0),o=t.format.split("|")[0].trim();a=w2utils.formatDate(l,o)+" "+a,r=w2utils.formatDate(l,o)+" "+r}e[Math.floor(s/8)]+='<div class="'+(this.inRange(a)||this.inRange(r)?"w2ui-time ":"w2ui-blocked")+'" hour="'+s+'">'+n+"</div>"}return'<div class="w2ui-calendar">   <div class="w2ui-calendar-title">'+w2utils.lang("Select Hour")+'</div>   <div class="w2ui-calendar-time"><table><tbody><tr>       <td>'+e[0]+"</td>       <td>"+e[1]+"</td>       <td>"+e[2]+"</td>   </tr></tbody></table></div></div>"},getMinHTML:function(e){null==e&&(e=0);var t=this.options;null==t&&(t={format:w2utils.settings.timeFormat});for(var i=-1<t.format.indexOf("h24"),s=[],n=0;n<60;n+=5){var a=(12<e&&!i?e-12:e)+":"+(n<10?0:"")+n+" "+(i?"":e<12?"am":"pm"),r=a,l=n<20?0:n<40?1:2;if(s[l]||(s[l]=""),"datetime"===this.type){var o=w2utils.isDateTime(this.el.value,t.format,!0),d=t.format.split("|")[0].trim();r=w2utils.formatDate(o,d)+" "+r}s[l]+='<div class="'+(this.inRange(r)?"w2ui-time ":"w2ui-blocked")+'" min="'+n+'">'+a+"</div>"}return'<div class="w2ui-calendar">   <div class="w2ui-calendar-title">'+w2utils.lang("Select Minute")+'</div>   <div class="w2ui-calendar-time"><table><tbody><tr>       <td>'+s[0]+"</td>       <td>"+s[1]+"</td>       <td>"+s[2]+"</td>   </tr></tbody></table></div></div>"},toMin:function(e){if("string"!=typeof e)return null;var t=e.split(":");return 2!==t.length?null:(t[0]=parseInt(t[0]),t[1]=parseInt(t[1]),-1!==e.indexOf("pm")&&12!==t[0]&&(t[0]+=12),60*t[0]+t[1])},fromMin:function(e){1440<=e&&(e%=1440),e<0&&(e=1440+e);var t=Math.floor(e/60),i=(e%60<10?"0":"")+e%60,s=this.options;return null==s&&(s={format:w2utils.settings.timeFormat}),-1!==s.format.indexOf("h24")?t+":"+i:(t<=12?t:t-12)+":"+i+" "+(12<=t?"pm":"am")}},b.extend(n.prototype,w2utils.event),w2obj.field=n}(jQuery),function($){var w2form=function(e){this.name=null,this.header="",this.box=null,this.url="",this.routeData={},this.formURL="",this.formHTML="",this.page=0,this.recid=0,this.fields=[],this.actions={},this.record={},this.original=null,this.postData={},this.httpHeaders={},this.method=null,this.toolbar={},this.tabs={},this.style="",this.focus=0,this.autosize=!0,this.nestedFields=!0,this.multipart=!1,this.tabindexBase=0,this.isGenerated=!1,this.last={xhr:null,errors:[]},$.extend(!0,this,w2obj.form,e)};$.fn.w2form=function(e){if($.isPlainObject(e)){var t=this;if(!w2utils.checkName(e,"w2form"))return;var i=e.record,s=e.original,n=e.fields,a=e.toolbar,r=e.tabs,l=new w2form(e);if($.extend(l,{record:{},original:null,fields:[],tabs:{},toolbar:{},handlers:[]}),$.isArray(r)){$.extend(!0,l.tabs,{tabs:[]});for(var o=0;o<r.length;o++){var d=r[o];"object"==typeof d?(l.tabs.tabs.push(d),!0===d.active&&(l.tabs.active=d.id)):l.tabs.tabs.push({id:d,text:d})}}else $.extend(!0,l.tabs,r);if($.extend(!0,l.toolbar,a),n)for(var u=0;u<n.length;u++){var c=$.extend(!0,{},n[u]);null==c.field&&null!=c.name&&(console.log("NOTICE: form field.name property is deprecated, please use field.field. Field ->",c),c.field=c.name),l.fields[u]=c}for(var u in i)$.isPlainObject(i[u])?l.record[u]=$.extend(!0,{},i[u]):l.record[u]=i[u];for(var u in s)$.isPlainObject(s[u])?l.original[u]=$.extend(!0,{},s[u]):l.original[u]=s[u];return 0<t.length&&(l.box=t[0]),""!==l.formURL?$.get(l.formURL,function(e){l.formHTML=e,l.isGenerated=!0,0===$(l.box).length&&0===e.length||($(l.box).html(e),l.render(l.box))}):""!==l.formHTML||(0!==$(this).length&&""!==$.trim($(this).html())?l.formHTML=$(this).html():l.formHTML=l.generateHTML()),""===(w2ui[l.name]=l).formURL&&(-1===String(l.formHTML).indexOf("w2ui-page")&&(l.formHTML='<div class="w2ui-page page-0" style="'+(l.pageStyle||"")+'">'+l.formHTML+"</div>"),$(l.box).html(l.formHTML),l.isGenerated=!0,l.render(l.box)),l}return(t=w2ui[$(this).attr("name")])?0<arguments.length?(t[e]&&t[e].apply(t,Array.prototype.slice.call(arguments,1)),this):t:null},w2form.prototype={onRequest:null,onLoad:null,onValidate:null,onSubmit:null,onProgress:null,onSave:null,onChange:null,onInput:null,onRender:null,onRefresh:null,onResize:null,onDestroy:null,onAction:null,onToolbar:null,onError:null,msgNotJSON:"Returned data is not in valid JSON format.",msgAJAXerror:"AJAX error. See console for more details.",msgRefresh:"Loading...",msgSaving:"Saving...",get:function(e,t){if(0===arguments.length){for(var i=[],s=0;s<this.fields.length;s++)null!=this.fields[s].field&&i.push(this.fields[s].field);return i}for(var n=0;n<this.fields.length;n++)if(this.fields[n].field==e)return!0===t?n:this.fields[n];return null},set:function(e,t){for(var i=0;i<this.fields.length;i++)if(this.fields[i].field==e)return $.extend(this.fields[i],t),this.refresh(e),!0;return!1},getValue:function(e){if(this.nestedFields){var t=void 0;try{var i=this.record;t=String(e).split(".").reduce(function(e,t){return e[t]},i)}catch(e){}return t}return this.record[e]},setValue:function(e,s){if(!this.nestedFields)return this.record[e]=s,!0;try{var n=this.record;return String(e).split(".").map(function(e,t,i){i.length-1!==t?n=(n[e]||(n[e]={}),n[e]):n[e]=s}),!0}catch(e){return!1}},show:function(){for(var e=[],t=0;t<arguments.length;t++){var i=this.get(arguments[t]);i&&i.hidden&&(i.hidden=!1,e.push(i.field))}return 0<e.length&&this.refresh.apply(this,e),e.length},hide:function(){for(var e=[],t=0;t<arguments.length;t++){var i=this.get(arguments[t]);i&&!i.hidden&&(i.hidden=!0,e.push(i.field))}return 0<e.length&&this.refresh.apply(this,e),e.length},enable:function(){for(var e=[],t=0;t<arguments.length;t++){var i=this.get(arguments[t]);i&&i.disabled&&(i.disabled=!1,e.push(i.field))}return 0<e.length&&this.refresh.apply(this,e),e.length},disable:function(){for(var e=[],t=0;t<arguments.length;t++){var i=this.get(arguments[t]);i&&!i.disabled&&(i.disabled=!0,e.push(i.field))}return 0<e.length&&this.refresh.apply(this,e),e.length},change:function(){Array.from(arguments).forEach(function(e){var t=this.get(e);t.$el&&t.$el.change()}.bind(this))},reload:function(e){("object"!=typeof this.url?this.url:this.url.get)&&0!==this.recid&&null!=this.recid?this.request(e):"function"==typeof e&&e()},clear:function(){0!=arguments.length?Array.from(arguments).forEach(function(e){var s=this.record;String(e).split(".").map(function(e,t,i){i.length-1!==t?s=s[e]:delete s[e]}),this.refresh(e)}.bind(this)):(this.recid=0,this.record={},this.original=null,this.refresh()),$().w2tag()},error:function(e){var t=this,i=this.trigger({target:this.name,type:"error",message:e,xhr:this.last.xhr});!0!==i.isCancelled?(setTimeout(function(){t.message(e)},1),this.trigger($.extend(i,{phase:"after"}))):"function"==typeof callBack&&callBack()},message:function(e){"string"==typeof e&&(e={width:e.length<300?350:550,height:e.length<300?170:250,body:'<div class="w2ui-centered">'+e+"</div>",buttons:'<button class="w2ui-btn" onclick="w2ui[\''+this.name+"'].message()\">Ok</button>",onOpen:function(e){setTimeout(function(){$(e.box).find(".w2ui-btn").focus()},25)}}),w2utils.message.call(this,{box:this.box,path:"w2ui."+this.name,title:".w2ui-form-header:visible",body:".w2ui-form-box"},e)},validate:function(e){null==e&&(e=!0),$().w2tag();for(var t=[],i=0;i<this.fields.length;i++){var s=this.fields[i];switch(null==this.getValue(s.field)&&this.setValue(s.field,""),s.type){case"int":this.getValue(s.field)&&!w2utils.isInt(this.getValue(s.field))&&t.push({field:s,error:w2utils.lang("Not an integer")});break;case"float":this.getValue(s.field)&&!w2utils.isFloat(this.getValue(s.field))&&t.push({field:s,error:w2utils.lang("Not a float")});break;case"money":this.getValue(s.field)&&!w2utils.isMoney(this.getValue(s.field))&&t.push({field:s,error:w2utils.lang("Not in money format")});break;case"color":case"hex":this.getValue(s.field)&&!w2utils.isHex(this.getValue(s.field))&&t.push({field:s,error:w2utils.lang("Not a hex number")});break;case"email":this.getValue(s.field)&&!w2utils.isEmail(this.getValue(s.field))&&t.push({field:s,error:w2utils.lang("Not a valid email")});break;case"checkbox":1==this.getValue(s.field)?this.setValue(s.field,1):this.setValue(s.field,0);break;case"date":s.options.format||(s.options.format=w2utils.settings.dateFormat),this.getValue(s.field)&&!w2utils.isDate(this.getValue(s.field),s.options.format)&&t.push({field:s,error:w2utils.lang("Not a valid date")+": "+s.options.format})}var n=this.getValue(s.field);s.required&&!0!==s.hidden&&-1==["div","custom","html","empty"].indexOf(s.type)&&(""===n||$.isArray(n)&&0===n.length||$.isPlainObject(n)&&$.isEmptyObject(n))&&t.push({field:s,error:w2utils.lang("Required field")}),s.options&&!0!==s.hidden&&0<s.options.minLength&&-1==["enum","list","combo"].indexOf(s.type)&&this.getValue(s.field).length<s.options.minLength&&t.push({field:s,error:w2utils.lang("Field should be at least "+s.options.minLength+" characters.")})}var a=this.trigger({phase:"before",target:this.name,type:"validate",errors:t});if(!0!==a.isCancelled)return this.last.errors=t,e&&this.showErrors(),this.trigger($.extend(a,{phase:"after"})),t},showErrors:function(){var s=this.last.errors;if(0<s.length){var e=s[0];this.goto(s[0].field.page),$(e.field.$el).parents(".w2ui-field")[0].scrollIntoView(!0);for(var t=0;t<s.length;t++){e=s[t];var i=$.extend({class:"w2ui-error",hideOnFocus:!0},e.options);null!=e.field&&("radio"===e.field.type?$($(e.field.el).closest("div")[0]).w2tag(e.error,i):-1!==["enum","file"].indexOf(e.field.type)?function(t){setTimeout(function(){var e=$(t.field.el).data("w2field").helpers.multi;$(t.field.el).w2tag(t.error,t.options),$(e).addClass("w2ui-error")},1)}(e):$(e.field.el).w2tag(e.error,i))}setTimeout(function(){var i=s[0];$(i.field.$el).parents(".w2ui-page").off(".hideErrors").on("scroll.hideErrors",function(e){for(var t=0;t<s.length;t++)i=s[t],$(i.field.el).w2tag();$(i.field.$el).parents(".w2ui-page").off(".hideErrors")})},300)}},getChanges:function(){var e={};return null==this.original||"object"!=typeof this.original||$.isEmptyObject(this.record)||(e=function e(t,i,s){for(var n in t)"object"==typeof t[n]?(s[n]=e(t[n],i[n]||{},{}),s[n]&&!$.isEmptyObject(s[n])||delete s[n]):t[n]!=i[n]&&(s[n]=t[n]);return s}(this.record,this.original,{})),e},getCleanRecord:function(e){var s=$.extend(!0,{},this.record);return this.fields.forEach(function(e){if(-1!=["list","combo","enum"].indexOf(e.type)){var t={nestedFields:!0,record:s},i=this.getValue.call(t,e.field);$.isPlainObject(i)&&i.id&&this.setValue.call(t,e.field,i.id),Array.isArray(i)&&i.forEach(function(e,t){$.isPlainObject(e)&&e.id&&(i[t]=e.id)})}if("map"==e.type){t={nestedFields:!0,record:s};(i=this.getValue.call(t,e.field))._order&&delete i._order}}.bind(this)),!0===e&&Object.keys(s).forEach(function(e){this.get(e)||delete s[e]}.bind(this)),s},request:function(postData,callBack){var obj=this;if("function"==typeof postData&&(callBack=postData,postData=null),null==postData&&(postData={}),this.url&&("object"!=typeof this.url||this.url.get)){null==this.recid&&(this.recid=0);var params={cmd:"get"};params.recid=this.recid,params.name=this.name,$.extend(params,this.postData),$.extend(params,postData);var edata=this.trigger({phase:"before",type:"request",target:this.name,url:this.url,postData:params,httpHeaders:this.httpHeaders});if(!0!==edata.isCancelled){this.record={},this.original=null,this.lock(w2utils.lang(this.msgRefresh));var url=edata.url;if("object"==typeof edata.url&&edata.url.get&&(url=edata.url.get),this.last.xhr)try{this.last.xhr.abort()}catch(e){}if(!$.isEmptyObject(obj.routeData)){var info=w2utils.parseRoute(url);if(0<info.keys.length)for(var k=0;k<info.keys.length;k++)null!=obj.routeData[info.keys[k].name]&&(url=url.replace(new RegExp(":"+info.keys[k].name,"g"),obj.routeData[info.keys[k].name]))}var ajaxOptions={type:"POST",url:url,data:edata.postData,headers:edata.httpHeaders,dataType:"text"},dataType=obj.dataType||w2utils.settings.dataType;switch(edata.dataType&&(dataType=edata.dataType),dataType){case"HTTP":ajaxOptions.data=String($.param(ajaxOptions.data,!1)).replace(/%5B/g,"[").replace(/%5D/g,"]");break;case"HTTPJSON":ajaxOptions.data={request:JSON.stringify(ajaxOptions.data)};break;case"RESTFULL":ajaxOptions.type="GET",ajaxOptions.data=String($.param(ajaxOptions.data,!1)).replace(/%5B/g,"[").replace(/%5D/g,"]");break;case"RESTFULLJSON":ajaxOptions.type="GET",ajaxOptions.data=JSON.stringify(ajaxOptions.data),ajaxOptions.contentType="application/json";break;case"JSON":ajaxOptions.type="POST",ajaxOptions.data=JSON.stringify(ajaxOptions.data),ajaxOptions.contentType="application/json"}this.method&&(ajaxOptions.type=this.method),edata.method&&(ajaxOptions.type=edata.method),this.last.xhr=$.ajax(ajaxOptions).done(function(data,status,xhr){var data;obj.unlock();var responseText=xhr.responseText;if("error"!==status&&null!=responseText&&""!==responseText){if("object"==typeof responseText)data=responseText;else try{eval("data = "+responseText)}catch(e){}null==data&&(data={status:"error",message:w2utils.lang(obj.msgNotJSON),responseText:responseText})}var edata=obj.trigger({phase:"before",target:obj.name,type:"load",data:data,xhr:xhr});!0!==edata.isCancelled?("error"!==status?"error"===edata.data.status?obj.error(w2utils.lang(edata.data.message)):obj.record=$.extend({},edata.data.record):(obj.error("AJAX Error "+xhr.status+": "+xhr.statusText),edata.data={status:"error",message:w2utils.lang(obj.msgAJAXerror),responseText:responseText}),obj.trigger($.extend(edata,{phase:"after"})),obj.refresh(),obj.applyFocus(),"function"==typeof callBack&&callBack(edata.data)):"function"==typeof callBack&&callBack({status:"error",message:"Request aborted."})}).fail(function(e,t,i){var s={status:t,error:i,rawResponseText:e.responseText},n=obj.trigger({phase:"before",type:"error",error:s,xhr:e});if(!0!==n.isCancelled){if("abort"!==t){var a;try{a=$.parseJSON(e.responseText)}catch(e){}console.log("ERROR: Server communication failed.","\n   EXPECTED:",{status:"success",items:[{id:1,text:"item"}]},"\n         OR:",{status:"error",message:"error message"},"\n   RECEIVED:","object"==typeof a?a:e.responseText),obj.unlock()}obj.trigger($.extend(n,{phase:"after"}))}}),this.trigger($.extend(edata,{phase:"after"}))}else"function"==typeof callBack&&callBack({status:"error",message:"Request aborted."})}},submit:function(e,t){return this.save(e,t)},save:function(postData,callBack){var obj=this;$(this.box).find(":focus").change(),"function"==typeof postData&&(callBack=postData,postData=null);var errors=obj.validate(!0);0===errors.length&&(null==postData&&(postData={}),obj.url&&("object"!=typeof obj.url||obj.url.save)?(obj.lock(w2utils.lang(obj.msgSaving)+' <span id="'+obj.name+'_progress"></span>'),setTimeout(function(){var params={cmd:"save"};params.recid=obj.recid,params.name=obj.name,$.extend(params,obj.postData),$.extend(params,postData),obj.multipart||obj.fields.forEach(function(e){"file"===e.type&&Array.isArray(obj.getValue(e.field))&&obj.getValue(e.field).forEach(function(e){delete e.file})}),params.record=$.extend(!0,{},obj.record);var edata=obj.trigger({phase:"before",type:"submit",target:obj.name,url:obj.url,postData:params,httpHeaders:obj.httpHeaders});if(!0!==edata.isCancelled){var url=edata.url;if("object"==typeof edata.url&&edata.url.save&&(url=edata.url.save),obj.last.xhr)try{obj.last.xhr.abort()}catch(e){}if(!$.isEmptyObject(obj.routeData)){var info=w2utils.parseRoute(url);if(0<info.keys.length)for(var k=0;k<info.keys.length;k++)null!=obj.routeData[info.keys[k].name]&&(url=url.replace(new RegExp(":"+info.keys[k].name,"g"),obj.routeData[info.keys[k].name]))}var ajaxOptions={type:"POST",url:url,data:edata.postData,headers:edata.httpHeaders,dataType:"text",xhr:function(){var e=new window.XMLHttpRequest;return e.upload.addEventListener("progress",function(e){if(e.lengthComputable){var t=obj.trigger({phase:"before",type:"progress",total:e.total,loaded:e.loaded,originalEvent:e});if(!0===t.isCancelled)return;var i=Math.round(e.loaded/e.total*100);(i&&100!=i||""!=$("#"+obj.name+"_progress").text())&&$("#"+obj.name+"_progress").text(i+"%"),obj.trigger($.extend(t,{phase:"after"}))}},!1),e}},dataType=obj.dataType||w2utils.settings.dataType;switch(edata.dataType&&(dataType=edata.dataType),dataType){case"HTTP":ajaxOptions.data=String($.param(ajaxOptions.data,!1)).replace(/%5B/g,"[").replace(/%5D/g,"]");break;case"HTTPJSON":ajaxOptions.data={request:JSON.stringify(ajaxOptions.data)};break;case"RESTFULL":0!==obj.recid&&null!=obj.recid&&(ajaxOptions.type="PUT"),ajaxOptions.data=String($.param(ajaxOptions.data,!1)).replace(/%5B/g,"[").replace(/%5D/g,"]");break;case"RESTFULLJSON":0!==obj.recid&&null!=obj.recid&&(ajaxOptions.type="PUT"),ajaxOptions.data=JSON.stringify(ajaxOptions.data),ajaxOptions.contentType="application/json";break;case"JSON":if(ajaxOptions.type="POST",ajaxOptions.contentType="application/json",obj.multipart){function apend(a,e,t,i){function r(e,t,i){if("object"==typeof e&&e instanceof File&&a.append(i,e),"object"==typeof e)if(e&&e.constructor===Array)for(var s=0;s<e.length;s++){var n=t?t[s]:t;r(e[s],n,i+"["+s+"]")}else apend(a,e,t,i)}for(var s in null==i&&(i=""),e){var n=""==i?s:"${p}[${prop}]",l=t?t[s]:t;r(e[s],l,n)}}var fdata=new FormData;fdata.append("__body",JSON.stringify(ajaxOptions.data)),apend(fdata,ajaxOptions.data),ajaxOptions.data=fdata,ajaxOptions.contentType=!1,ajaxOptions.processData=!1}else ajaxOptions.data=JSON.stringify(ajaxOptions.data)}this.method&&(ajaxOptions.type=this.method),edata.method&&(ajaxOptions.type=edata.method),obj.last.xhr=$.ajax(ajaxOptions).done(function(data,status,xhr){obj.unlock();var edata=obj.trigger({phase:"before",target:obj.name,type:"save",xhr:xhr,status:status,data:data});if(!0!==edata.isCancelled){var data,responseText=xhr.responseText;if("error"!==status){if(null!=responseText&&""!==responseText){if("object"==typeof responseText)data=responseText;else try{eval("data = "+responseText)}catch(e){}null==data&&(data={status:"error",message:w2utils.lang(obj.msgNotJSON),responseText:responseText}),"error"===data.status?obj.error(w2utils.lang(data.message)):obj.original=null}}else obj.error("AJAX Error "+xhr.status+": "+xhr.statusText),data={status:"error",message:w2utils.lang(obj.msgAJAXerror),responseText:responseText};obj.trigger($.extend(edata,{phase:"after"})),obj.refresh(),"function"==typeof callBack&&callBack(data,xhr)}}).fail(function(e,t,i){var s={status:t,error:i,rawResponseText:e.responseText},n=obj.trigger({phase:"before",type:"error",error:s,xhr:e});!0!==n.isCancelled&&(console.log("ERROR: server communication failed. The server should return",{status:"success"},"OR",{status:"error",message:"error message"},", instead the AJAX request produced this: ",s),obj.unlock(),obj.trigger($.extend(n,{phase:"after"})))}),obj.trigger($.extend(edata,{phase:"after"}))}},50)):console.log("ERROR: Form cannot be saved because no url is defined."))},lock:function(e,t){var i=Array.prototype.slice.call(arguments,0);i.unshift(this.box),setTimeout(function(){w2utils.lock.apply(window,i)},10)},unlock:function(e){var t=this.box;setTimeout(function(){w2utils.unlock(t,e)},25)},lockPage:function(e,t){var i=$(this.box).find(".page-"+e);return!!i.length&&(w2utils.lock(i,t),!0)},unlockPage:function(e,t){var i=$(this.box).find(".page-"+e);return!!i.length&&(w2utils.unlock(i,t),!0)},goto:function(e){this.page!==e&&(null!=e&&(this.page=e),!0===$(this.box).data("auto-size")&&$(this.box).height(0),this.refresh())},generateHTML:function(){for(var e,t,i,s,n,a=[],r="",l=0;l<this.fields.length;l++){i="",n=' tabindex="'+(s=this.tabindexBase+l+1)+'"';var o=this.fields[l];null==o.html&&(o.html={}),null==o.options&&(o.options={}),null!=o.html.caption&&null==o.html.label&&(console.log("NOTICE: form field.html.caption property is deprecated, please use field.html.label. Field ->",o),o.html.label=o.html.caption),null==o.html.label&&(o.html.label=o.field),o.html=$.extend(!0,{label:"",span:6,attr:"",text:"",style:"",page:0,column:0},o.html),null==e&&(e=o.html.page),null==t&&(t=o.html.column);var d='<input id="'+o.field+'" name="'+o.field+'" class="w2ui-input" type="text" '+o.html.attr+n+">";switch(o.type){case"pass":case"password":d='<input id="'+o.field+'" name="'+o.field+'" class="w2ui-input" type = "password" '+o.html.attr+n+">";break;case"checkbox":d='<label>   <input id="'+o.field+'" name="'+o.field+'" style="float: left" class="w2ui-input" type="checkbox" '+o.html.attr+n+'>   <div style="margin: 6px 0 0 20px; user-select: none;">'+o.html.label+"</div></label>";break;case"radio":d="";var u=o.options.items?o.options.items:o.html.items;$.isArray(u)||(u=[]),0<u.length&&(u=w2obj.field.prototype.normMenu.call(this,u,o));for(var c=0;c<u.length;c++)d+='<label style="user-select: none">  <input id="'+o.field+'" name="'+o.field+'" class="w2ui-input" type = "radio" '+o.html.attr+(0===c?n:"")+' value="'+u[c].id+'">&#160;'+u[c].text+"</label><br>";break;case"select":d='<select id="'+o.field+'" name="'+o.field+'" class="w2ui-input" '+o.html.attr+n+">";u=o.options.items?o.options.items:o.html.items;$.isArray(u)||(u=[]),0<u.length&&(u=w2obj.field.prototype.normMenu.call(this,u,o));for(c=0;c<u.length;c++)d+='<option value="'+u[c].id+'">'+u[c].text+"</option>";d+="</select>";break;case"textarea":d='<textarea id="'+o.field+'" name="'+o.field+'" class="w2ui-input" '+o.html.attr+n+"></textarea>";break;case"toggle":d='<input id="'+o.field+'" name="'+o.field+'" type="checkbox" '+o.html.attr+n+' class="w2ui-input w2ui-toggle"><div><div></div></div>';break;case"map":case"array":o.html.key=o.html.key||{},o.html.value=o.html.value||{},o.html.tabindex_str=n,d='<span style="float: right">'+(o.html.text||"")+'</span><input id="'+o.field+'" name="'+o.field+'" type="hidden" '+o.html.attr+n+'><div class="w2ui-map-container"></div>';break;case"html":case"div":case"custom":d='<div id="'+o.field+'" name="'+o.field+'" '+o.html.attr+n+">"+(o&&o.html&&o.html.html?o.html.html:"")+"</div>"}if(""!==r&&(e!=o.html.page||t!=o.html.column||o.html.group&&r!=o.html.group)&&(a[e][t]+="\n   </div>",r=""),o.html.group&&r!=o.html.group){var h="";o.html.groupCollapsable&&(h='<span class="w2ui-icon-collapse" style="width: 15px; display: inline-block; position: relative; top: -2px;"></span>'),i+='\n   <div class="w2ui-group-title" '+(""!=h?'data-group="'+w2utils.base64encode(o.html.group)+'"':"")+(""!=h?'style="cursor: pointer"':"")+(""!=h?"onclick=\"w2ui['"+this.name+"'].toggleGroup('"+o.html.group+"')\"":"")+">"+h+o.html.group+'</div>\n   <div class="w2ui-group" style="'+(o.html.groupStyle||"")+'">',r=o.html.group}if(null==o.html.anchor){var p=null!=o.html.span?"w2ui-span"+o.html.span:"";-1==o.html.span&&(p="w2ui-span-none"),i+='\n      <div class="w2ui-field '+p+'" style="'+(o.hidden?"display: none;":"")+o.html.style+'">\n         <label'+("none"==p?' style="display: none"':"")+">"+w2utils.lang("checkbox"!=o.type?o.html.label:o.html.text)+"</label>"+("empty"===o.type?"":"\n         <div>"+d+("array"!=o.type&&"map"!=o.type?w2utils.lang("checkbox"!=o.type?o.html.text:""):"")+"</div>")+"\n      </div>"}else a[o.html.page].anchors=a[o.html.page].anchors||{},a[o.html.page].anchors[o.html.anchor]='<div class="w2ui-field w2ui-field-inline" style="'+(o.hidden?"display: none;":"")+o.html.style+'">'+("empty"===o.type?"":"<div>"+w2utils.lang("checkbox"!=o.type?o.html.label:o.html.text)+d+w2utils.lang("checkbox"!=o.type?o.html.text:"")+"</div>")+"</div>";null==a[o.html.page]&&(a[o.html.page]={}),null==a[o.html.page][o.html.column]&&(a[o.html.page][o.html.column]=""),a[o.html.page][o.html.column]+=i,e=o.html.page,t=o.html.column}if(""!==r&&(a[e][t]+="\n   </div>"),this.tabs.tabs)for(c=0;c<this.tabs.tabs.length;c++)null==a[c]&&(a[c]=[]);var f="";if(!$.isEmptyObject(this.actions)){for(var g in f+='\n<div class="w2ui-buttons">',s=this.tabindexBase+this.fields.length+1,this.actions){var m=this.actions[g],w={text:"",style:"",class:""};$.isPlainObject(m)?(null==m.text&&null!=m.caption&&(console.log("NOTICE: form action.caption property is deprecated, please use action.text. Action ->",m),m.text=m.caption),m.text&&(w.text=m.text),m.style&&(w.style=m.style),m.class&&(w.class=m.class)):(w.text=g,-1!==["save","update","create"].indexOf(g.toLowerCase())?w.class="w2ui-btn-blue":w.class=""),f+='\n    <button name="'+g+'" class="w2ui-btn '+w.class+'" style="'+w.style+'" tabindex="'+s+'">'+w2utils.lang(w.text)+"</button>",s++}f+="\n</div>"}i="";for(var v=0;v<a.length;v++)i+='<div class="w2ui-page page-'+v+'" style="'+(0!==v?"display: none;":"")+this.pageStyle+'">',a[v].before&&(i+=a[v].before),i+='<div class="w2ui-column-container">',Object.keys(a[v]).sort().forEach(function(e,t){e==parseInt(e)&&(i+='<div class="w2ui-column col-'+e+'">'+(a[v][e]||"")+"\n</div>")}),i+="\n</div>",a[v].after&&(i+=a[v].after),i+="\n</div>",a[v].anchors&&Object.keys(a[v].anchors).forEach(function(e,t){i=i.replace(e,a[v].anchors[e])});return i+=f},toggleGroup:function(e,t){var i=$(this.box).find('.w2ui-group-title[data-group="'+w2utils.base64encode(e)+'"]');if("none"==i.next().css("display")&&!0!==t)i.next().slideDown(300),i.next().next().remove(),i.find("span").addClass("w2ui-icon-collapse").removeClass("w2ui-icon-expand");else{i.next().slideUp(300);var s="width: "+i.next().css("width")+";padding-left: "+i.next().css("padding-left")+";padding-right: "+i.next().css("padding-right")+";margin-left: "+i.next().css("margin-left")+";margin-right: "+i.next().css("margin-right")+";";setTimeout(function(){i.next().after('<div style="height: 5px;'+s+'"></div>')},100),i.find("span").addClass("w2ui-icon-expand").removeClass("w2ui-icon-collapse")}},action:function(e,t){var i=this.actions[e],s=i;$.isPlainObject(i)&&i.onClick&&(s=i.onClick);var n=this.trigger({phase:"before",target:e,type:"action",click:s,originalEvent:t});!0!==n.isCancelled&&("function"==typeof s&&s.call(this,t),this.trigger($.extend(n,{phase:"after"})))},resize:function(){var e=this,t=this.trigger({phase:"before",target:this.name,type:"resize"});if(!0!==t.isCancelled){var i=$(this.box).find("> div.w2ui-form-box"),s=$(this.box).find("> div .w2ui-form-header"),n=$(this.box).find("> div .w2ui-form-toolbar"),a=$(this.box).find("> div .w2ui-form-tabs"),r=$(this.box).find("> div .w2ui-page"),l=$(this.box).find("> div .w2ui-page.page-"+this.page),o=$(this.box).find("> div .w2ui-page.page-"+this.page+" > div"),d=$(this.box).find("> div .w2ui-buttons");u(),this.autosize&&(0!==parseInt($(this.box).height())&&!0!==$(this.box).data("auto-size")||($(this.box).height((0<s.length?w2utils.getSize(s,"height"):0)+("object"==typeof this.tabs&&$.isArray(this.tabs.tabs)&&0<this.tabs.tabs.length?w2utils.getSize(a,"height"):0)+("object"==typeof this.toolbar&&$.isArray(this.toolbar.items)&&0<this.toolbar.items.length?w2utils.getSize(n,"height"):0)+(0<r.length?w2utils.getSize(o,"height")+w2utils.getSize(l,"+height")+12:0)+(0<d.length?w2utils.getSize(d,"height"):0)),$(this.box).data("auto-size",!0)),u()),this.toolbar&&this.toolbar.resize&&this.toolbar.resize(),this.tabs&&this.tabs.resize&&this.tabs.resize(),e.trigger($.extend(t,{phase:"after"}))}function u(){i.width($(e.box).width()).height($(e.box).height()),n.css("top",""!==e.header?w2utils.getSize(s,"height"):0),a.css("top",(""!==e.header?w2utils.getSize(s,"height"):0)+("object"==typeof e.toolbar&&$.isArray(e.toolbar.items)&&0<e.toolbar.items.length?w2utils.getSize(n,"height"):0)),r.css("top",(""!==e.header?w2utils.getSize(s,"height"):0)+("object"==typeof e.toolbar&&$.isArray(e.toolbar.items)&&0<e.toolbar.items.length?w2utils.getSize(n,"height")+5:0)+("object"==typeof e.tabs&&$.isArray(e.tabs.tabs)&&0<e.tabs.tabs.length?w2utils.getSize(a,"height")+5:0)),r.css("bottom",0<d.length?w2utils.getSize(d,"height"):0)}},refresh:function(){var e=(new Date).getTime(),u=this;if(this.box&&this.isGenerated&&null!=$(this.box).html()){var t=this.trigger({phase:"before",target:this.name,type:"refresh",page:this.page,field:a,fields:arguments});if(!0!==t.isCancelled){var i=Array.from(this.fields.keys());0<arguments.length?i=Array.from(arguments).map(function(e,t){return"string"!=typeof e&&console.log("ERROR: Arguments in refresh functions should be field names"),this.get(e,!0)}.bind(this)).filter(function(e,t){return null!=e}):($(this.box).find("input, textarea, select").each(function(e,t){var i=null!=$(t).attr("name")?$(t).attr("name"):$(t).attr("id"),s=u.get(i);if(s){var n=$(t).closest(".w2ui-page");if(0<n.length)for(var a=0;a<100;a++)if(n.hasClass("page-"+a)){s.page=a;break}}}),$(this.box).find(".w2ui-page").hide(),$(this.box).find(".w2ui-page.page-"+this.page).show(),$(this.box).find(".w2ui-form-header").html(this.header),"object"==typeof this.tabs&&$.isArray(this.tabs.tabs)&&0<this.tabs.tabs.length?($("#form_"+this.name+"_tabs").show(),this.tabs.active=this.tabs.tabs[this.page].id,this.tabs.refresh()):$("#form_"+this.name+"_tabs").hide(),"object"==typeof this.toolbar&&$.isArray(this.toolbar.items)&&0<this.toolbar.items.length?($("#form_"+this.name+"_toolbar").show(),this.toolbar.refresh()):$("#form_"+this.name+"_toolbar").hide());for(var s=0;s<i.length;s++){if(null==(a=this.fields[i[s]]).name&&null!=a.field&&(a.name=a.field),null==a.field&&null!=a.name&&(a.field=a.name),a.$el=$(this.box).find('[name="'+String(a.name).replace(/\\/g,"\\\\")+'"]'),a.el=a.$el[0],a.el&&(a.el.id=a.name),(m=$(a).data("w2field"))&&m.clear(),$(a.$el).off(".w2form").on("change.w2form",function(e){var t=this.value,i=null!=u.getValue(this.name)?u.getValue(this.name):"",s=u.get(this.name);if(null!=s){if(-1!==["list","enum","file"].indexOf(s.type)&&$(this).data("selected")){var n=$(this).data("selected"),a=u.getValue(this.name);if($.isArray(n)){t=[];for(var r=0;r<n.length;r++)t[r]=$.extend(!0,{},n[r])}if($.isPlainObject(n)&&(t=$.extend(!0,{},n)),$.isArray(a)){i=[];for(r=0;r<a.length;r++)i[r]=$.extend(!0,{},a[r])}$.isPlainObject(a)&&(i=$.extend(!0,{},a))}if(-1!==["toggle","checkbox"].indexOf(s.type)&&(t=!!$(this).prop("checked")&&("on"===$(this).prop("value")||$(this).prop("value"))),-1!==["int","float","percent","money","currency"].indexOf(s.type)&&(t=$(this).data("w2field").clean(t)),t!==i){var l=u.trigger({phase:"before",target:this.name,type:"change",value_new:t,value_previous:i,originalEvent:e});if(!0!==l.isCancelled){var o=this.value;if("select"===this.type&&(o=this.value),"checkbox"===this.type&&(o=!!this.checked),"radio"===this.type&&s.$el.each(function(e,t){t.checked&&(o=t.value)}),-1!==["int","float","percent","money","currency","list","combo","enum","file","toggle"].indexOf(s.type)&&(o=t),-1!==["enum","file"].indexOf(s.type)&&0<o.length){var d=$(s.el).data("w2field").helpers.multi;$(d).removeClass("w2ui-error")}(""===o||null==o||$.isArray(o)&&0===o.length||$.isPlainObject(o)&&$.isEmptyObject(o))&&(o=null),u.setValue(this.name,o),u.trigger($.extend(l,{phase:"after"}))}else $(this).val(u.getValue(this.name))}}}).on("input.w2form",function(e){var t=this.value;"checkbox"==e.target.type&&(t=e.target.checked),null==u.original&&($.isEmptyObject(u.record)?u.original={}:u.original=$.extend(!0,{},u.record));var i=u.trigger({phase:"before",target:this.name,type:"input",value_new:t,originalEvent:e});!0!==i.isCancelled&&u.trigger($.extend(i,{phase:"after"}))}),a.required?$(a.el).parent().parent().addClass("w2ui-required"):$(a.el).parent().parent().removeClass("w2ui-required"),null!=a.disabled){var n=$(a.el);a.disabled?(null==n.data("w2ui-tabIndex")&&n.data("w2ui-tabIndex",n.prop("tabIndex")),$(a.el).prop("readonly",!0).prop("tabindex",-1).closest(".w2ui-field").addClass("w2ui-disabled")):$(a.el).prop("readonly",!1).prop("tabIndex",n.data("w2ui-tabIndex")).closest(".w2ui-field").removeClass("w2ui-disabled")}m=(m=a.el)||$(this.box).find("#"+a.field),a.hidden?$(m).closest(".w2ui-field").hide():$(m).closest(".w2ui-field").show()}$(this.box).find("button, input[type=button]").each(function(e,t){$(t).off("click").on("click",function(e){var t=this.value;this.id&&(t=this.id),this.name&&(t=this.name),u.action(t,e)})});for(s=0;s<i.length;s++){var a=this.fields[i[s]],r=null!=this.getValue(a.name)?this.getValue(a.name):"";if(a.el)switch($(a.el).hasClass("w2ui-input")||$(a.el).addClass("w2ui-input"),a.type=String(a.type).toLowerCase(),a.options||(a.options={}),a.type){case"text":case"textarea":case"email":case"pass":case"password":a.el.value=r;break;case"int":case"float":case"money":case"currency":case"percent":a.el.value=r,$(a.el).w2field($.extend({},a.options,{type:a.type}));break;case"hex":case"alphanumeric":case"color":case"date":case"time":a.el.value=r,$(a.el).w2field($.extend({},a.options,{type:a.type}));break;case"toggle":w2utils.isFloat(r)&&(r=parseFloat(r)),$(a.el).prop("checked",!!r),this.setValue(a.name,r||!1);break;case"list":case"combo":if("list"===a.type){var l=$.isPlainObject(r)?r.id:$.isPlainObject(a.options.selected)?a.options.selected.id:r;a.options.items||(a.options.items=[]),"function"==typeof(f=a.options.items)&&(f=f());var o=!1;if(Array.isArray(f))for(var d=0;d<f.length;d++){var c=f[d];if(c.id==l){r=$.extend(!0,{},c),u.setValue(a.name,r),o=!0;break}}o||null==r||""===r||a.$el.data("find_selected",r)}else"combo"!==a.type||$.isPlainObject(r)?$.isPlainObject(r)&&null!=r.text?a.el.value=r.text:a.el.value="":a.el.value=r;$.isPlainObject(r)||(r={}),$(a.el).w2field($.extend({},a.options,{type:a.type,selected:r}));break;case"enum":case"file":var h=[];o=!1;$.isArray(r)||(r=[]),"function"!=typeof a.options.items&&($.isArray(a.options.items)||(a.options.items=[]),r.forEach(function(t){a.options.items.forEach(function(e){e&&(e.id==t||$.isPlainObject(t)&&e.id==t.id)&&(h.push($.isPlainObject(e)?$.extend(!0,{},e):e),o=!0)})})),o||null==r||0===r.length||(a.$el.data("find_selected",r),h=r);var p=$.extend({},a.options,{type:a.type,selected:h});Object.keys(a.options).forEach(function(e){"function"==typeof a.options[e]&&(p[e]=a.options[e])}),$(a.el).w2field(p);break;case"select":var f;if(null!=(f=a.options.items)&&0<f.length){f=w2obj.field.prototype.normMenu.call(this,f,a),$(a.el).html("");for(var g=0;g<f.length;g++)$(a.el).append('<option value="'+f[g].id+'">'+f[g].text+"</option")}$(a.el).val(r);break;case"map":case"array":"map"!=a.type||null!=r&&$.isPlainObject(r)||(this.setValue(a.field,{}),r=this.getValue(a.field)),"array"!=a.type||null!=r&&Array.isArray(r)||(this.setValue(a.field,[]),r=this.getValue(a.field)),function(f,g){g.el.mapAdd=function(e,t,i){var s=(e.disabled?" readOnly ":"")+(e.html.tabindex_str||""),n='<div class="w2ui-map-field" style="margin-bottom: 5px"><input id="'+e.field+"_key_"+i+'" data-cnt="'+i+'" type="text" '+e.html.key.attr+s+' class="w2ui-input w2ui-map key">'+(e.html.key.text||"")+'<input id="'+e.field+"_value_"+i+'" data-cnt="'+i+'" type="text" '+e.html.value.attr+s+' class="w2ui-input w2ui-map value">'+(e.html.value.text||"")+"</div>";t.append(n)},g.el.mapRefresh=function(h,p){var e,s,n,a=1;"map"==g.type&&($.isPlainObject(h)||(h={}),null==h._order&&(h._order=Object.keys(h)),e=h._order),"array"==g.type&&(Array.isArray(h)||(h=[]),e=h.map(function(e){return e.key})),e.forEach(function(t){s=p.find("#"+w2utils.escapeId(g.name)+"_key_"+a),n=p.find("#"+w2utils.escapeId(g.name)+"_value_"+a),0!=s.length&&0!=n.length||(g.el.mapAdd(g,p,a),s=p.find("#"+w2utils.escapeId(g.name)+"_key_"+a),n=p.find("#"+w2utils.escapeId(g.name)+"_value_"+a));var e=h[t];if("array"==g.type){var i=h.filter(function(e){return e.key==t});0<i.length&&(e=i[0].value)}s.val(t),n.val(e),!0!==g.disabled&&!1!==g.disabled||(s.prop("readOnly",!!g.disabled),n.prop("readOnly",!!g.disabled)),s.parents(".w2ui-map-field").attr("data-key",t),a++});var t=p.find("#"+w2utils.escapeId(g.name)+"_key_"+a).parent(),i=p.find("#"+w2utils.escapeId(g.name)+"_key_"+(a+1)).parent();0!==t.length||s&&(!0===s.prop("readOnly")||!0===s.prop("disabled"))||g.el.mapAdd(g,p,a),1==t.length&&1==i.length&&(t.removeAttr("data-key"),t.find(".key").val(i.find(".key").val()),t.find(".value").val(i.find(".value").val()),i.remove()),!0!==g.disabled&&!1!==g.disabled||(t.find(".key").prop("readOnly",!!g.disabled),t.find(".value").prop("readOnly",!!g.disabled)),$(g.el).next().find("input.w2ui-map").off(".mapChange").on("keyup.mapChange",function(e){var t=$(e.target).parents(".w2ui-map-field");13==e.keyCode&&t.next().find("input.key").focus()}).on("change.mapChange",function(){var e=$(event.target).parents(".w2ui-map-field"),i=e.attr("data-key"),t=e.find(".key").val(),s=e.find(".value").val(),n={},a={},r=null,l=null;n[t]=s,"array"==g.type&&(h.forEach(function(e,t){e.key==i&&(l=t)}),r=h[l]),null!=i&&"map"==g.type&&(a[i]=h[i]),null!=i&&"array"==g.type&&(a[i]=r.value);var o=f.trigger({phase:"before",target:g.field,type:"change",originalEvent:event,value_new:n,value_previous:a});if(!0!==o.isCancelled){if("map"==g.type){delete h[i];var d=h._order.indexOf(i);if(""!=t){if(null!=h[t]){for(var u,c=0;u=t+ ++c,null!=h[u];);t=u,e.find(".key").val(u)}h[t]=s,e.attr("data-key",t),-1!=d?h._order[d]=t:h._order.push(t)}else h._order.splice(d,1),e.find(".value").val("")}else"array"==g.type&&(""!=t?null==r?h.push({key:t,value:s}):(r.key=t,r.value=s):h.splice(l,1));f.setValue(g.field,h),g.el.mapRefresh(h,p),f.trigger($.extend(o,{phase:"after"}))}})},g.el.mapRefresh(r,$(g.el).parent().find(".w2ui-map-container"))}(this,a);break;case"radio":$(a.$el).prop("checked",!1).each(function(e,t){$(t).val()==r&&$(t).prop("checked",!0)});break;case"checkbox":$(a.el).prop("checked",!!r),!0!==a.disabled&&!1!==a.disabled||$(a.el).prop("disabled",!!a.disabled);break;case"div":case"custom":$(a.el).html(r);break;case"html":case"empty":break;default:$(a.el).val(r),$(a.el).w2field($.extend({},a.options,{type:a.type}))}}var m=$(this.box).find(".w2ui-page");for(d=0;d<m.length;d++)1<$(m[d]).find("> *").length&&$(m[d]).wrapInner("<div></div>");return this.trigger($.extend(t,{phase:"after"})),this.resize(),(new Date).getTime()-e}}},render:function(e){var t=(new Date).getTime(),i=this;if("object"==typeof e&&(0<$(this.box).find("#form_"+this.name+"_tabs").length&&$(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-form").html(""),this.box=e),this.isGenerated&&this.box){var s=this.trigger({phase:"before",target:this.name,type:"render",box:null!=e?e:this.box});if(!0!==s.isCancelled){var n='<div class="w2ui-form-box">'+(""!==this.header?'<div class="w2ui-form-header">'+this.header+"</div>":"")+'    <div id="form_'+this.name+'_toolbar" class="w2ui-form-toolbar" style="display: none"></div>    <div id="form_'+this.name+'_tabs" class="w2ui-form-tabs" style="display: none"></div>'+this.formHTML+"</div>";return $(this.box).attr("name",this.name).addClass("w2ui-reset w2ui-form").html(n),0<$(this.box).length&&($(this.box)[0].style.cssText+=this.style),"function"!=typeof this.toolbar.render&&(this.toolbar=$().w2toolbar($.extend({},this.toolbar,{name:this.name+"_toolbar",owner:this})),this.toolbar.on("click",function(e){var t=i.trigger({phase:"before",type:"toolbar",target:e.target,originalEvent:e});!0!==t.isCancelled&&i.trigger($.extend(t,{phase:"after"}))})),"object"==typeof this.toolbar&&"function"==typeof this.toolbar.render&&this.toolbar.render($("#form_"+this.name+"_toolbar")[0]),"function"!=typeof this.tabs.render&&(this.tabs=$().w2tabs($.extend({},this.tabs,{name:this.name+"_tabs",owner:this,active:this.tabs.active})),this.tabs.on("click",function(e){i.goto(this.get(e.target,!0))})),"object"==typeof this.tabs&&"function"==typeof this.tabs.render&&(this.tabs.render($("#form_"+this.name+"_tabs")[0]),this.tabs.active&&this.tabs.click(this.tabs.active)),this.trigger($.extend(s,{phase:"after"})),this.resize(),("object"!=typeof this.url?this.url:this.url.get)&&0!==this.recid&&null!=this.recid?this.request():this.refresh(),0===$(".w2ui-layout").length&&(this.tmp_resize=function(e){null==w2ui[i.name]?$(window).off("resize.w2uiResize",i.tmp_resize):w2ui[i.name].resize()},$(window).off("resize.w2uiResize").on("resize.w2uiResize",i.tmp_resize)),-1!=this.focus&&setTimeout(function(){0===$(i.box).find("input, select, textarea").length?setTimeout(focusEl,500):i.applyFocus()},50),(new Date).getTime()-t}}},applyFocus:function(){for(var e=this.focus,t=$(this.box).find("div:not(.w2ui-field-helper) > input, select, textarea, div > label:nth-child(1) > :radio").not(".file-input");$(t[e]).is(":hidden")&&t.length>=e;)e++;t[e]&&t[e].focus()},destroy:function(){var e=this.trigger({phase:"before",target:this.name,type:"destroy"});!0!==e.isCancelled&&("object"==typeof this.toolbar&&this.toolbar.destroy&&this.toolbar.destroy(),"object"==typeof this.tabs&&this.tabs.destroy&&this.tabs.destroy(),0<$(this.box).find("#form_"+this.name+"_tabs").length&&$(this.box).removeAttr("name").removeClass("w2ui-reset w2ui-form").html(""),delete w2ui[this.name],this.trigger($.extend(e,{phase:"after"})),$(window).off("resize","body"))}},$.extend(w2form.prototype,w2utils.event),w2obj.form=w2form}(jQuery),function(e,t){if("function"==typeof define&&define.amd)return define(function(){return t});if("undefined"!=typeof exports){if("undefined"!=typeof module&&module.exports)return exports=module.exports=t;e=exports}for(var i in t)e[i]=t[i]}(this,{w2ui:w2ui,w2obj:w2obj,w2utils:w2utils,w2popup:w2popup,w2alert:w2alert,w2confirm:w2confirm,w2prompt:w2prompt});",
{"status":false}
],

[
"w2ui.min.css_1.5",
"/* w2ui 1.5.x (nightly) (c) http://w2ui.com, vitmalina@gmail.com */
@font-face {
  font-family: "w2ui-font";
  src: url("data:application/x-font-woff;charset=utf-8;base64,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") format("woff");
  font-weight: normal;
  font-style: normal;
}
[class^="w2ui-icon-"]:before,
[class*=" w2ui-icon-"]:before {
  font-family: "w2ui-font";
  display: inline-block;
  vertical-align: middle;
  line-height: 1;
  font-weight: normal;
  font-style: normal;
  speak: none;
  text-decoration: inherit;
  text-transform: none;
  text-rendering: optimizeLegibility;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
}
/* Icons */
.w2ui-icon-check:before {
  content: "\f101";
}
.w2ui-icon-colors:before {
  content: "\f102";
}
.w2ui-icon-columns:before {
  content: "\f103";
}
.w2ui-icon-cross:before {
  content: "\f104";
}
.w2ui-icon-empty:before {
  content: "\f105";
}
.w2ui-icon-info:before {
  content: "\f106";
}
.w2ui-icon-pencil:before {
  content: "\f107";
}
.w2ui-icon-plus:before {
  content: "\f108";
}
.w2ui-icon-reload:before {
  content: "\f109";
}
.w2ui-icon-search:before {
  content: "\f10a";
}
.w2ui-icon-settings:before {
  content: "\f10b";
}
/*************************************************
* --- Reset (used for all w2ui widgets)
* --- The reset is needed to coexist with other CSS
* --- on the same page (for example bootstrap)
*/
.w2ui-reset {
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
  font-family: Verdana, Arial, sans-serif;
  font-size: 11px;
}
.w2ui-reset * {
  color: default;
  line-height: 100%;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
  margin: 0px;
  padding: 0px;
}
.w2ui-reset table {
  max-width: none;
  background-color: transparent;
  border-collapse: separate;
  border-spacing: 0;
  border: none;
}
.w2ui-reset table tr th,
.w2ui-reset table tr td {
  font-family: Verdana, Arial, sans-serif;
  font-size: 11px;
}
.w2ui-reset input:not([type=button]):not([type=submit]):not([type=checkbox]):not([type=radio]),
.w2ui-reset select,
.w2ui-reset textarea {
  display: inline-block;
  width: auto;
  height: auto;
  vertical-align: baseline;
  padding: 4px;
  margin: 0;
  font-size: 11px;
}
.w2ui-reset select {
  padding: 1px;
  height: 23px;
  font-size: 11px;
}
.w2ui-centered {
  position: absolute;
  left: 0px;
  right: 0px;
  top: 50%;
  -webkit-transform: translateY(-50%);
  -moz-transform: translateY(-50%);
  -ms-transform: translateY(-50%);
  -o-transform: translateY(-50%);
  transform: translateY(-50%);
  max-height: 100%;
  margin: 0px;
  padding: 0px 10px;
  text-align: center;
}
.w2ui-disabled,
.w2ui-readonly {
  background-color: #f1f1f1 !important;
  color: #777 !important;
  outline: none!important;
}
.w2ui-message {
  font-size: 12px;
  position: absolute;
  z-index: 250;
  background-color: #F9F9F9;
  border: 1px solid #999;
  box-shadow: 0px 0px 15px #aaa;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
  border-top: 0px;
  border-radius: 0px 0px 6px 6px;
  overflow: auto;
}
.w2ui-message .w2ui-message-body {
  position: absolute;
  top: 0px;
  bottom: 45px;
  left: 0px;
  right: 0px;
  overflow: auto;
  line-height: 1.5;
  font-size: 14px;
}
.w2ui-message .w2ui-message-body .w2ui-centered {
  line-height: 1.5;
}
.w2ui-message .w2ui-message-buttons {
  position: absolute;
  height: 45px;
  bottom: 0px;
  left: 0px;
  right: 0px;
  border-top: 1px solid #e5e5e5;
  text-align: center;
  padding: 8px;
}
/*************************************************
* ---- Input Controls ----
*/
div.w2ui-input:focus {
  outline-color: #72B2FF;
}
input:not([type=button]):not([type=submit]).w2ui-input,
textarea.w2ui-input {
  padding: 4px;
  border: 1px solid #cacaca;
  border-radius: 3px;
  color: black;
  background-color: white;
  line-height: normal;
}
input:not([type=button]):not([type=submit]).w2ui-input:focus,
textarea.w2ui-input:focus {
  outline-color: #72B2FF;
}
input:not([type=button]):not([type=submit]).w2ui-input:disabled,
textarea.w2ui-input:disabled,
input:not([type=button]):not([type=submit]).w2ui-input[readonly],
textarea.w2ui-input[readonly] {
  background-color: #f1f1f1;
  color: #777;
  outline: none!important;
}
/* IE9-11 specific classes */
/* needs doblue :: */
input.w2ui-input::-ms-clear {
  display: none;
}
input.w2ui-input:-ms-input-placeholder {
  color: #aaa !important;
}
select.w2ui-input {
  color: black;
  padding: 0px 15px 0px 7px;
  line-height: 1.8;
  border-radius: 3px;
  border: 1px solid #cacaca;
  -webkit-appearance: none;
  background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAALCAQAAACnzwd+AAAAcklEQVR4AcXMsQFBQQDG4P9tAgC0gJYRQJZgKQMwCqCku6vVAAAA+NJHP4KHOk0aV2pRw61n4BBmyOxKQ8I4ehZeuhd3HTx6DQEGZ7sBfr2OOOOj3Yi43kMKs9sZknofOexqZ8npMygwWZTX51CipP+YA1OiZJbYYg9lAAAAAElFTkSuQmCC'), -webkit-linear-gradient(to bottom, #FFF 20%, #f6f6f6 50%, #EEE 52%, #f4f4f4 100%);
  background-size: 17px 6px, 100% 100%;
  background-position: right center, left top;
  background-repeat: no-repeat, no-repeat;
}
.w2ui-icon-expand:before {
  position: relative;
  top: 1px;
  left: 1px;
  content: ' ';
  width: 5px;
  height: 5px;
  border: 2px solid rgba(150, 150, 150, 0.8);
  border-bottom: 0;
  border-left: 0;
  transform: rotateZ(45deg);
}
.w2ui-icon-collapse:before {
  position: relative;
  top: -1px;
  left: 3px;
  content: ' ';
  width: 5px;
  height: 5px;
  border: 2px solid rgba(150, 150, 150, 0.8);
  border-bottom: 0;
  border-left: 0;
  transform: rotateZ(135deg);
}
/* On/Off switch */
input[type="checkbox"].w2ui-toggle {
  position: absolute;
  opacity: 0;
  width: 46px;
  height: 22px;
  padding: 0px;
  margin: 0px;
  margin-left: 2px;
  /* Knob */
  /* Green */
  /* Default Blue */
}
input[type="checkbox"].w2ui-toggle:focus {
  box-shadow: 0px 0px 1px 2px #a8cfff;
}
input[type="checkbox"].w2ui-toggle + div {
  display: inline-block;
  width: 46px;
  height: 22px;
  border: 1px solid #bbb;
  border-radius: 30px;
  background-color: #eee;
  -webkit-transition-duration: 0.3s;
  -webkit-transition-property: background-color, box-shadow;
  -moz-transition-duration: 0.3s;
  -moz-transition-property: background-color, box-shadow;
  box-shadow: inset 0 0 0 0px rgba(0, 0, 0, 0.4);
  margin-left: 2px;
}
input[type="checkbox"].w2ui-toggle.w2ui-small + div {
  width: 30px;
  height: 16px;
}
input[type="checkbox"].w2ui-toggle:focus + div {
  box-shadow: 0px 0px 3px 2px #91baed;
}
input[type="checkbox"].w2ui-toggle:disabled + div {
  opacity: 0.3;
}
input[type="checkbox"].w2ui-toggle + div > div {
  float: left;
  width: 22px;
  height: 22px;
  border-radius: inherit;
  background: #f5f5f5;
  -webkit-transition-duration: 0.3s;
  -webkit-transition-property: transform, background-color, box-shadow;
  -moz-transition-duration: 0.3s;
  -moz-transition-property: transform, background-color;
  box-shadow: 0px 0px 1px #323232, 0 0 0 1px rgba(200, 200, 200, 0.6);
  pointer-events: none;
  margin-top: -1px;
  margin-left: -1px;
}
input[type="checkbox"].w2ui-toggle.w2ui-small + div > div {
  width: 16px;
  height: 16px;
}
input[type="checkbox"].w2ui-toggle:checked + div > div {
  -webkit-transform: translate3d(24px, 0, 0);
  -moz-transform: translate3d(24px, 0, 0);
  background-color: #ffffff;
}
input[type="checkbox"].w2ui-toggle.w2ui-small:checked + div > div {
  -webkit-transform: translate3d(14px, 0, 0);
  -moz-transform: translate3d(14px, 0, 0);
}
input[type="checkbox"].w2ui-toggle:focus {
  outline: none;
}
input[type="checkbox"].w2ui-toggle:checked + div {
  border: 1px solid #00a23f;
  box-shadow: inset 0 0 0 12px #54B350;
}
input[type="checkbox"].w2ui-toggle:checked:focus + div {
  box-shadow: 0px 0px 3px 2px #91baed, inset 0 0 0 12px #54B350;
}
input[type="checkbox"].w2ui-toggle:checked + div > div {
  box-shadow: 0px 2px 5px rgba(0, 0, 0, 0.3), 0 0 0 1px #00a23f;
}
input[type="checkbox"].w2ui-toggle.blue:checked + div {
  border: 1px solid #206FAD;
  box-shadow: inset 0 0 0 12px #35A6EB;
}
input[type="checkbox"].w2ui-toggle.blue:checked:focus + div {
  box-shadow: 0px 0px 3px 2px #91baed, inset 0 0 0 12px #35A6EB;
}
input[type="checkbox"].w2ui-toggle.blue:checked + div > div {
  box-shadow: 0px 2px 5px rgba(0, 0, 0, 0.3), 0px 0px 0 1px #206FAD;
}
/*************************************************
* ---- Overlay and Bubble ----
*/
.w2ui-overlay {
  position: absolute;
  margin-top: 4px;
  margin-left: -17px;
  display: none;
  z-index: 1300;
  color: inherit;
  background-color: #FbFbFb;
  border-color: #FbFbFb;
  box-shadow: 0px 2px 10px #999;
  border-radius: 4px;
  text-align: left;
}
.w2ui-overlay > div {
  border-radius: 4px;
  position: relative;
  border: 3px solid #777;
}
.w2ui-overlay table td {
  color: inherit;
}
.w2ui-overlay:before {
  content: "";
  position: absolute;
  border-color: inherit;
}
.w2ui-overlay:after {
  content: "";
  position: absolute;
  border-color: inherit;
  bottom: 100%;
  left: 4px;
}
.w2ui-overlay.top-arrow:before {
  border-bottom: 12px solid #6f6f6f;
  border-right: 12px solid transparent;
  border-left: 12px solid transparent;
  bottom: 100%;
  margin-bottom: -3px;
}
.w2ui-overlay.top-arrow:after {
  border-bottom: 8px solid black;
  border-bottom-color: inherit;
  border-right: 8px solid transparent;
  border-left: 8px solid transparent;
  bottom: 100%;
  margin-bottom: -3px;
}
.w2ui-overlay.bottom-arrow:before {
  border-top: 12px solid #6f6f6f;
  border-right: 12px solid transparent;
  border-left: 12px solid transparent;
  top: 100%;
  margin-top: -3px;
}
.w2ui-overlay.bottom-arrow:after {
  border-top: 8px solid black;
  border-top-color: inherit;
  border-right: 8px solid transparent;
  border-left: 8px solid transparent;
  top: 100%;
  margin-top: -3px;
}
.w2ui-overlay.w2ui-overlay-popup {
  z-index: 1700;
}
.w2ui-overlay .w2ui-grid-searches {
  border-top: 3px solid #777 !important;
}
.w2ui-overlay .no-color {
  border: 1px solid #eee;
  background: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAABlBMVEX/////TgCFoIUYAAAAGUlEQVR42uXHIQEAAACDsNO/NJ4Kn9uC8wsJkAARUrXAjwAAAABJRU5ErkJggg==');
  background-size: 15px 15px;
}
.w2ui-tag {
  position: absolute;
  z-index: 1300;
  opacity: 0;
  -webkit-transition: opacity 0.3s;
  -moz-transition: opacity 0.3s;
  -ms-transition: opacity 0.3s;
  -o-transition: opacity 0.3s;
  transition: opacity 0.3s;
}
.w2ui-tag .w2ui-tag-body {
  box-sizing: border-box;
  display: inline-block;
  position: absolute;
  border-radius: 3px;
  padding: 6px 10px;
  margin-left: 10px;
  margin-top: 0px;
  background-color: rgba(60, 60, 60, 0.9);
  color: white !important;
  font-size: 11px;
  font-family: verdana;
  text-shadow: 1px 1px 3px #000;
  line-height: 1.4;
  letter-spacing: 0.1px;
}
.w2ui-tag .w2ui-tag-body.w2ui-tag-right:before {
  content: "";
  position: absolute;
  width: 0;
  height: 0;
  border-top: 6px solid transparent;
  border-right: 6px solid rgba(60, 60, 60, 0.9);
  border-bottom: 6px solid transparent;
  margin: 0px 0 0 -16px;
}
.w2ui-tag .w2ui-tag-body.w2ui-tag-left:after {
  content: "";
  position: absolute;
  top: 5px;
  width: 0;
  height: 0;
  border-top: 6px solid transparent;
  border-left: 6px solid rgba(60, 60, 60, 0.9);
  border-bottom: 6px solid transparent;
  margin: 0px 0 0 10px;
}
.w2ui-tag .w2ui-tag-body.w2ui-tag-bottom:before {
  content: "";
  position: absolute;
  width: 0;
  height: 0;
  border-right: 6px solid transparent;
  border-left: 6px solid transparent;
  border-bottom: 6px solid rgba(60, 60, 60, 0.9);
  margin: -12px 0 0 2px;
}
.w2ui-tag .w2ui-tag-body.w2ui-tag-top:after {
  content: "";
  position: absolute;
  left: 12px;
  bottom: -6px;
  width: 0;
  height: 0;
  border-right: 6px solid transparent;
  border-left: 6px solid transparent;
  border-top: 6px solid rgba(60, 60, 60, 0.9);
}
.w2ui-tag.w2ui-tag-popup {
  z-index: 1700;
}
/*
*    Drop down menu
*/
.w2ui-menu {
  position: absolute;
  top: 0px;
  bottom: 0px;
}
.w2ui-menu table {
  font-family: verdana;
  font-size: 11px;
  width: 100%;
  color: black;
  background-color: white;
  padding: 5px 0px;
  cursor: default;
}
.w2ui-menu table td {
  white-space: nowrap;
}
.w2ui-menu table.sub-menu {
  top: 0;
  background-color: #fafdff;
  border-top: 1px dotted #cccccc;
  border-bottom: 1px dotted #cccccc;
}
.w2ui-menu table.sub-menu td:first-child {
  padding-left: 10px;
}
.w2ui-menu table.sub-menu td.menu-divider {
  padding-left: 16px;
}
.w2ui-menu table .w2ui-item-even {
  color: inherit;
  background-color: #FFF;
}
.w2ui-menu table .w2ui-item-odd {
  color: inherit;
  background-color: #F3F6FA;
}
.w2ui-menu table .w2ui-item-group {
  color: #444;
  font-weight: bold;
  background-color: #ECEDF0;
  border-bottom: 1px solid #D3D2D4;
}
.w2ui-menu table td.menu-icon {
  padding: 3px 0px 4px 6px;
  width: 20px;
}
.w2ui-menu table td.menu-icon > span {
  height: 20px;
  width: 18px;
}
.w2ui-menu table td.menu-divider {
  padding: 6px;
  pointer-events: none;
}
.w2ui-menu table td.menu-divider div.line {
  border-top: 1px solid silver;
  color: transparent;
  height: 0px;
  padding: 0px 25px 0 0px;
}
.w2ui-menu table td.menu-divider.divider-text {
  padding: 12px 6px;
}
.w2ui-menu table td.menu-divider.divider-text div.text {
  display: block;
  position: absolute;
  margin-top: -6px;
  margin-left: 46%;
  background-color: white;
  padding: 0px 3px;
  color: darkgrey;
  transform: translateX(-50%);
}
.w2ui-menu table td.menu-text {
  padding: 8px 10px 8px 5px;
  width: auto;
}
.w2ui-menu table td.menu-count {
  text-align: right;
  padding-right: 1px;
}
.w2ui-menu table td.menu-count > span {
  border: 1px solid #F6FCF4;
  border-radius: 20px;
  width: auto;
  height: 18px;
  padding: 2px 7px;
  margin: 3px 5px 0px 5px;
  background-color: #F2F8F0;
  color: #666;
  box-shadow: 0px 0px 2px #474545;
  text-shadow: 1px 1px 0px #FFF;
}
.w2ui-menu table td.menu-count > span.hotkey {
  border: none;
  border-radius: 0px;
  background-color: transparent !important;
  color: #888;
  box-shadow: none;
  text-shadow: none;
}
.w2ui-menu table td.menu-count > span.remove {
  border-color: transparent;
  background-color: transparent;
  box-shadow: none;
  padding: 2px 5px;
}
.w2ui-menu table td.menu-count > span.remove:hover {
  color: #982525;
  border-color: #d28d5b;
  background-color: #f9e7e7;
}
.w2ui-menu table tr.expanded td.menu-count > span,
.w2ui-menu table tr.collapsed td.menu-count > span {
  border-color: transparent;
  background-color: transparent;
  box-shadow: none;
  padding: 2px 5px;
  border-radius: 0px;
}
.w2ui-menu table tr.expanded td.menu-count > span:after,
.w2ui-menu table tr.collapsed td.menu-count > span:after {
  content: "";
  position: absolute;
  border-left: 5px solid #808080;
  border-top: 5px solid transparent;
  border-bottom: 5px solid transparent;
  transform: rotateZ(-90deg);
  pointer-events: none;
  margin-left: -2px;
}
.w2ui-menu table tr.expanded td.menu-count > span:hover,
.w2ui-menu table tr.collapsed td.menu-count > span:hover {
  border-color: transparent;
  background-color: transparent;
}
.w2ui-menu table tr.collapsed td.menu-count span:after {
  transform: rotateZ(90deg);
}
.w2ui-menu table tr:hover {
  color: inherit;
  background-color: #E6F0FF;
}
.w2ui-menu table tr.w2ui-selected {
  background-color: #B6D5FB;
}
.w2ui-menu table tr.w2ui-selected td {
  color: inherit;
}
.w2ui-menu table tr.w2ui-disabled {
  opacity: 0.4;
  background-color: white !important;
}
.w2ui-menu table .w2ui-icon {
  font-size: 14px;
  color: #8D99A7;
  display: inline-block;
  padding-top: 4px;
}
.w2ui-menu-inline {
  padding: 0;
  margin: 0;
}
.w2ui-menu-inline .w2ui-menu {
  position: static;
}
.w2ui-menu-inline .w2ui-menu > table {
  padding: 0px;
}
.w2ui-menu-inline .w2ui-menu table td.menu-icon,
.w2ui-menu-inline .w2ui-menu table td.menu-text {
  padding: 1px 1px 1px 5px;
}
/*************************************************
* ---- Common Classes ----
*/
.w2ui-marker {
  color: #444;
  background-color: rgba(252, 244, 161, 0.48);
}
.w2ui-spinner {
  display: inline-block;
  background-size: 100%;
  background-repeat: no-repeat;
  background-image: url(data:image/gif;base64,R0lGODlhgACAAKIAAP///93d3bu7u5mZmQAA/wAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFBQAEACwCAAIAfAB8AAAD/0i63P4wygYqmDjrzbtflvWNZGliYXiubKuloivPLlzReD7al+7/Eh5wSFQIi8hHYBkwHUmD6CD5YTJLz49USuVYraRsZ7vtar7XnQ1Kjpoz6LRHvGlz35O4nEPP2O94EnpNc2sef1OBGIOFMId/inB6jSmPdpGScR19EoiYmZobnBCIiZ95k6KGGp6ni4wvqxilrqBfqo6skLW2YBmjDa28r6Eosp27w8Rov8ekycqoqUHODrTRvXsQwArC2NLF29UM19/LtxO5yJd4Au4CK7DUNxPebG4e7+8n8iv2WmQ66BtoYpo/dvfacBjIkITBE9DGlMvAsOIIZjIUAixliv9ixYZVtLUos5GjwI8gzc3iCGghypQqrbFsme8lwZgLZtIcYfNmTJ34WPTUZw5oRxdD9w0z6iOpO15MgTh1BTTJUKos39jE+o/KS64IFVmsFfYT0aU7capdy7at27dw48qdS7eu3bt480I02vUbX2F/JxYNDImw4GiGE/P9qbhxVpWOI/eFKtlNZbWXuzlmG1mv58+gQ4seTbq06dOoU6vGQZJy0FNlMcV+czhQ7SQmYd8eMhPs5BxVdfcGEtV3buDBXQ+fURxx8oM6MT9P+Fh6dOrH2zavc13u9JXVJb520Vp8dvC76wXMuN5Sepm/1WtkEZHDefnzR9Qvsd9+/wi8+en3X0ntYVcSdAE+UN4zs7ln24CaLagghIxBaGF8kFGoIYV+Ybghh841GIyI5ICIFoklJsigihmimJOLEbLYIYwxSgigiZ+8l2KB+Ml4oo/w8dijjcrouCORKwIpnJIjMnkkksalNeR4fuBIm5UEYImhIlsGCeWNNJphpJdSTlkml1jWeOY6TnaRpppUctcmFW9mGSaZceYopH9zkjnjUe59iR5pdapWaGqHopboaYua1qije67GJ6CuJAAAIfkEBQUABAAsCgACAFcAMAAAA/9Iutz+ML5Ag7w46z0r5WAoSp43nihXVmnrdusrv+s332dt4Tyo9yOBUJD6oQBIQGs4RBlHySSKyczVTtHoidocPUNZaZAr9F5FYbGI3PWdQWn1mi36buLKFJvojsHjLnshdhl4L4IqbxqGh4gahBJ4eY1kiX6LgDN7fBmQEJI4jhieD4yhdJ2KkZk8oiSqEaatqBekDLKztBG2CqBACq4wJRi4PZu1sA2+v8C6EJexrBAD1AOBzsLE0g/V1UvYR9sN3eR6lTLi4+TlY1wz6Qzr8u1t6FkY8vNzZTxaGfn6mAkEGFDgL4LrDDJDyE4hEIbdHB6ESE1iD4oVLfLAqPETIsOODwmCDJlv5MSGJklaS6khAQAh+QQFBQAEACwfAAIAVwAwAAAD/0i63P5LSAGrvTjrNuf+YKh1nWieIumhbFupkivPBEzR+GnnfLj3ooFwwPqdAshAazhEGUXJJIrJ1MGOUamJ2jQ9QVltkCv0XqFh5IncBX01afGYnDqD40u2z76JK/N0bnxweC5sRB9vF34zh4gjg4uMjXobihWTlJUZlw9+fzSHlpGYhTminKSepqebF50NmTyor6qxrLO0L7YLn0ALuhCwCrJAjrUqkrjGrsIkGMW/BMEPJcphLgDaABjUKNEh29vdgTLLIOLpF80s5xrp8ORVONgi8PcZ8zlRJvf40tL8/QPYQ+BAgjgMxkPIQ6E6hgkdjoNIQ+JEijMsasNY0RQix4gKP+YIKXKkwJIFF6JMudFEAgAh+QQFBQAEACw8AAIAQgBCAAAD/kg0PPowykmrna3dzXvNmSeOFqiRaGoyaTuujitv8Gx/661HtSv8gt2jlwIChYtc0XjcEUnMpu4pikpv1I71astytkGh9wJGJk3QrXlcKa+VWjeSPZHP4Rtw+I2OW81DeBZ2fCB+UYCBfWRqiQp0CnqOj4J1jZOQkpOUIYx/m4oxg5cuAaYBO4Qop6c6pKusrDevIrG2rkwptrupXB67vKAbwMHCFcTFxhLIt8oUzLHOE9Cy0hHUrdbX2KjaENzey9Dh08jkz8Tnx83q66bt8PHy8/T19vf4+fr6AP3+/wADAjQmsKDBf6AOKjS4aaHDgZMeSgTQcKLDhBYPEswoA1BBAgAh+QQFBQAEACxOAAoAMABXAAAD7Ei6vPOjyUkrhdDqfXHm4OZ9YSmNpKmiqVqykbuysgvX5o2HcLxzup8oKLQQix0UcqhcVo5ORi+aHFEn02sDeuWqBGCBkbYLh5/NmnldxajX7LbPBK+PH7K6narfO/t+SIBwfINmUYaHf4lghYyOhlqJWgqDlAuAlwyBmpVnnaChoqOkpaanqKmqKgGtrq+wsbA1srW2ry63urasu764Jr/CAb3Du7nGt7TJsqvOz9DR0tPU1TIA2ACl2dyi3N/aneDf4uPklObj6OngWuzt7u/d8fLY9PXr9eFX+vv8+PnYlUsXiqC3c6PmUUgAACH5BAUFAAQALE4AHwAwAFcAAAPpSLrc/m7IAau9bU7MO9GgJ0ZgOI5leoqpumKt+1axPJO1dtO5vuM9yi8TlAyBvSMxqES2mo8cFFKb8kzWqzDL7Xq/4LB4TC6bz1yBes1uu9uzt3zOXtHv8xN+Dx/x/wJ6gHt2g3Rxhm9oi4yNjo+QkZKTCgGWAWaXmmOanZhgnp2goaJdpKGmp55cqqusrZuvsJays6mzn1m4uRAAvgAvuBW/v8GwvcTFxqfIycA3zA/OytCl0tPPO7HD2GLYvt7dYd/ZX99j5+Pi6tPh6+bvXuTuzujxXens9fr7YPn+7egRI9PPHrgpCQAAIfkEBQUABAAsPAA8AEIAQgAAA/lIutz+UI1Jq7026h2x/xUncmD5jehjrlnqSmz8vrE8u7V5z/m5/8CgcEgsGo/IpHLJbDqf0Kh0ShBYBdTXdZsdbb/Yrgb8FUfIYLMDTVYz2G13FV6Wz+lX+x0fdvPzdn9WeoJGAYcBN39EiIiKeEONjTt0kZKHQGyWl4mZdREAoQAcnJhBXBqioqSlT6qqG6WmTK+rsa1NtaGsuEu6o7yXubojsrTEIsa+yMm9SL8osp3PzM2cStDRykfZ2tfUtS/bRd3ewtzV5pLo4eLjQuUp70Hx8t9E9eqO5Oku5/ztdkxi90qPg3x2EMpR6IahGocPCxp8AGtigwQAIfkEBQUABAAsHwBOAFcAMAAAA/9Iutz+MMo36pg4682J/V0ojs1nXmSqSqe5vrDXunEdzq2ta3i+/5DeCUh0CGnF5BGULC4tTeUTFQVONYAs4CfoCkZPjFar83rBx8l4XDObSUL1Ott2d1U4yZwcs5/xSBB7dBMBhgEYfncrTBGDW4WHhomKUY+QEZKSE4qLRY8YmoeUfkmXoaKInJ2fgxmpqqulQKCvqRqsP7WooriVO7u8mhu5NacasMTFMMHCm8qzzM2RvdDRK9PUwxzLKdnaz9y/Kt8SyR3dIuXmtyHpHMcd5+jvWK4i8/TXHff47SLjQvQLkU+fG29rUhQ06IkEG4X/Rryp4mwUxSgLL/7IqFETB8eONT6ChCFy5ItqJomES6kgAQAh+QQFBQAEACwKAE4AVwAwAAAD/0i63A4QuEmrvTi3yLX/4MeNUmieITmibEuppCu3sDrfYG3jPKbHveDktxIaF8TOcZmMLI9NyBPanFKJp4A2IBx4B5lkdqvtfb8+HYpMxp3Pl1qLvXW/vWkli16/3dFxTi58ZRcChwIYf3hWBIRchoiHiotWj5AVkpIXi4xLjxiaiJR/T5ehoomcnZ+EGamqq6VGoK+pGqxCtaiiuJVBu7yaHrk4pxqwxMUzwcKbyrPMzZG90NGDrh/JH8t72dq3IN1jfCHb3L/e5ebh4ukmxyDn6O8g08jt7tf26ybz+m/W9GNXzUQ9fm1Q/APoSWAhhfkMAmpEbRhFKwsvCsmosRIHx444PoKcIXKkjIImjTzjkQAAIfkEBQUABAAsAgA8AEIAQgAAA/VIBNz+8KlJq72Yxs1d/uDVjVxogmQqnaylvkArT7A63/V47/m2/8CgcEgsGo/IpHLJbDqf0Kh0Sj0FroGqDMvVmrjgrDcTBo8v5fCZki6vCW33Oq4+0832O/at3+f7fICBdzsChgJGeoWHhkV0P4yMRG1BkYeOeECWl5hXQ5uNIAOjA1KgiKKko1CnqBmqqk+nIbCkTq20taVNs7m1vKAnurtLvb6wTMbHsUq4wrrFwSzDzcrLtknW16tI2tvERt6pv0fi48jh5h/U6Zs77EXSN/BE8jP09ZFA+PmhP/xvJgAMSGBgQINvEK5ReIZhQ3QEMTBLAAAh+QQFBQAEACwCAB8AMABXAAAD50i6DA4syklre87qTbHn4OaNYSmNqKmiqVqyrcvBsazRpH3jmC7yD98OCBF2iEXjBKmsAJsWHDQKmw571l8my+16v+CweEwum8+hgHrNbrvbtrd8znbR73MVfg838f8BeoB7doN0cYZvaIuMjY6PkJGSk2gClgJml5pjmp2YYJ6dX6GeXaShWaeoVqqlU62ir7CXqbOWrLafsrNctjIDwAMWvC7BwRWtNsbGFKc+y8fNsTrQ0dK3QtXAYtrCYd3eYN3c49/a5NVj5eLn5u3s6e7x8NDo9fbL+Mzy9/T5+tvUzdN3Zp+GBAAh+QQJBQAEACwCAAIAfAB8AAAD/0i63P4wykmrvTjrzbv/YCiOZGmeaKqubOu+cCzPdArcQK2TOL7/nl4PSMwIfcUk5YhUOh3M5nNKiOaoWCuWqt1Ou16l9RpOgsvEMdocXbOZ7nQ7DjzTaeq7zq6P5fszfIASAYUBIYKDDoaGIImKC4ySH3OQEJKYHZWWi5iZG0ecEZ6eHEOio6SfqCaqpaytrpOwJLKztCO2jLi1uoW8Ir6/wCHCxMG2x7muysukzb230M6H09bX2Nna29zd3t/g4cAC5OXm5+jn3Ons7eba7vHt2fL16tj2+QL0+vXw/e7WAUwnrqDBgwgTKlzIsKHDh2gGSBwAccHEixAvaqTYcFCjRoYeNyoM6REhyZIHT4o0qPIjy5YTTcKUmHImx5cwE85cmJPnSYckK66sSAAj0aNIkypdyrSp06dQo0qdSrWq1atYs2rdyrWr169gwxZJAAA7);
}
/* common icons */
.w2ui-icon {
  background-repeat: no-repeat;
  height: 16px;
  width: 16px;
  overflow: hidden;
  margin: 2px 2px;
  display: inline-block;
}
.w2ui-icon.icon-search,
.w2ui-icon.icon-search-down {
  background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACYAAAAgCAYAAAB+ZAqzAAACuElEQVRYw9WXSWhTQRjHR0UKLqhFaV0OUih68GAOWjyJKypCpAoV8aIiioIICiKiB1GMtE3MYmry2moXDz1UDx7sUXHBhQpSaRVxrYpWcMO9avx/8AJh/CbznHkxdeB3Cd/8589kvuUJkWcdjCTHghUgAi6DJ+AVeAqugSQIggniXywcNBJsB70g44EHYBcYXUhTM8EFj4ZkboKqQpiqAv2GprK8o7/f75t6pjn0M3gNPmri3vtycxAZA64qDvkJ2kENqAQTQQWoBg74qth3B4y3NbZDIX4fzNfsnQtuK/YfsjFVCh4pMq3Co0Y5uMVoUGkpy8aFT5xaeSzVEo45bXdBt4LeaLq1k0RXMYJfdDfFmAuAD4zWlty4UNyZEkm19MUb2zMw8Sfp1u+IWSrcIimLnTG8/SijdU6OO5poDESdtgHZVBzUHm/amhW7zoitMTS2mNHqASPk2FDCCcLMYK6p+obmulyxfiYLA4bGKFvfSnrUvkq5+Lpk8z4yRH8r3l/X4WiqJFfspSQ0CGYZGpsMnkt6L+h31Z76hpMdeOwPQ7H0NFnssST0C8wxNDaDKb6kP06150gsHahNNlVzYheZd7HJ0BiX4VRGhpmIhRixKyZilM2M1mnTArtIUbU3/qVO0H0GvmQ4CY4C3YopYYlHjXlggNG4R33Ypi2tVtwaPeTdNMkq9pVQZQdvFPs32zbx4aAjzxhDRfIAWAeWg7VgrzsY5ht/zoNJtubKwA3LITGjSKRyW3NTwaUCmKOSMd3WHH0ZJRQZZkOP1zFKZ3CB++4+aQ6kEeksWAb2a2L7qDv49S1Q6T72MOgEXa6RGFhP3wpS/B6NOWpRs0UxFg7eqTFHjX1hscxtAz/ymEuIYi0cvgF8Y0w5Ro3dZ3M1boJkTaXEUFlug6fsdsRQWzTj0cey+N/Xb2sj5lTh2M6OAAAAAElFTkSuQmCC) no-repeat center !important;
  background-size: 14px 12px !important;
  opacity: 0.9;
}
.w2ui-icon.icon-folder {
  background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAGrSURBVDjLxZO7ihRBFIa/6u0ZW7GHBUV0UQQTZzd3QdhMQxOfwMRXEANBMNQX0MzAzFAwEzHwARbNFDdwEd31Mj3X7a6uOr9BtzNjYjKBJ6nicP7v3KqcJFaxhBVtZUAK8OHlld2st7Xl3DJPVONP+zEUV4HqL5UDYHr5xvuQAjgl/Qs7TzvOOVAjxjlC+ePSwe6DfbVegLVuT4r14eTr6zvA8xSAoBLzx6pvj4l+DZIezuVkG9fY2H7YRQIMZIBwycmzH1/s3F8AapfIPNF3kQk7+kw9PWBy+IZOdg5Ug3mkAATy/t0usovzGeCUWTjCz0B+Sj0ekfdvkZ3abBv+U4GaCtJ1iEm6ANQJ6fEzrG/engcKw/wXQvEKxSEKQxRGKE7Izt+DSiwBJMUSm71rguMYhQKrBygOIRStf4TiFFRBvbRGKiQLWP29yRSHKBTtfdBmHs0BUpgvtgF4yRFR+NUKi0XZcYjCeCG2smkzLAHkbRBmP0/Uk26O5YnUActBp1GsAI+S5nRJJJal5K1aAMrq0d6Tm9uI6zjyf75dAe6tx/SsWeD//o2/Ab6IH3/h25pOAAAAAElFTkSuQmCC) no-repeat center !important;
}
.w2ui-icon.icon-page {
  background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAINSURBVBgZBcG/r55zGAfg6/4+z3va01NHlYgzEfE7MdCIGISFgS4Gk8ViYyM2Mdlsko4GSf8Do0FLRCIkghhYJA3aVBtEz3nP89wf11VJvPDepdd390+8Nso5nESBQoq0pfvXm9fzWf19453LF85vASqJlz748vInb517dIw6EyYBIIG49u+xi9/c9MdvR//99MPPZ7+4cP4IZhhTPbwzT2d+vGoaVRRp1rRliVvHq+cfvM3TD82+7mun0o/ceO7NT+/4/KOXjwZU1ekk0840bAZzMQ2mooqh0A72d5x/6sB9D5zYnff3PoYBoWBgFKPKqDKqjCpjKr//dcu9p489dra88cydps30KswACfNEKanSaxhlntjJ8Mv12Paie+vZ+0+oeSwwQ0Iw1xAR1CiFNJkGO4wu3ZMY1AAzBI0qSgmCNJsJUEOtJSMaCTBDLyQ0CknAGOgyTyFFiLI2awMzdEcSQgSAAKVUmAeNkxvWJWCGtVlDmgYQ0GFtgg4pNtOwbBcwQy/Rife/2yrRRVI0qYCEBly8Z+P4qMEMy7JaVw72N568e+iwhrXoECQkfH91kY7jwwXMsBx1L93ZruqrK6uuiAIdSnTIKKPLPFcvay8ww/Hh+ufeznTXu49v95IMoQG3784gYXdTqvRmqn/Wpa/ADFX58MW3L71SVU9ETgEIQQQIOOzub+fhIvwPRDgeVjWDahIAAAAASUVORK5CYII=) no-repeat center !important;
}
/*************************************************
* ---- Locking portion of the screen (in grid, form, layout)
*/
.w2ui-lock {
  display: none;
  position: absolute;
  z-index: 1400;
  top: 0px;
  left: 0px;
  width: 100%;
  height: 100%;
  opacity: 0.15;
  filter: alpha(opacity=15);
  background-color: #333;
}
.w2ui-lock-msg {
  display: none;
  position: absolute;
  z-index: 1400;
  top: 45%;
  left: 50%;
  -webkit-transform: translateX(-50%) translateY(-50%);
  -moz-transform: translateX(-50%) translateY(-50%);
  -ms-transform: translateX(-50%) translateY(-50%);
  -o-transform: translateX(-50%) translateY(-50%);
  transform: translateX(-50%) translateY(-50%);
  width: 200px;
  height: 80px;
  padding: 30px 8px;
  white-space: nowrap;
  text-overflow: ellipsis;
  overflow: hidden;
  font-size: 13px;
  font-family: Verdana, Arial, sans-serif;
  opacity: 0.8;
  filter: alpha(opacity=80);
  background-color: #555;
  color: white;
  text-align: center;
  border-radius: 5px;
  border: 2px solid #444;
}
.w2ui-lock-msg .w2ui-spinner {
  display: inline-block;
  width: 24px;
  height: 24px;
  margin: -3px 8px -7px -10px;
}
/*************************************************
* ---- Scroll contet, used in toolbar and tabs ----
*/
.w2ui-scroll-wrapper {
  overflow: hidden;
}
.w2ui-scroll-left,
.w2ui-scroll-right {
  top: 0;
  width: 18px;
  height: 100%;
  cursor: default !important;
  z-index: 10;
  display: none;
  position: absolute;
}
.w2ui-scroll-left:hover,
.w2ui-scroll-right:hover {
  background-color: #ddd;
}
.w2ui-scroll-left {
  left: 0;
  box-shadow: 0px 0px 7px #5F5F5F;
  background: #F7F7F7 url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAQAAADZc7J/AAAAzklEQVR4Ae2THRDEMBCFzy1ucatb3eJ2uhi3uNUtbnGrW9zi1rOdNzdvdl7nDpvYt/9/r7+/51myZZf/zXkD2iMHHRSb0x3oskwMieK05PwEXqP4ExSL0wp0ROao2OOuMPOMdUL6XU1/oGLcFWb+NqyTd2W/P/2qTr9h+nFXhOkHXRHiNyjrgp/U/V+WaQcaNY13zZI0A1JvcVqAnrGDTdtDtZUHjHIJhxxVLN0iqXgCP1l/7h8U9kc6abyJ4/eNWPpGdBv+XdUK0K8cnvcBly2rDr7C1HQAAAAASUVORK5CYII=') center center no-repeat;
  background-size: 15px 12px;
}
.w2ui-scroll-right {
  right: 0;
  box-shadow: 0px 0px 7px #5F5F5F;
  background: #F7F7F7 url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAQAAADZc7J/AAAAz0lEQVR4Ae2UG7TGMBCEr1vd4la3uMUtuli3utWtbnGLW9zi9l/bDMzJG7u12cfJfLunf1+UEC9Bv0vVQwJ8hjRCaZafflb1C9RQf4OD0gSDE+i+PiJAabFhQc1y1AYYsJGLY3lgxM17uWPO56yPiFDqVPWgRtpIHSd1zPnwkBsdI58OlNwx4fP2X0TgfMTOoHSdKOXkpyNvEyQh7ul+4swxJSTQuwNDxz68l/ukVNbu0Neen5Z+KvzWxBAqHds349uPFJ/jVOrPjxUq++OLf+20q5+noXo0AAAAAElFTkSuQmCC') center center no-repeat;
  background-size: 15px 13px;
}
button.w2ui-btn {
  position: relative;
  display: inline-block;
  border-radius: 4px;
  margin: 0px 5px;
  padding: 6px 12px;
  color: #666;
  font-size: 12px;
  border: 1px solid #B6B6B6;
  background-image: -webkit-linear-gradient(#FFF 0%, #E7E7E7 100%);
  background-image: -moz-linear-gradient(#FFF 0%, #E7E7E7 100%);
  background-image: -ms-linear-gradient(#FFF 0%, #E7E7E7 100%);
  background-image: -o-linear-gradient(#FFF 0%, #E7E7E7 100%);
  background-image: linear-gradient(#FFF 0%, #E7E7E7 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffe7e7e7', endColorstr='#ffffffff', GradientType=0);
  outline: none;
  box-shadow: 0px 1px 0px white;
  cursor: default;
  min-width: 75px;
  line-height: 110%;
  user-select: none;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  -o-user-select: none;
  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
}
button.w2ui-btn:hover {
  text-decoration: none;
  border: 1px solid #bbb;
  background-image: -webkit-linear-gradient(#F7F7F7 0%, #DDDDDD 100%);
  background-image: -moz-linear-gradient(#F7F7F7 0%, #DDDDDD 100%);
  background-image: -ms-linear-gradient(#F7F7F7 0%, #DDDDDD 100%);
  background-image: -o-linear-gradient(#F7F7F7 0%, #DDDDDD 100%);
  background-image: linear-gradient(#F7F7F7 0%, #DDDDDD 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffdddddd', endColorstr='#fff7f7f7', GradientType=0);
  color: #333;
}
button.w2ui-btn:active,
button.w2ui-btn.clicked {
  border: 1px solid #999;
  background-image: -webkit-linear-gradient(#ccc 0%, #ccc 100%);
  background-image: -moz-linear-gradient(#ccc 0%, #ccc 100%);
  background-image: -ms-linear-gradient(#ccc 0%, #ccc 100%);
  background-image: -o-linear-gradient(#ccc 0%, #ccc 100%);
  background-image: linear-gradient(#ccc 0%, #ccc 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffcccccc', endColorstr='#ffcccccc', GradientType=0);
  text-shadow: 1px 1px 1px #eee;
}
button.w2ui-btn:disabled {
  border: 1px solid #bbb !important;
  background: #f7f7f7 !important;
  color: #bdbcbc !important;
  text-shadow: none !important;
}
button.w2ui-btn:focus:before {
  content: "";
  border: 1px dashed #aaa;
  border-radius: 3px;
  position: absolute;
  top: 2px;
  bottom: 2px;
  left: 2px;
  right: 2px;
  pointer-events: none;
}
button.w2ui-btn::-moz-focus-inner {
  border: 0;
}
button.w2ui-btn-blue {
  color: white;
  background-image: -webkit-linear-gradient(#80C0F7 0%, #269DF0 100%);
  background-image: -moz-linear-gradient(#80C0F7 0%, #269DF0 100%);
  background-image: -ms-linear-gradient(#80C0F7 0%, #269DF0 100%);
  background-image: -o-linear-gradient(#80C0F7 0%, #269DF0 100%);
  background-image: linear-gradient(#80C0F7 0%, #269DF0 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff269df0', endColorstr='#ff80c0f7', GradientType=0);
  border: 1px solid #538AB7;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-blue:hover {
  color: white;
  background-image: -webkit-linear-gradient(#73B6F0 0%, #2391DD 100%);
  background-image: -moz-linear-gradient(#73B6F0 0%, #2391DD 100%);
  background-image: -ms-linear-gradient(#73B6F0 0%, #2391DD 100%);
  background-image: -o-linear-gradient(#73B6F0 0%, #2391DD 100%);
  background-image: linear-gradient(#73B6F0 0%, #2391DD 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff2391dd', endColorstr='#ff73b6f0', GradientType=0);
  border: 1px solid #497BA3;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-blue:active,
button.w2ui-btn-blue.clicked {
  color: white;
  background-image: -webkit-linear-gradient(#1E83C9 0%, #1E83C9 100%);
  background-image: -moz-linear-gradient(#1E83C9 0%, #1E83C9 100%);
  background-image: -ms-linear-gradient(#1E83C9 0%, #1E83C9 100%);
  background-image: -o-linear-gradient(#1E83C9 0%, #1E83C9 100%);
  background-image: linear-gradient(#1E83C9 0%, #1E83C9 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff1e83c9', endColorstr='#ff1e83c9', GradientType=0);
  border: 1px solid #1268A6;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-blue:focus:before {
  border: 1px dashed #e8e8e8;
}
button.w2ui-btn-green {
  color: white;
  background-image: -webkit-linear-gradient(#81CF81 0%, #52A452 100%);
  background-image: -moz-linear-gradient(#81CF81 0%, #52A452 100%);
  background-image: -ms-linear-gradient(#81CF81 0%, #52A452 100%);
  background-image: -o-linear-gradient(#81CF81 0%, #52A452 100%);
  background-image: linear-gradient(#81CF81 0%, #52A452 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff52a452', endColorstr='#ff81cf81', GradientType=0);
  border: 1px solid #479247;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-green:hover {
  color: white;
  background-image: -webkit-linear-gradient(#6ABE68 0%, #3F8F3D 100%);
  background-image: -moz-linear-gradient(#6ABE68 0%, #3F8F3D 100%);
  background-image: -ms-linear-gradient(#6ABE68 0%, #3F8F3D 100%);
  background-image: -o-linear-gradient(#6ABE68 0%, #3F8F3D 100%);
  background-image: linear-gradient(#6ABE68 0%, #3F8F3D 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff3f8f3d', endColorstr='#ff6abe68', GradientType=0);
  border: 1px solid #479247;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-green:active,
button.w2ui-btn-green.clicked {
  color: white;
  background-image: -webkit-linear-gradient(#377D36 0%, #377D36 100%);
  background-image: -moz-linear-gradient(#377D36 0%, #377D36 100%);
  background-image: -ms-linear-gradient(#377D36 0%, #377D36 100%);
  background-image: -o-linear-gradient(#377D36 0%, #377D36 100%);
  background-image: linear-gradient(#377D36 0%, #377D36 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff377d36', endColorstr='#ff377d36', GradientType=0);
  border: 1px solid #555 !important;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-green:focus:before {
  border: 1px dashed #e8e8e8;
}
button.w2ui-btn-orange {
  color: white;
  background-image: -webkit-linear-gradient(#FCC272 0%, #FB8822 100%);
  background-image: -moz-linear-gradient(#FCC272 0%, #FB8822 100%);
  background-image: -ms-linear-gradient(#FCC272 0%, #FB8822 100%);
  background-image: -o-linear-gradient(#FCC272 0%, #FB8822 100%);
  background-image: linear-gradient(#FCC272 0%, #FB8822 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fffb8822', endColorstr='#fffcc272', GradientType=0);
  border: 1px solid #B68B4C;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-orange:hover {
  color: white;
  background-image: -webkit-linear-gradient(#F4AD59 0%, #F1731F 100%);
  background-image: -moz-linear-gradient(#F4AD59 0%, #F1731F 100%);
  background-image: -ms-linear-gradient(#F4AD59 0%, #F1731F 100%);
  background-image: -o-linear-gradient(#F4AD59 0%, #F1731F 100%);
  background-image: linear-gradient(#F4AD59 0%, #F1731F 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fff1731f', endColorstr='#fff4ad59', GradientType=0);
  border: 1px solid #B68B4C;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-orange:active,
button.w2ui-btn-orange.clicked {
  color: white;
  border: 1px solid #666;
  background-image: -webkit-linear-gradient(#B98747 0%, #B98747 100%);
  background-image: -moz-linear-gradient(#B98747 0%, #B98747 100%);
  background-image: -ms-linear-gradient(#B98747 0%, #B98747 100%);
  background-image: -o-linear-gradient(#B98747 0%, #B98747 100%);
  background-image: linear-gradient(#B98747 0%, #B98747 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffb98747', endColorstr='#ffb98747', GradientType=0);
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-orange:focus:before {
  border: 1px dashed #f9f9f9;
}
button.w2ui-btn-red {
  color: white;
  background-image: -webkit-linear-gradient(#FF6E70 0%, #C72D2D 100%);
  background-image: -moz-linear-gradient(#FF6E70 0%, #C72D2D 100%);
  background-image: -ms-linear-gradient(#FF6E70 0%, #C72D2D 100%);
  background-image: -o-linear-gradient(#FF6E70 0%, #C72D2D 100%);
  background-image: linear-gradient(#FF6E70 0%, #C72D2D 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffc72d2d', endColorstr='#ffff6e70', GradientType=0);
  border: 1px solid #BB3C3E;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-red:hover {
  color: white;
  background-image: -webkit-linear-gradient(#EE696C 0%, #AE2527 100%);
  background-image: -moz-linear-gradient(#EE696C 0%, #AE2527 100%);
  background-image: -ms-linear-gradient(#EE696C 0%, #AE2527 100%);
  background-image: -o-linear-gradient(#EE696C 0%, #AE2527 100%);
  background-image: linear-gradient(#EE696C 0%, #AE2527 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffae2527', endColorstr='#ffee696c', GradientType=0);
  border: 1px solid #BB3C3E;
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-red:active,
button.w2ui-btn-red.clicked {
  color: white;
  border: 1px solid #861C1E;
  background-image: -webkit-linear-gradient(#9C2123 0%, #9C2123 100%);
  background-image: -moz-linear-gradient(#9C2123 0%, #9C2123 100%);
  background-image: -ms-linear-gradient(#9C2123 0%, #9C2123 100%);
  background-image: -o-linear-gradient(#9C2123 0%, #9C2123 100%);
  background-image: linear-gradient(#9C2123 0%, #9C2123 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff9c2123', endColorstr='#ff9c2123', GradientType=0);
  text-shadow: 0px 0px 1px #111;
}
button.w2ui-btn-red:focus:before {
  border: 1px dashed #ddd;
}
button.w2ui-btn-small {
  padding: 5px !important;
  margin: 0px;
  min-width: 0px;
}
button.w2ui-btn-small:focus:before {
  border-radius: 2px;
  top: 2px;
  bottom: 2px;
  left: 2px;
  right: 2px;
}
/*************************************************
* ---- Forms ----
*/
.w2ui-form {
  position: relative;
  color: black;
  background-color: #F2F2F2;
  border: 1px solid #c0c0c0;
  border-radius: 3px;
  padding: 0px;
  overflow: hidden !important;
}
.w2ui-form > div {
  position: absolute;
  overflow: hidden;
}
.w2ui-form .w2ui-form-header {
  position: absolute;
  left: 0;
  right: 0;
  border-bottom: 1px solid #99bbe8 !important;
  overflow: hidden;
  color: #444;
  font-size: 13px;
  text-align: center;
  padding: 8px;
  background-image: -webkit-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -moz-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -ms-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -o-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: linear-gradient(#DAE6F3, #C2D5ED);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffdae6f3', endColorstr='#ffc2d5ed', GradientType=0);
  border-top-left-radius: 3px;
  border-top-right-radius: 3px;
}
.w2ui-form .w2ui-form-toolbar {
  position: absolute;
  left: 0px;
  right: 0px;
  margin: 0px;
  padding: 5px 3px;
  border-bottom: 1px solid #d5d8d8;
}
.w2ui-form .w2ui-form-tabs {
  margin: 0px;
  padding: 0px;
}
.w2ui-form .w2ui-tabs {
  position: absolute;
  left: 0;
  right: 0;
  border-top-left-radius: 3px;
  border-top-right-radius: 3px;
  padding-top: 5px !important;
  background-color: #fafafa;
}
.w2ui-form .w2ui-tabs .w2ui-tab.active {
  background-color: #F2F2F2;
}
.w2ui-form .w2ui-page {
  position: absolute;
  left: 0;
  right: 0;
  overflow: auto;
  padding: 10px 5px 0 5px;
  border-left: 1px solid inherit;
  border-right: 1px solid inherit;
  background-color: inherit;
  border-radius: 3px;
}
.w2ui-form .w2ui-column-container {
  display: flex;
  padding: 0;
}
.w2ui-form .w2ui-column-container .w2ui-column {
  width: 100%;
}
.w2ui-form .w2ui-column-container .w2ui-column.col-0,
.w2ui-form .w2ui-column-container .w2ui-column.col-1,
.w2ui-form .w2ui-column-container .w2ui-column.col-2,
.w2ui-form .w2ui-column-container .w2ui-column.col-3,
.w2ui-form .w2ui-column-container .w2ui-column.col-4,
.w2ui-form .w2ui-column-container .w2ui-column.col-5,
.w2ui-form .w2ui-column-container .w2ui-column.col-6,
.w2ui-form .w2ui-column-container .w2ui-column.col-7,
.w2ui-form .w2ui-column-container .w2ui-column.col-8,
.w2ui-form .w2ui-column-container .w2ui-column.col-9,
.w2ui-form .w2ui-column-container .w2ui-column.col-10 {
  margin: 0 5px;
}
.w2ui-form .w2ui-buttons {
  position: absolute;
  left: 0;
  right: 0;
  bottom: 0;
  text-align: center;
  border-top: 1px solid #d5d8d8;
  border-bottom: 0px solid #d5d8d8;
  background-color: #fafafa;
  padding: 15px 0px !important;
  border-bottom-left-radius: 3px;
  border-bottom-right-radius: 3px;
}
.w2ui-form .w2ui-buttons input[type="button"],
.w2ui-form .w2ui-buttons button {
  min-width: 80px;
  margin-right: 5px;
}
.w2ui-form input[type=checkbox],
.w2ui-form input[type=radio] {
  margin-top: 4px;
  margin-bottom: 4px;
  width: 14px;
  height: 14px;
}
.w2ui-form input[type=checkbox].w2ui-toggle {
  margin: 0px;
  width: 50px;
}
.w2ui-group-title {
  padding: 5px 2px;
  color: #8D96A2;
  text-shadow: 1px 1px 2px #fdfdfd;
  font-size: 120%;
}
.w2ui-group {
  background-color: #F9F9F9;
  margin: 5px 0px 10px 0px;
  padding: 10px 5px;
  border-top: 1px solid #DCDCDC;
  border-bottom: 1px solid #DCDCDC;
}
.w2ui-field > label {
  display: block;
  float: left;
  margin-top: 7px;
  margin-bottom: 3px;
  width: 120px;
  padding: 0px;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
  text-align: right;
  min-height: 20px;
  color: #666;
}
.w2ui-field > div {
  /* do not include width */
  margin-bottom: 3px;
  margin-left: 128px;
  padding: 3px;
  min-height: 28px;
  float: none;
}
.w2ui-field.w2ui-required > div {
  position: relative;
}
.w2ui-field.w2ui-required:not(.w2ui-field-inline) > div::before {
  content: '*';
  position: absolute;
  margin-top: 5px;
  margin-left: -9px;
  color: red;
}
.w2ui-field.w2ui-required.w2ui-field-inline > div::before {
  content: '' !important;
}
.w2ui-field.w2ui-disabled {
  opacity: 0.3;
  background-color: transparent !important;
}
.w2ui-field.w2ui-span-none > label {
  margin: 0;
  padding: 5px 0 0 4px;
  display: block;
  width: 100%;
  text-align: left;
}
.w2ui-field.w2ui-span-none > div {
  margin-left: 0;
}
.w2ui-field.w2ui-span0 > label {
  display: none;
}
.w2ui-field.w2ui-span0 > div {
  margin-left: 0;
}
.w2ui-field.w2ui-span1 > label {
  width: 20px;
}
.w2ui-field.w2ui-span1 > div {
  margin-left: 28px;
}
.w2ui-field.w2ui-span2 > label {
  width: 40px;
}
.w2ui-field.w2ui-span2 > div {
  margin-left: 48px;
}
.w2ui-field.w2ui-span3 > label {
  width: 60px;
}
.w2ui-field.w2ui-span3 > div {
  margin-left: 68px;
}
.w2ui-field.w2ui-span4 > label {
  width: 80px;
}
.w2ui-field.w2ui-span4 > div {
  margin-left: 88px;
}
.w2ui-field.w2ui-span5 > label {
  width: 100px;
}
.w2ui-field.w2ui-span5 > div {
  margin-left: 108px;
}
.w2ui-field.w2ui-span6 > label {
  width: 120px;
}
.w2ui-field.w2ui-span6 > div {
  margin-left: 128px;
}
.w2ui-field.w2ui-span7 > label {
  width: 140px;
}
.w2ui-field.w2ui-span7 > div {
  margin-left: 148px;
}
.w2ui-field.w2ui-span8 > label {
  width: 160px;
}
.w2ui-field.w2ui-span8 > div {
  margin-left: 168px;
}
.w2ui-field.w2ui-span9 > label {
  width: 180px;
}
.w2ui-field.w2ui-span9 > div {
  margin-left: 188px;
}
.w2ui-field.w2ui-span10 > label {
  width: 200px;
}
.w2ui-field.w2ui-span10 > div {
  margin-left: 208px;
}
.w2ui-field.w2ui-field-inline {
  display: inline;
}
.w2ui-field.w2ui-field-inline > div {
  display: inline;
  margin: 0;
  padding: 0;
}
.w2ui-error {
  border: 1px solid #FFA8A8 !important;
  background-color: #FFF4EB !important;
}
.w2field {
  padding: 3px;
  border-radius: 3px;
  border: 1px solid silver;
}
.w2ui-field-helper {
  position: absolute;
  display: inline-block;
  line-height: 100%;
  /* pointer-events: none; - do not use as IE does not support it */
  user-select: none;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  -o-user-select: none;
}
.w2ui-field-helper .w2ui-field-up {
  position: absolute;
  top: 0px;
  padding: 2px 3px;
}
.w2ui-field-helper .w2ui-field-down {
  position: absolute;
  bottom: 0px;
  padding: 2px 3px;
}
.w2ui-field-helper .arrow-up:hover {
  border-bottom-color: #81C6FF;
}
.w2ui-field-helper .arrow-down:hover {
  border-top-color: #81C6FF;
}
/*
*    ARROWS
*/
.arrow-up {
  background: none;
  width: 0;
  height: 0;
  border-left: 4px solid transparent;
  /* left arrow slant */
  border-right: 4px solid transparent;
  /* right arrow slant */
  border-bottom: 5px solid #777;
  /* bottom, add background color here */
  font-size: 0;
  line-height: 0;
}
.arrow-down {
  background: none;
  width: 0;
  height: 0;
  border-left: 4px solid transparent;
  border-right: 4px solid transparent;
  border-top: 5px solid #777;
  font-size: 0;
  line-height: 0;
}
.arrow-left {
  background: none;
  width: 0;
  height: 0;
  border-bottom: 4px solid transparent;
  /* left arrow slant */
  border-top: 4px solid transparent;
  /* right arrow slant */
  border-right: 5px solid #777;
  /* bottom, add background color here */
  font-size: 0;
  line-height: 0;
}
.arrow-right {
  background: none;
  width: 0;
  height: 0;
  border-bottom: 4px solid transparent;
  /* left arrow slant */
  border-top: 4px solid transparent;
  /* right arrow slant */
  border-left: 5px solid #777;
  /* bottom, add background color here */
  font-size: 0;
  line-height: 0;
}
/*
*    COLOR overlay
*/
.w2ui-color {
  padding: 8px 5px 0px 5px;
  background-color: white;
  border-radius: 3px;
}
.w2ui-color input:focus {
  outline: none;
  border: 1px solid #999 !important;
}
.w2ui-color .w2ui-color-palette {
  width: 242px;
}
.w2ui-color .w2ui-color-palette table {
  table-layout: fixed;
  width: 160px;
}
.w2ui-color .w2ui-color-palette table td {
  width: 20px;
  height: 20px;
  text-align: center;
}
.w2ui-color .w2ui-color-palette table td div {
  cursor: pointer;
  display: inline-block;
  width: 16px;
  height: 17px;
  padding: 1px 4px;
  border: 1px solid transparent;
  color: white;
  text-shadow: 0px 0px 2px #000;
}
.w2ui-color .w2ui-color-palette table td div:hover {
  outline: 1px solid #666;
  border: 1px solid #fff;
}
.w2ui-color .w2ui-color-palette table td div.no-color {
  border: 1px solid #efefef;
}
.w2ui-color .w2ui-color-advanced {
  height: 176px;
  padding: 1px 2px;
}
.w2ui-color .w2ui-color-advanced .palette {
  position: relative;
  width: 150px;
  height: 125px;
  outline: 1px solid #d2d2d2;
  box-sizing: content-box;
}
.w2ui-color .w2ui-color-advanced .palette .palette-bg {
  height: 100%;
  background-image: linear-gradient(0deg, #000000, rgba(204, 154, 129, 0));
  pointer-events: none;
}
.w2ui-color .w2ui-color-advanced .rainbow {
  position: relative;
  width: 150px;
  height: 12px;
  margin: 10px 0px 0px 0px;
  background: linear-gradient(90deg, #ff0000 0%, #ffff00 17%, #00ff00 33%, #00ffff 50%, #0000ff 67%, #ff00ff 83%, #ff0000 100%);
}
.w2ui-color .w2ui-color-advanced .alpha {
  position: relative;
  width: 150px;
  height: 12px;
  margin: 10px 0px 0px 0px;
  background-color: #fff;
  background-image: linear-gradient(45deg, #bbb 25%, transparent 25%, transparent 75%, #bbb 75%, #bbb), linear-gradient(45deg, #bbb 25%, transparent 25%, transparent 75%, #bbb 75%, #bbb);
  background-size: 12px 12px;
  background-position: 0 0, 6px 6px;
}
.w2ui-color .w2ui-color-advanced .alpha .alpha-bg {
  height: 100%;
  background-image: linear-gradient(90deg, rgba(80, 80, 80, 0) 0%, #505050 100%);
  pointer-events: none;
}
.w2ui-color .w2ui-color-advanced .value1 {
  pointer-events: none;
  position: absolute;
  top: 0px;
  display: inline-block;
  width: 8px;
  height: 8px;
  border-radius: 10px;
  border: 1px solid #999;
  background-color: transparent;
  box-shadow: 0px 0px 1px white;
  transform: translateX(-1px) translateY(-1px);
}
.w2ui-color .w2ui-color-advanced .value2 {
  pointer-events: none;
  position: absolute;
  top: -2px;
  display: inline-block;
  width: 8px;
  height: 16px;
  border-radius: 2px;
  border: 1px solid #696969;
  background-color: #ffffff;
  box-shadow: 0px 0px 1px white;
  transform: translateX(-1px);
}
.w2ui-color .w2ui-color-advanced .color-info {
  float: right;
  width: 80px;
  margin-left: 158px;
  margin-top: 0px;
}
.w2ui-color .w2ui-color-advanced .color-info .color-preview-bg {
  box-shadow: 0 0 1px #c3c3c3;
  height: 40px;
  background-color: #fff;
  background-image: linear-gradient(45deg, #bbb 25%, transparent 25%, transparent 75%, #bbb 75%, #bbb), linear-gradient(45deg, #bbb 25%, transparent 25%, transparent 75%, #bbb 75%, #bbb);
  background-size: 16px 16px;
  background-position: 0 0, 8px 8px;
  margin-bottom: 10px;
}
.w2ui-color .w2ui-color-advanced .color-info .color-preview,
.w2ui-color .w2ui-color-advanced .color-info .color-original {
  height: 40px;
  width: 40px;
  float: left;
}
.w2ui-color .w2ui-color-advanced .color-info .color-part {
  padding-top: 5px;
}
.w2ui-color .w2ui-color-advanced .color-info .color-part span {
  display: inline-block;
  width: 7px;
  margin-left: 1px;
  color: #666;
}
.w2ui-color .w2ui-color-advanced .color-info .color-part input {
  font-size: 10px!important;
  border-radius: 2px;
  border: 1px solid #ccc;
  width: 26px !important;
  padding: 2px !important;
  color: #333;
}
.w2ui-color .w2ui-color-tabs {
  background-color: #f7f7f7;
  height: 30px;
  margin: 10px -5px 0px -5px;
  border-top: 1px solid #d6d6d6;
}
.w2ui-color .w2ui-color-tabs .w2ui-color-tab {
  float: left;
  display: inline-block;
  width: 34px;
  height: 25px;
  border: 1px solid transparent;
  border-radius: 1px;
  margin: -1px -3px 0px 8px;
  text-align: center;
  font-size: 15px;
  padding-top: 1px;
  color: #7b7b7b;
}
.w2ui-color .w2ui-color-tabs .w2ui-color-tab.selected {
  color: #555;
  background-color: white;
  border: 1px solid #e0e0e0;
  border-top: 1px solid transparent;
  border-bottom-left-radius: 5px;
  border-bottom-right-radius: 5px;
}
/*
*    DATE overlay
*/
.w2ui-calendar {
  margin: 0px;
  padding: 1px;
  line-height: 108%;
}
.w2ui-calendar .w2ui-calendar-title {
  margin: 0px -1px;
  padding: 7px 2px;
  background-image: -webkit-linear-gradient(#f6f6f6, #d9d9d9);
  background-image: -moz-linear-gradient(#f6f6f6, #d9d9d9);
  background-image: -ms-linear-gradient(#f6f6f6, #d9d9d9);
  background-image: -o-linear-gradient(#f6f6f6, #d9d9d9);
  background-image: linear-gradient(#f6f6f6, #d9d9d9);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fff6f6f6', endColorstr='#ffd9d9d9', GradientType=0);
  border-bottom: 1px solid #bbb;
  color: #555;
  text-align: center;
  text-shadow: 1px 1px 1px #eee;
  cursor: pointer;
}
.w2ui-calendar .w2ui-calendar-jump {
  position: absolute;
  top: 27px;
  left: 0px;
  right: 0px;
  bottom: 0px;
  background-color: #FaFaFa;
}
.w2ui-calendar .w2ui-calendar-jump > :first-child {
  position: absolute;
  top: 0px;
  left: 0px;
  bottom: 0px;
  width: 110px;
  overflow: hidden;
  padding-top: 5px;
  border-right: 1px solid silver;
}
.w2ui-calendar .w2ui-calendar-jump > :last-child {
  position: absolute;
  top: 0px;
  right: 0px;
  bottom: 0px;
  width: 88px;
  overflow-x: hidden;
  overflow-y: auto;
  padding-top: 5px;
  text-align: center;
}
.w2ui-calendar .w2ui-calendar-jump .w2ui-jump-month,
.w2ui-calendar .w2ui-calendar-jump .w2ui-jump-year {
  display: inline-block;
  padding: 5px 0px;
  text-align: center;
  float: left;
  margin: 2px;
  width: 50px;
  cursor: default;
  border: 1px solid transparent;
  border-radius: 2px;
}
.w2ui-calendar .w2ui-calendar-jump .w2ui-jump-year {
  float: none;
  width: 95%;
}
.w2ui-calendar .w2ui-calendar-jump .w2ui-jump-month:hover,
.w2ui-calendar .w2ui-calendar-jump .w2ui-jump-year:hover {
  border: 1px solid #ccc;
  color: black;
  background-color: #efefef;
}
.w2ui-calendar .w2ui-calendar-jump .w2ui-jump-month.selected,
.w2ui-calendar .w2ui-calendar-jump .w2ui-jump-year.selected {
  border: 1px solid #ccc;
  color: black;
  background-color: #dadada;
}
.w2ui-calendar .w2ui-calendar-previous,
.w2ui-calendar .w2ui-calendar-next {
  width: 24px;
  height: 20px;
  color: #666;
  border: 1px solid transparent;
  border-radius: 3px;
  padding: 2px 3px 1px 2px;
  margin: -4px 0px 0px 0px;
  cursor: default;
}
.w2ui-calendar .w2ui-calendar-previous:hover,
.w2ui-calendar .w2ui-calendar-next:hover {
  border: 1px solid silver;
  background-color: #efefef;
}
.w2ui-calendar .w2ui-calendar-previous > div,
.w2ui-calendar .w2ui-calendar-next > div {
  position: absolute;
  border-left: 4px solid #888;
  border-top: 4px solid #888;
  border-right: 4px solid transparent;
  border-bottom: 4px solid transparent;
  width: 0px;
  height: 0px;
  padding: 0px;
  margin: 3px 0px 0px 0px;
}
.w2ui-calendar .w2ui-calendar-previous {
  float: left;
}
.w2ui-calendar .w2ui-calendar-previous > div {
  -webkit-transform: rotate(-45deg);
  -moz-transform: rotate(-45deg);
  -ms-transform: rotate(-45deg);
  -o-transform: rotate(-45deg);
  transform: rotate(-45deg);
  margin-left: 6px;
}
.w2ui-calendar .w2ui-calendar-next {
  float: right;
}
.w2ui-calendar .w2ui-calendar-next > div {
  -webkit-transform: rotate(135deg);
  -moz-transform: rotate(135deg);
  -ms-transform: rotate(135deg);
  -o-transform: rotate(135deg);
  transform: rotate(135deg);
  margin-left: 2px;
  margin-right: 2px;
}
.w2ui-calendar .w2ui-calendar-now {
  cursor: pointer;
  margin-bottom: 10px;
  text-align: center;
}
.w2ui-calendar .w2ui-calendar-now:hover {
  color: #0A96DE;
}
.w2ui-calendar table.w2ui-calendar-days {
  padding: 0px;
}
.w2ui-calendar table.w2ui-calendar-days td {
  border: 1px solid #fff;
  color: black;
  background-color: #f9f9f9;
  padding: 6px;
  cursor: default;
  text-align: right;
}
.w2ui-calendar table.w2ui-calendar-days td.w2ui-saturday,
.w2ui-calendar table.w2ui-calendar-days td.w2ui-sunday {
  border: 1px solid #fff;
  color: #c8493b;
  background-color: #f9f9f9;
}
.w2ui-calendar table.w2ui-calendar-days td.w2ui-saturday:hover,
.w2ui-calendar table.w2ui-calendar-days td.w2ui-sunday:hover {
  border: 1px solid #ccc;
  color: black;
  background-color: #e9e9e9;
}
.w2ui-calendar table.w2ui-calendar-days td.w2ui-saturday.w2ui-blocked,
.w2ui-calendar table.w2ui-calendar-days td.w2ui-sunday.w2ui-blocked {
  text-decoration: line-through;
  border: 1px solid #fff;
  color: #ccc;
  background-color: #fff;
}
.w2ui-calendar table.w2ui-calendar-days td.w2ui-today {
  color: black;
  background-color: #e2f7cd;
}
.w2ui-calendar table.w2ui-calendar-days td:hover {
  border: 1px solid #ccc;
  color: black;
  background-color: #e9e9e9;
}
.w2ui-calendar table.w2ui-calendar-days td.w2ui-date-selected {
  border: 1px solid #8cb067;
}
.w2ui-calendar table.w2ui-calendar-days td.w2ui-blocked {
  text-decoration: line-through;
  border: 1px solid #fff;
  color: #ccc;
  background-color: #fff;
}
.w2ui-calendar table.w2ui-calendar-days td.w2ui-day-empty {
  border: 1px solid #fff;
  background-color: #fdfdfd;
}
.w2ui-calendar table.w2ui-calendar-days tr.w2ui-day-title td {
  border: 1px solid #fff;
  color: gray;
  background-color: #fff;
  text-align: center;
  padding: 6px;
}
/*
*    Time
*/
.w2ui-calendar-time {
  padding: 5px;
  cursor: default;
}
.w2ui-calendar-time td div {
  padding: 7px 10px;
  text-align: center;
  border: 1px solid transparent;
  white-space: nowrap;
}
.w2ui-calendar-time td:nth-child(even) {
  background-color: #f6f6f6;
}
.w2ui-calendar-time td div:hover {
  border: 1px solid #ccc;
  color: black;
  background-color: #e9e9e9;
}
.w2ui-calendar-time td div.w2ui-blocked {
  text-decoration: line-through;
  border: 1px solid #fff;
  color: #ccc;
  background-color: #fff;
}
.w2ui-select {
  cursor: default;
  color: black !important;
  background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAALCAQAAACnzwd+AAAAcklEQVR4AcXMsQFBQQDG4P9tAgC0gJYRQJZgKQMwCqCku6vVAAAA+NJHP4KHOk0aV2pRw61n4BBmyOxKQ8I4ehZeuhd3HTx6DQEGZ7sBfr2OOOOj3Yi43kMKs9sZknofOexqZ8npMygwWZTX51CipP+YA1OiZJbYYg9lAAAAAElFTkSuQmCC'), -webkit-linear-gradient(top, #fff 20%, #f6f6f6 50%, #EEE 52%, #f4f4f4 100%);
  background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAALCAQAAACnzwd+AAAAcklEQVR4AcXMsQFBQQDG4P9tAgC0gJYRQJZgKQMwCqCku6vVAAAA+NJHP4KHOk0aV2pRw61n4BBmyOxKQ8I4ehZeuhd3HTx6DQEGZ7sBfr2OOOOj3Yi43kMKs9sZknofOexqZ8npMygwWZTX51CipP+YA1OiZJbYYg9lAAAAAElFTkSuQmCC'), -moz-linear-gradient(top, #fff 20%, #f6f6f6 50%, #EEE 52%, #f4f4f4 100%);
  background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAALCAQAAACnzwd+AAAAcklEQVR4AcXMsQFBQQDG4P9tAgC0gJYRQJZgKQMwCqCku6vVAAAA+NJHP4KHOk0aV2pRw61n4BBmyOxKQ8I4ehZeuhd3HTx6DQEGZ7sBfr2OOOOj3Yi43kMKs9sZknofOexqZ8npMygwWZTX51CipP+YA1OiZJbYYg9lAAAAAElFTkSuQmCC'), -ms-linear-gradient(top, #fff 20%, #f6f6f6 50%, #EEE 52%, #f4f4f4 100%);
  background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAALCAQAAACnzwd+AAAAcklEQVR4AcXMsQFBQQDG4P9tAgC0gJYRQJZgKQMwCqCku6vVAAAA+NJHP4KHOk0aV2pRw61n4BBmyOxKQ8I4ehZeuhd3HTx6DQEGZ7sBfr2OOOOj3Yi43kMKs9sZknofOexqZ8npMygwWZTX51CipP+YA1OiZJbYYg9lAAAAAElFTkSuQmCC'), -o-linear-gradient(top, #fff 20%, #f6f6f6 50%, #EEE 52%, #f4f4f4 100%);
  background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAALCAQAAACnzwd+AAAAcklEQVR4AcXMsQFBQQDG4P9tAgC0gJYRQJZgKQMwCqCku6vVAAAA+NJHP4KHOk0aV2pRw61n4BBmyOxKQ8I4ehZeuhd3HTx6DQEGZ7sBfr2OOOOj3Yi43kMKs9sZknofOexqZ8npMygwWZTX51CipP+YA1OiZJbYYg9lAAAAAElFTkSuQmCC'), linear-gradient(to bottom, #fff 20%, #f6f6f6 50%, #EEE 52%, #f4f4f4 100%);
  background-size: 17px 6px, 100% 100%;
  background-position: right center, left top;
  background-repeat: no-repeat, no-repeat;
}
.w2ui-select[readonly],
.w2ui-select[disabled] {
  background-image: none;
  background-color: #f1f1f1 !important;
  color: #777 !important;
  outline: none!important;
}
/*
*    ENUM items
*/
.w2ui-list {
  color: inherit;
  position: absolute;
  padding: 0px;
  margin: 0px;
  min-height: 25px;
  overflow: auto;
  border: 1px solid silver;
  border-radius: 3px;
  font-size: 6px;
  line-height: 100%;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
  background-color: white;
}
.w2ui-list input[type=text] {
  -webkit-box-shadow: none;
  -moz-box-shadow: none;
  -ms-box-shadow: none;
  -o-box-shadow: none;
  box-shadow: none;
}
.w2ui-list ul {
  list-style-type: none;
  background-color: black;
  margin: 0px;
  padding: 0px;
}
.w2ui-list ul li {
  float: left;
  margin: 2px 1px 0px 2px;
  border-radius: 3px;
  width: auto;
  padding: 3px 10px 1px 7px;
  border: 1px solid #88B0D6;
  background-color: #EFF3F5;
  white-space: nowrap;
  cursor: default;
  font-family: verdana;
  font-size: 11px;
  line-height: 100%;
  height: 20px;
  overflow: hidden;
  text-overflow: ellipsis;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-list ul li:hover {
  background-color: #d0dbe1;
}
.w2ui-list ul li:last-child {
  border-radius: 0px;
  border: 1px solid transparent;
  background-color: transparent;
}
.w2ui-list ul li:last-child input {
  padding: 1px;
  padding-top: 0px;
  margin: 0px;
  border: 0px;
  outline: none;
  height: auto;
  line-height: 100%;
  font-size: inherit;
  font-family: inherit;
  background-color: transparent;
}
.w2ui-list ul li .w2ui-list-remove {
  float: right;
  width: 15px;
  height: 14px;
  margin: -1px -9px 0px 3px;
  border-radius: 15px;
}
.w2ui-list ul li .w2ui-list-remove:hover {
  background-color: #D77F7F;
  color: white;
}
.w2ui-list ul li .w2ui-list-remove:before {
  position: relative;
  top: 0px;
  padding: 0px;
  margin: 0px;
  left: 5px;
  color: inherit;
  opacity: 0.7;
  text-shadow: inherit;
  font-size: inherit;
  font-variant: small-caps;
  content: 'x';
  line-height: 100%;
}
.w2ui-list ul li > span.file-size {
  pointer-events: none;
  color: #777;
}
.w2ui-list.w2ui-readonly ul > li:hover {
  background-color: #EFF3F5;
}
.w2ui-list .w2ui-enum-placeholder {
  display: inline;
  position: absolute;
  pointer-events: none;
  color: #999;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-list.w2ui-file-dragover {
  background-color: #E4FFDA;
  border: 1px solid #93E07D;
}
/*************************************************
* ---- Layout ----
*/
.w2ui-layout {
  overflow: hidden !important;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-layout * {
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-layout > div {
  position: absolute;
  overflow: hidden;
  border: 0px;
  margin: 0px;
  padding: 0px;
  outline: 0px;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-layout > div .w2ui-panel {
  display: none;
  position: absolute;
  z-index: 120;
}
.w2ui-layout > div .w2ui-panel .w2ui-panel-title {
  position: absolute;
  left: 0px;
  top: 0px;
  right: 0px;
  padding: 5px;
  background-image: -webkit-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -moz-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -ms-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -o-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: linear-gradient(#DAE6F3, #C2D5ED);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffdae6f3', endColorstr='#ffc2d5ed', GradientType=0);
  border: 1px solid #B9CEE9;
  border-bottom: 1px solid #99bbe8;
}
.w2ui-layout > div .w2ui-panel .w2ui-panel-tabs {
  position: absolute;
  left: 0px;
  top: 0px;
  right: 0px;
  z-index: 2;
  display: none;
  overflow: hidden;
  background-color: #FAFAFA;
  padding: 4px 0px;
}
.w2ui-layout > div .w2ui-panel .w2ui-panel-tabs > .w2ui-tab.active {
  background-color: #F2F2F2;
}
.w2ui-layout > div .w2ui-panel .w2ui-panel-toolbar {
  position: absolute;
  left: 0px;
  top: 0px;
  right: 0px;
  z-index: 2;
  display: none;
  overflow: hidden;
  background-color: #FAFAFA;
  border-bottom: 1px solid silver;
  padding: 4px;
}
.w2ui-layout > div .w2ui-panel .w2ui-panel-content {
  position: absolute;
  left: 0px;
  top: 0px;
  right: 0px;
  bottom: 0px;
  z-index: 1;
  color: inherit;
  background-color: #F2F2F2;
}
.w2ui-layout > div .w2ui-resizer {
  display: none;
  position: absolute;
  z-index: 121;
  background-color: transparent;
}
.w2ui-layout > div .w2ui-resizer:hover,
.w2ui-layout > div .w2ui-resizer.active {
  background-color: #C8CAD1;
}
/*************************************************
* ---- Grid ----
*/
.w2ui-grid {
  position: relative;
  border: 1px solid silver;
  border-radius: 2px;
  overflow: hidden !important;
}
.w2ui-grid > div {
  position: absolute;
  overflow: hidden;
}
.w2ui-grid .w2ui-grid-header {
  position: absolute;
  border-bottom: 1px solid #99bbe8 !important;
  height: 28px;
  overflow: hidden;
  color: #444;
  font-size: 13px;
  text-align: center;
  padding: 7px;
  background-image: -webkit-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -moz-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -ms-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: -o-linear-gradient(#DAE6F3, #C2D5ED);
  background-image: linear-gradient(#DAE6F3, #C2D5ED);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffdae6f3', endColorstr='#ffc2d5ed', GradientType=0);
  border-top-left-radius: 2px;
  border-top-right-radius: 2px;
}
.w2ui-grid .w2ui-grid-toolbar {
  position: absolute;
  border-bottom: 1px solid silver;
  background-color: #EAEAEA;
  height: 38px;
  padding: 6px 1px 4px 1px;
  margin: 0px;
  box-shadow: 0px 1px 2px #ddd;
}
.w2ui-grid .w2ui-toolbar-search {
  position: relative;
  width: 160px;
  margin-right: 3px;
}
.w2ui-grid .w2ui-toolbar-search .w2ui-search-all {
  outline: none !important;
  width: 160px !important;
  border-radius: 3px !important;
  line-height: normal !important;
  height: 23px !important;
  border: 1px solid #B9B9B9 !important;
  color: #000 !important;
  background-color: white !important;
  padding: 3px 18px 3px 21px !important;
  margin: 0px !important;
  margin-top: 1px !important;
}
.w2ui-grid .w2ui-toolbar-search .w2ui-search-down {
  position: absolute;
  margin-top: -7px;
  margin-left: 4px;
}
.w2ui-grid .w2ui-toolbar-search .w2ui-search-clear {
  position: absolute;
  width: 16px;
  height: 16px;
  margin-top: -8px;
  margin-left: -20px;
  border-radius: 15px;
  cursor: default;
}
.w2ui-grid .w2ui-toolbar-search .w2ui-search-clear:hover {
  background-color: #D77F7F;
  color: white;
}
.w2ui-grid .w2ui-toolbar-search .w2ui-search-clear:before {
  position: relative;
  top: 2px;
  left: 5px;
  opacity: 0.6;
  color: inherit;
  text-shadow: inherit;
  content: 'x';
  cursor: default;
}
.w2ui-grid .w2ui-grid-body {
  position: absolute;
  overflow: hidden;
  padding: 0px;
  background-color: white;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  -o-user-select: none;
  user-select: none;
}
.w2ui-grid .w2ui-grid-body input,
.w2ui-grid .w2ui-grid-body select,
.w2ui-grid .w2ui-grid-body textarea {
  user-select: text;
  -webkit-user-select: text;
  -moz-user-select: text;
  -ms-user-select: text;
  -o-user-select: text;
}
.w2ui-grid .w2ui-grid-body div.w2ui-input {
  user-select: tex;
  -webkit-user-select: tex;
  -moz-user-select: tex;
  -ms-user-select: tex;
  -o-user-select: tex;
  background-color: white;
  padding: 4px 2px;
  border: 1px solid transparent;
  width: 100%;
  height: 100%;
  pointer-events: auto;
  outline: none;
  white-space: pre;
  overflow: hidden;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-columns,
.w2ui-grid .w2ui-grid-body .w2ui-grid-fcolumns {
  overflow: hidden;
  position: absolute;
  left: 0px;
  top: 0px;
  right: 0px;
  box-shadow: 0px 1px 4px #ddd;
  height: auto;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-columns table,
.w2ui-grid .w2ui-grid-body .w2ui-grid-fcolumns table {
  height: auto;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-columns .w2ui-resizer,
.w2ui-grid .w2ui-grid-body .w2ui-grid-fcolumns .w2ui-resizer {
  position: absolute;
  z-index: 1000;
  display: block;
  background-image: none;
  background-color: rgba(0, 0, 0, 0);
  /* needed for IE */
  padding: 0px;
  margin: 0px;
  width: 6px;
  height: 12px;
  cursor: col-resize;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords {
  position: absolute;
  left: 0px;
  right: 0px;
  top: 0px;
  bottom: 0px;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-odd,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-odd {
  color: inherit;
  background-color: white;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-odd:hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-odd:hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-odd.w2ui-record-hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-odd.w2ui-record-hover {
  color: inherit;
  background-color: #E6F0FF;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-odd.w2ui-empty-record:hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-odd.w2ui-empty-record:hover {
  background-color: white;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-even,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-even {
  color: inherit;
  background-color: #F3F6FA;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-even:hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-even:hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-even.w2ui-record-hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-even.w2ui-record-hover {
  color: inherit;
  background-color: #E6F0FF;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-even.w2ui-empty-record:hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-even.w2ui-empty-record:hover {
  background-color: #F3F6FA;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-selected,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-selected,
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr td.w2ui-selected,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr td.w2ui-selected {
  color: black !important;
  background-color: #B6D5FF !important;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr.w2ui-inactive,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-inactive,
.w2ui-grid .w2ui-grid-body .w2ui-grid-records table tr td.w2ui-inactive,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords table tr td.w2ui-inactive {
  background-color: #D8DEE7 !important;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records .w2ui-expanded1,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords .w2ui-expanded1 {
  height: 0px;
  border-bottom: 1px solid #b2bac0;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records .w2ui-expanded1 > div,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords .w2ui-expanded1 > div {
  height: 0px;
  border: 0px;
  transition: height 0.3s, opacity 0.3s;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records .w2ui-expanded2,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords .w2ui-expanded2 {
  height: 0px;
  border-radius: 0px;
  border-bottom: 1px solid #b2bac0;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records .w2ui-expanded2 > div,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords .w2ui-expanded2 > div {
  height: 0px;
  border: 0px;
  transition: height 0.3s, opacity 0.3s;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records .w2ui-load-more,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords .w2ui-load-more {
  border-top: 1px solid #D6D5D7;
  cursor: pointer;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records .w2ui-load-more > div,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords .w2ui-load-more > div {
  text-align: center;
  color: #777;
  background-color: rgba(233, 237, 243, 0.5);
  padding: 10px 0px 15px 0px;
  border-top: 1px solid white;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-records .w2ui-load-more > div:hover,
.w2ui-grid .w2ui-grid-body .w2ui-grid-frecords .w2ui-load-more > div:hover {
  color: inherit;
  background-color: #E6F0FF;
}
.w2ui-grid .w2ui-grid-body table {
  border-spacing: 0px;
  border-collapse: collapse;
  table-layout: fixed;
  width: 1px;
}
.w2ui-grid .w2ui-grid-body table .w2ui-head {
  margin: 0px;
  padding: 0px;
  border-right: 1px solid #c5c5c5;
  border-bottom: 1px solid #c5c5c5;
  color: black;
  background-image: -webkit-linear-gradient(#F9F9F9, #E4E4E4);
  background-image: -moz-linear-gradient(#F9F9F9, #E4E4E4);
  background-image: -ms-linear-gradient(#F9F9F9, #E4E4E4);
  background-image: -o-linear-gradient(#F9F9F9, #E4E4E4);
  background-image: linear-gradient(#F9F9F9, #E4E4E4);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fff9f9f9', endColorstr='#ffe4e4e4', GradientType=0);
}
.w2ui-grid .w2ui-grid-body table .w2ui-head > div {
  padding: 7px 3px;
  white-space: nowrap;
  text-overflow: ellipsis;
  overflow: hidden;
  position: relative;
}
.w2ui-grid .w2ui-grid-body table .w2ui-head.w2ui-col-intersection {
  border-right-color: #72B2FF;
}
.w2ui-grid .w2ui-grid-body table .w2ui-head.w2ui-reorder-cols-head:hover {
  cursor: move;
}
.w2ui-grid .w2ui-grid-body table .w2ui-head .col-intersection-marker {
  padding: 0;
  position: absolute;
  height: 100%;
  top: 0;
}
.w2ui-grid .w2ui-grid-body table .w2ui-head .col-intersection-marker.left {
  left: 0;
  margin-left: -5px;
}
.w2ui-grid .w2ui-grid-body table .w2ui-head .col-intersection-marker.right {
  right: 0;
  margin-right: -5px;
}
.w2ui-grid .w2ui-grid-body table .w2ui-head .col-intersection-marker .top-marker {
  position: absolute;
  top: 0;
  height: 0;
  width: 0;
  border-top: 5px solid #72B2FF;
  border-left: 5px solid transparent;
  border-right: 5px solid transparent;
}
.w2ui-grid .w2ui-grid-body table .w2ui-head .col-intersection-marker .bottom-marker {
  position: absolute;
  bottom: 0;
  height: 0;
  width: 0;
  border-bottom: 5px solid #72B2FF;
  border-left: 5px solid transparent;
  border-right: 5px solid transparent;
}
.w2ui-grid .w2ui-grid-body table td {
  border-right: 1px solid #D6D5D7;
  border-bottom: 0px solid #D6D5D7;
  cursor: default;
  overflow: hidden;
}
.w2ui-grid .w2ui-grid-body table td.w2ui-soft-span,
.w2ui-grid .w2ui-grid-body table td.w2ui-soft-hidden {
  border-right-color: transparent;
}
.w2ui-grid .w2ui-grid-body table td.w2ui-grid-data {
  margin: 0px;
  padding: 0px;
}
.w2ui-grid .w2ui-grid-body table td.w2ui-grid-data .w2ui-info {
  position: relative;
  top: 1px;
  font-size: 14px;
  color: #8D99A7;
  cursor: pointer;
  width: 16px;
  display: inline-block;
  margin-right: 2px;
  text-align: center;
}
.w2ui-grid .w2ui-grid-body table td.w2ui-grid-data > div {
  padding: 3px 3px 3px 3px;
  overflow: hidden;
  white-space: nowrap;
  text-overflow: ellipsis;
}
.w2ui-grid .w2ui-grid-body table td.w2ui-grid-data > div.flexible-record {
  height: auto;
  overflow: visible;
  white-space: normal;
}
.w2ui-grid .w2ui-grid-body table td.w2ui-grid-data .w2ui-show-children {
  width: 16px;
  height: 10px;
  display: inline-block;
  position: relative;
  top: -1px;
  cursor: pointer;
}
.w2ui-grid .w2ui-grid-body table td:last-child {
  border-right: 0px;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-number {
  width: 34px;
  color: #777;
  background-color: rgba(233, 237, 243, 0.5);
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-number div {
  padding: 0px 7px 0px 3px;
  text-align: right;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-number.w2ui-head {
  cursor: pointer;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-select {
  width: 26px;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-select div {
  padding: 0px 0px;
  text-align: center;
  overflow: hidden;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-select div input[type=checkbox] {
  margin-top: 0px;
  margin-bottom: 0px;
  position: relative;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-expand {
  width: 26px;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-expand div {
  padding: 0px 0px;
  text-align: center;
  font-weight: bold;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-order {
  width: 26px;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-order.w2ui-grid-data div {
  cursor: move;
  height: 18px;
  background-image: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgogIDxyZWN0IHN0eWxlPSJmaWxsOiAjYWFhOyIgeD0iMCIgeT0iNCIgaGVpZ2h0PSIzIiB3aWR0aD0iMTYiPjwvcmVjdD4KICA8cmVjdCBzdHlsZT0iZmlsbDogI2FhYTsiIHg9IjAiIHk9IjkiIGhlaWdodD0iMyIgd2lkdGg9IjE2Ij48L3JlY3Q+Cjwvc3ZnPg==");
  background-position: 5px 2px;
  background-size: 14px 12px;
  background-repeat: no-repeat;
}
.w2ui-grid .w2ui-grid-body table .w2ui-col-selected {
  background-color: #d1d1d1 !important;
}
.w2ui-grid .w2ui-grid-body table .w2ui-row-selected {
  background-color: #d1d1d1 !important;
}
.w2ui-grid .w2ui-grid-body div.w2ui-col-header {
  height: auto !important;
  width: 100%;
  overflow: hidden;
  padding-right: 10px !important;
}
.w2ui-grid .w2ui-grid-body div.w2ui-col-header > div.w2ui-sort-up {
  border: 4px solid transparent;
  border-bottom: 5px solid #8D99A7;
  margin-top: -2px;
  margin-right: -7px;
  float: right;
}
.w2ui-grid .w2ui-grid-body div.w2ui-col-header > div.w2ui-sort-down {
  border: 4px solid transparent;
  border-top: 5px solid #8D99A7;
  margin-top: 2px;
  margin-right: -7px;
  float: right;
}
.w2ui-grid .w2ui-grid-body .w2ui-col-group {
  text-align: center;
}
.w2ui-grid .w2ui-grid-body .w2ui-grid-scroll1 {
  position: absolute;
  left: 0px;
  bottom: 0px;
  border-top: 1px solid #ddd;
  border-right: 1px solid #ddd;
  background-color: #FAFAFA;
}
.w2ui-grid .w2ui-grid-empty-msg {
  position: absolute;
  top: 27px;
  left: 0;
  right: 0;
  bottom: 0;
  background-color: rgba(255, 255, 255, 0.65);
}
.w2ui-grid .w2ui-grid-empty-msg > div {
  position: absolute;
  left: 0;
  right: 0;
  top: 45%;
  transform: translateY(-45%);
  text-align: center;
  font-size: 13px;
  color: #666;
}
.w2ui-grid .w2ui-changed {
  background: url(data:image/gif;base64,R0lGODlhCgAKAJEAALAABf///wAAAAAAACH5BAEAAAIALAAAAAAKAAoAAAIPlI8Hy8mbxIsSUnup3rQAADs=) no-repeat top right;
}
.w2ui-grid .w2ui-edit-box {
  position: absolute;
  z-index: 1001;
  border: 2px solid #6299DA;
  pointer-events: auto;
}
.w2ui-grid .w2ui-editable {
  overflow: hidden;
  height: 100% !important;
  margin: 0px !important;
  padding: 0px !important;
}
.w2ui-grid .w2ui-editable input {
  border: 0px;
  border-radius: 0px;
  margin: 0px;
  padding: 4px 3px;
  width: 100%;
  height: 100%;
}
.w2ui-grid .w2ui-editable input.w2ui-select {
  outline: none !important;
  background: #fff;
}
.w2ui-grid .w2ui-grid-summary {
  position: absolute;
  box-shadow: 0px -1px 4px #aaa;
}
.w2ui-grid .w2ui-grid-summary table {
  color: inherit;
}
.w2ui-grid .w2ui-grid-summary table .w2ui-odd {
  background-color: #EEF5EB;
}
.w2ui-grid .w2ui-grid-summary table .w2ui-even {
  background-color: #F8FFF5;
}
.w2ui-grid .w2ui-grid-footer {
  position: absolute;
  margin: 0px;
  padding: 0px;
  text-align: center;
  height: 24px;
  overflow: hidden;
  user-select: text;
  -webkit-user-select: text;
  -moz-user-select: text;
  -ms-user-select: text;
  -o-user-select: text;
  box-shadow: 0px -1px 4px #eee;
  color: #444;
  background-color: #F8F8F8;
  border-top: 1px solid #ddd;
  border-bottom-left-radius: 2px;
  border-bottom-right-radius: 2px;
}
.w2ui-grid .w2ui-grid-footer .w2ui-footer-left {
  float: left;
  padding-top: 5px;
  padding-left: 5px;
}
.w2ui-grid .w2ui-grid-footer .w2ui-footer-right {
  float: right;
  padding-top: 5px;
  padding-right: 5px;
}
.w2ui-grid .w2ui-grid-footer .w2ui-footer-center {
  padding: 2px;
  text-align: center;
}
.w2ui-grid .w2ui-grid-footer .w2ui-footer-center .w2ui-footer-nav {
  width: 110px;
  margin: 0 auto;
  padding: 0px;
  text-align: center;
}
.w2ui-grid .w2ui-grid-footer .w2ui-footer-center .w2ui-footer-nav input[type=text] {
  padding: 1px 2px 2px 2px;
  border-radius: 3px;
  width: 40px;
  text-align: center;
}
.w2ui-grid .w2ui-grid-footer .w2ui-footer-center .w2ui-footer-nav a.w2ui-footer-btn {
  display: inline-block;
  border-radius: 3px;
  cursor: pointer;
  font-size: 11px;
  line-height: 16px;
  padding: 1px 5px;
  width: 30px;
  height: 18px;
  margin-top: -1px;
  color: black;
  background-color: transparent;
}
.w2ui-grid .w2ui-grid-footer .w2ui-footer-center .w2ui-footer-nav a.w2ui-footer-btn:hover {
  color: #000;
  background-color: #AEC8FF;
}
.w2ui-grid .w2ui-grid-focus-input {
  position: absolute;
  top: 0;
  right: 0;
  z-index: -1;
  opacity: 0;
  overflow: hidden;
  padding: 0px;
  margin: 0px;
  width: 1px;
  height: 1px;
  resize: none;
  border: 0px;
}
/* SpeadSheet */
.w2ui-ss .w2ui-grid-body .w2ui-grid-records table tr td.w2ui-selected {
  background-color: #EEF4FE !important;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-records table tr td.w2ui-inactive {
  background-color: #F4F6F9 !important;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-records table td {
  border-right-width: 1px;
  border-bottom: 1px solid #efefef;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-records table tr.w2ui-odd,
.w2ui-ss .w2ui-grid-body .w2ui-grid-records table tr.w2ui-even,
.w2ui-ss .w2ui-grid-body .w2ui-grid-records table tr.w2ui-odd:hover,
.w2ui-ss .w2ui-grid-body .w2ui-grid-records table tr.w2ui-even:hover {
  background-color: inherit;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-records table tr:first-child td {
  border-top: 0px;
  border-bottom: 0px;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-frecords table tr td.w2ui-selected {
  background-color: #EEF4FE !important;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-frecords table tr td.w2ui-inactive {
  background-color: #F4F6F9 !important;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-frecords table td {
  border-right-width: 1px;
  border-bottom: 1px solid #efefef;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-odd,
.w2ui-ss .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-even,
.w2ui-ss .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-odd:hover,
.w2ui-ss .w2ui-grid-body .w2ui-grid-frecords table tr.w2ui-even:hover {
  background-color: inherit;
}
.w2ui-ss .w2ui-grid-body .w2ui-grid-frecords table tr:first-child td {
  border-bottom: 0px;
}
.w2ui-ss .w2ui-grid-body .w2ui-selection {
  position: absolute;
  z-index: 1000;
  border: 2px solid #6299DA;
  /* #457FC2; */
  pointer-events: none;
}
.w2ui-ss .w2ui-grid-body .w2ui-selection .w2ui-selection-resizer {
  cursor: crosshair;
  position: absolute;
  bottom: 0px;
  right: 0px;
  width: 6px;
  height: 6px;
  margin-right: -3px;
  margin-bottom: -3px;
  background-color: #457FC2;
  border: 0.5px solid #fff;
  outline: 1px solid white;
  pointer-events: auto;
}
.w2ui-ss .w2ui-grid-body .w2ui-selection.w2ui-inactive {
  border: 2px solid #C0C2C5;
}
.w2ui-ss .w2ui-grid-body .w2ui-selection.w2ui-inactive .w2ui-selection-resizer {
  background-color: #B0B0B0;
}
.w2ui-ss .w2ui-grid-body .w2ui-soft-range {
  position: absolute;
  pointer-events: none;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}
.w2ui-ss .w2ui-grid-body .w2ui-changed {
  background: inherit;
  /* do not show changed for spreadsheet */
}
.w2ui-info-bubble table {
  font-size: 11px;
  font-family: Verdana, Arial, sans-serif;
  color: white;
  text-shadow: 1px 1px solid #999;
}
.w2ui-info-bubble table tr td:first-child {
  white-space: nowrap;
  padding: 2px;
  padding-right: 10px;
  color: #ddd;
  vertical-align: top;
}
.w2ui-info-bubble table tr td:last-child {
  white-space: pre;
  padding: 2px;
}
.w2ui-overlay .w2ui-select-field {
  padding: 4px 0px;
  cursor: default;
}
.w2ui-overlay .w2ui-select-field table {
  font-size: 11px;
  font-family: Verdana, Arial, sans-serif;
  border-spacing: 0px;
  border-collapse: border-collapse;
}
.w2ui-overlay .w2ui-select-field table tr {
  height: 27px;
}
.w2ui-overlay .w2ui-select-field table tr:hover {
  background-color: #B6D5FF;
}
.w2ui-overlay .w2ui-select-field table tr td:nth-child(1) {
  width: 26px;
  padding-right: 6px;
  text-align: right;
  color: #888;
}
.w2ui-overlay .w2ui-select-field table tr td:nth-child(2) {
  padding: 3px 20px 3px 0px;
}
.w2ui-overlay .w2ui-col-on-off {
  padding: 4px 0px;
}
.w2ui-overlay .w2ui-col-on-off table {
  border-spacing: 0px;
  border-collapse: border-collapse;
}
.w2ui-overlay .w2ui-col-on-off table tr:hover {
  background-color: #B6D5FF;
}
.w2ui-overlay .w2ui-col-on-off table td input[type=checkbox] {
  margin: 3px 2px 2px 2px;
}
.w2ui-overlay .w2ui-col-on-off table td label {
  display: block;
  padding: 3px 0px;
  padding-right: 10px;
}
.w2ui-overlay .w2ui-col-on-off table td:first-child {
  padding: 4px 0px 4px 6px;
}
.w2ui-overlay .w2ui-col-on-off table td:last-child {
  padding: 4px 6px 4px 0px;
}
.w2ui-overlay .w2ui-grid-searches {
  text-align: left;
  padding: 0px;
  border-top: 0px;
  background-color: #f7f6f0;
}
.w2ui-overlay .w2ui-grid-searches table {
  padding: 4px;
  padding-top: 12px;
  border-collapse: border-collapse;
}
.w2ui-overlay .w2ui-grid-searches table td {
  padding: 4px;
  /* for IE */
}
.w2ui-overlay .w2ui-grid-searches table td.close-btn {
  width: 20px;
  padding-right: 20px;
}
.w2ui-overlay .w2ui-grid-searches table td.close-btn button {
  min-width: 24px;
  height: 24px;
  padding-top: 5px !important;
}
.w2ui-overlay .w2ui-grid-searches table td.caption {
  text-align: right;
  padding-right: 5px;
  border-right: 1px solid #E8E8E3;
}
.w2ui-overlay .w2ui-grid-searches table td.operator {
  text-align: left;
  padding: 0px 10px;
  padding-right: 5px;
  border-right: 1px solid #E8E8E3;
  height: 31px;
}
.w2ui-overlay .w2ui-grid-searches table td.operator select {
  width: 100%;
  color: black;
}
.w2ui-overlay .w2ui-grid-searches table td.operator select::-ms-expand {
  display: none;
}
.w2ui-overlay .w2ui-grid-searches table td.value {
  padding-right: 5px;
  padding-left: 5px;
}
.w2ui-overlay .w2ui-grid-searches table td.value input[type=text] {
  border-radius: 3px;
  padding: 3px;
  margin-right: 3px;
  height: 23px;
}
.w2ui-overlay .w2ui-grid-searches table td.value select {
  padding: 3px;
  margin-right: 3px;
  height: 23px;
}
.w2ui-overlay .w2ui-grid-searches table td.actions {
  border-right: 0px;
}
.w2ui-overlay .w2ui-grid-searches table td.actions > div {
  margin: -7px;
  margin-top: 15px;
  padding: 13px 0px;
  text-align: center;
  background-color: #EFEFE9;
  border-top: 1px solid #E8E8E3;
}
/*************************************************
* ---- Popup ----
*/
.w2ui-popup {
  position: fixed;
  z-index: 1600;
  overflow: hidden;
  font-family: Verdana, Arial, sans-serif;
  border-radius: 6px;
  padding: 0px;
  margin: 0px;
  border: 1px solid #777;
  background-color: #eee;
  box-shadow: 0px 0px 25px #555;
}
.w2ui-popup,
.w2ui-popup * {
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-popup .w2ui-popup-title {
  padding: 6px;
  border-radius: 6px 6px 0px 0px;
  background-image: -webkit-linear-gradient(#ECECEC, #DFDFDF);
  background-image: -moz-linear-gradient(#ECECEC, #DFDFDF);
  background-image: -ms-linear-gradient(#ECECEC, #DFDFDF);
  background-image: -o-linear-gradient(#ECECEC, #DFDFDF);
  background-image: linear-gradient(#ECECEC, #DFDFDF);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffececec', endColorstr='#ffdfdfdf', GradientType=0);
  border-bottom: 2px solid #BFBFBF;
  position: absolute;
  overflow: hidden;
  height: 32px;
  left: 0px;
  right: 0px;
  top: 0px;
  text-overflow: ellipsis;
  text-align: center;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  -o-user-select: none;
  user-select: none;
  cursor: move;
  font-size: 15px;
  color: #555;
  z-index: 300;
}
.w2ui-popup .w2ui-popup-button {
  float: right;
  width: 18px;
  height: 18px;
  cursor: pointer;
  overflow: hidden;
  padding: 0px;
  margin: 0px 3px 0px 0px;
  background: url(data:image/png;base64,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) no-repeat center left;
  background-position: 0px 0px;
  color: transparent !important;
  border-radius: 3px;
  border: 1px solid transparent;
}
.w2ui-popup .w2ui-popup-close {
  margin-top: 0px;
  background-position: -32px 0px;
}
.w2ui-popup .w2ui-popup-close:hover {
  background-color: #ccc;
  border: 1px solid #aaa;
}
.w2ui-popup .w2ui-popup-max {
  background-position: -16px 0px;
}
.w2ui-popup .w2ui-popup-max:hover {
  background-color: #ccc;
  border: 1px solid #aaa;
}
.w2ui-popup .w2ui-box,
.w2ui-popup .w2ui-box-temp {
  position: absolute;
  left: 0px;
  right: 0px;
  top: 32px;
  bottom: 52px;
  z-index: 100;
}
.w2ui-popup .w2ui-popup-body {
  font-size: 12px;
  line-height: 130%;
  padding: 0px 7px 7px 7px;
  color: #000;
  background-color: #eee;
  position: absolute;
  overflow: auto;
  width: 100%;
  height: 100%;
}
.w2ui-popup .w2ui-popup-buttons {
  padding: 12px;
  border-radius: 0px 0px 6px 6px;
  border-top: 1px solid #d5d8d8;
  background-color: #F1F1F1;
  text-align: center;
  position: absolute;
  overflow: hidden;
  height: 52px;
  left: 0px;
  right: 0px;
  bottom: 0px;
  z-index: 200;
}
.w2ui-popup .w2ui-popup-no-title {
  border-top-left-radius: 6px;
  border-top-right-radius: 6px;
  top: 0px !important;
}
.w2ui-popup .w2ui-popup-no-buttons {
  border-bottom-left-radius: 6px;
  border-bottom-right-radius: 6px;
  bottom: 0px !important;
}
.w2ui-popup .w2ui-alert-msg,
.w2ui-popup .w2ui-confirm-msg {
  font-size: 13px;
  line-height: 1.5;
}
.w2ui-popup .w2ui-prompt textarea {
  width: 100%;
  height: 50px;
  resize: none;
}
/*************************************************
* ---- Sidebar ----
*/
.w2ui-sidebar {
  position: relative;
  cursor: default;
  overflow: hidden !important;
  background-color: #fafafa !important;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-sidebar * {
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-sidebar > div {
  position: absolute;
  overflow: hidden;
}
.w2ui-sidebar .w2ui-sidebar-top {
  position: absolute;
  z-index: 2;
  top: 0px;
  left: 0px;
  right: 0px;
}
.w2ui-sidebar .w2ui-sidebar-top .w2ui-flat-left,
.w2ui-sidebar .w2ui-sidebar-top .w2ui-flat-right {
  position: absolute;
  right: 2px;
  top: 2px;
  height: 24px;
  padding: 5px;
  border-radius: 2px;
  background-size: 16px 12px;
  background-position: center center;
  background-repeat: no-repeat;
  background-color: #fafafa;
}
.w2ui-sidebar .w2ui-sidebar-top .w2ui-flat-left:hover,
.w2ui-sidebar .w2ui-sidebar-top .w2ui-flat-right:hover {
  background-color: #f1f1f1;
}
.w2ui-sidebar .w2ui-sidebar-top .w2ui-flat-left {
  left: auto;
  width: 25px;
  background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAQAAADZc7J/AAAAzklEQVR4Ae2THRDEMBCFzy1ucatb3eJ2uhi3uNUtbnGrW9zi1rOdNzdvdl7nDpvYt/9/r7+/51myZZf/zXkD2iMHHRSb0x3oskwMieK05PwEXqP4ExSL0wp0ROao2OOuMPOMdUL6XU1/oGLcFWb+NqyTd2W/P/2qTr9h+nFXhOkHXRHiNyjrgp/U/V+WaQcaNY13zZI0A1JvcVqAnrGDTdtDtZUHjHIJhxxVLN0iqXgCP1l/7h8U9kc6abyJ4/eNWPpGdBv+XdUK0K8cnvcBly2rDr7C1HQAAAAASUVORK5CYII=');
}
.w2ui-sidebar .w2ui-sidebar-top .w2ui-flat-right {
  left: 2px;
  width: auto;
  background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAQAAADZc7J/AAAAz0lEQVR4Ae2UG7TGMBCEr1vd4la3uMUtuli3utWtbnGLW9zi9l/bDMzJG7u12cfJfLunf1+UEC9Bv0vVQwJ8hjRCaZafflb1C9RQf4OD0gSDE+i+PiJAabFhQc1y1AYYsJGLY3lgxM17uWPO56yPiFDqVPWgRtpIHSd1zPnwkBsdI58OlNwx4fP2X0TgfMTOoHSdKOXkpyNvEyQh7ul+4swxJSTQuwNDxz68l/ukVNbu0Neen5Z+KvzWxBAqHds349uPFJ/jVOrPjxUq++OLf+20q5+noXo0AAAAAElFTkSuQmCC');
}
.w2ui-sidebar .w2ui-sidebar-bottom {
  position: absolute;
  z-index: 2;
  bottom: 0px;
  left: 0px;
  right: 0px;
}
.w2ui-sidebar .w2ui-sidebar-body {
  position: absolute;
  z-index: 1;
  overflow: auto;
  top: 0px;
  bottom: 0px;
  left: 0px;
  right: 0px;
  padding: 2px 0px;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  -o-user-select: none;
  user-select: none;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node {
  background-color: transparent;
  border: 1px solid transparent;
  border-radius: 4px;
  margin: 0px 3px;
  padding: 1px 0px;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node .w2ui-node-text,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node .w2ui-node-image,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node .w2ui-node-image > span {
  color: black;
  text-shadow: 0px 0px 0px #fff;
  pointer-events: none;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node .w2ui-node-text:hover,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node .w2ui-node-image:hover,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node .w2ui-node-image > span:hover {
  color: inherit;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node:hover {
  border-top: 1px solid #f9f9f9;
  border-bottom: 1px solid #f9f9f9;
  background-color: #f1f1f1;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node .w2ui-node-image {
  width: 22px;
  text-align: center;
  pointer-events: none;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node .w2ui-node-image > span {
  color: #888 !important;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node input,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node button {
  pointer-events: auto;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected:hover {
  position: relative;
  background-color: #E9E9E9;
  border: 1px solid #dfdfdf;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected .w2ui-node-text,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected:hover .w2ui-node-text,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected .w2ui-node-image,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected:hover .w2ui-node-image,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected .w2ui-node-image > span,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected:hover .w2ui-node-image > span {
  color: inherit !important;
  text-shadow: 0px 0px 0px #fff !important;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-selected:before {
  content: "";
  border: 1px dashed transparent;
  border-radius: 4px;
  position: absolute;
  top: -1px;
  bottom: -1px;
  left: -1px;
  right: -1px;
  pointer-events: none;
}
.w2ui-sidebar .w2ui-sidebar-body.w2ui-focus .w2ui-selected:before {
  border: 1px solid #cccccc;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-disabled,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-disabled:hover {
  background: transparent !important;
  border: 1px solid transparent;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-disabled .w2ui-node-text,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-disabled:hover .w2ui-node-text,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-disabled .w2ui-node-image,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-disabled:hover .w2ui-node-image,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-disabled .w2ui-node-image > span,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-disabled:hover .w2ui-node-image > span {
  opacity: 0.4;
  filter: alpha(opacity=40);
  color: black !important;
  text-shadow: 0px 0px 0px #fff !important;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-text {
  white-space: nowrap;
  padding: 5px 0px 5px 3px;
  margin: 1px 0px 1px 22px;
  position: relative;
  z-index: 1;
  font-size: 12px;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-group {
  white-space: nowrap;
  overflow: hidden;
  padding: 10px 0px 10px 10px;
  margin: 0px;
  cursor: default;
  color: #8fabca;
  background-color: transparent;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-group :nth-child(1) {
  /* show / hide link */
  margin-right: 10px;
  float: right;
  color: transparent;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-group :nth-child(2) {
  /* title text */
  font-weight: normal;
  text-transform: uppercase;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-sub {
  overflow: hidden;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data {
  padding: 2px;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-node-image {
  padding: 3px 0px 0px 0px;
  float: left;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-node-image > span {
  font-size: 16px;
  color: black;
  text-shadow: 0px 0px 0px #fff;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-node-image.w2ui-icon {
  margin-top: 3px;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-node-count {
  float: right;
  border: 1px solid #F6FCF4;
  border-radius: 20px;
  width: auto;
  height: 18px;
  padding: 2px 7px;
  margin: 3px 4px -2px 0;
  background-color: #F2F8F0;
  color: #666;
  box-shadow: 0px 0px 2px #474545;
  text-shadow: 1px 1px 0px #FFF;
  position: relative;
  z-index: 2;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-collapsed,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-expanded {
  float: right;
  width: auto;
  height: 18px;
  position: relative;
  z-index: 2;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-collapsed span,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-expanded span {
  border-color: transparent;
  background-color: transparent;
  box-shadow: none;
  padding: 2px 5px;
  border-radius: 0px;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-collapsed span:after,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-expanded span:after {
  content: "";
  position: absolute;
  border-left: 5px solid #808080;
  border-top: 5px solid transparent;
  border-bottom: 5px solid transparent;
  transform: rotateZ(-90deg);
  pointer-events: none;
  margin-left: -4px;
  margin-top: 7px;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-collapsed span:hover,
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-expanded span:hover {
  border-color: transparent;
  background-color: transparent;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-data .w2ui-collapsed span:after {
  transform: rotateZ(90deg);
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-flat {
  display: block;
  padding: 2px 0px;
  text-align: center;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-flat .w2ui-node-image {
  float: none;
  text-align: center;
  width: auto;
  padding: 1px 0px;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-flat .w2ui-node-image > span {
  font-size: 16px;
  color: black;
  text-shadow: 0px 0px 0px #fff;
}
.w2ui-sidebar .w2ui-sidebar-body .w2ui-node-flat .w2ui-node-image.w2ui-icon {
  width: 21px;
}
/*************************************************
* ---- Tabs ----
*/
.w2ui-tabs {
  cursor: default;
  overflow: hidden !important;
  position: relative;
  background-color: #fafafa;
  padding: 3px 0px;
}
.w2ui-tabs:not(.w2ui-tabs-up) {
  padding-bottom: 0px !important;
}
.w2ui-tabs.w2ui-tabs-up {
  padding-top: 0px !important;
}
.w2ui-tabs table {
  border-bottom: 1px solid silver;
  padding: 0px 7px;
}
.w2ui-tabs .w2ui-tab {
  padding: 6px 20px;
  text-align: center;
  color: black;
  background-color: transparent;
  border: 1px solid silver;
  border-bottom: 1px solid silver;
  white-space: nowrap;
  margin: 1px 1px -1px 0px;
  border-top-left-radius: 4px;
  border-top-right-radius: 4px;
  cursor: default;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  -o-user-select: none;
  user-select: none;
}
.w2ui-tabs .w2ui-tab.active {
  color: black;
  background-color: white;
  border: 1px solid silver;
  border-bottom: 1px solid transparent;
}
.w2ui-tabs .w2ui-tab.closable {
  padding: 6px 28px 6px 20px;
}
.w2ui-tabs .w2ui-tab-close {
  color: #555;
  text-shadow: 1px 1px 1px #bbb;
  float: right;
  margin: 6px 4px 0px 0px;
  padding: 0px 0px 0px 5px;
  width: 16px;
  height: 16px;
  opacity: 0.9;
  border: 0px;
  border-top: 3px solid transparent;
  border-radius: 9px;
}
.w2ui-tabs .w2ui-tab-close:hover {
  background-color: #D77F7F;
  color: white;
}
.w2ui-tabs .w2ui-tab-close:before {
  position: relative;
  top: -2px;
  left: 0px;
  opacity: 0.6;
  color: inherit;
  text-shadow: inherit;
  content: 'x';
}
.w2ui-tabs.w2ui-tabs-up table {
  border-top: 1px solid #c0c0c0;
  border-bottom: 0px;
}
.w2ui-tabs.w2ui-tabs-up .w2ui-tab {
  border-top: 1px solid #C0C0C0;
  margin: -1px 1px 0px 0px;
  border-radius: 0px;
  border-bottom-left-radius: 4px;
  border-bottom-right-radius: 4px;
}
.w2ui-tabs.w2ui-tabs-up .w2ui-tab.active {
  border: 1px solid silver;
  border-top: 1px solid transparent;
}
.w2ui-tabs.w2ui-tabs-up .w2ui-tab-close {
  margin-top: 4px;
}
/*************************************************
* ---- Toolbar ----
*/
.w2ui-toolbar {
  margin: 0px;
  padding: 2px;
  outline: 0px;
  position: relative;
  background-color: #efefef;
  overflow: hidden !important;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  -o-user-select: none;
  user-select: none;
}
.w2ui-toolbar .disabled {
  opacity: 0.3;
  filter: alpha(opacity=30);
}
.w2ui-toolbar table {
  table-layout: auto !important;
}
.w2ui-toolbar table td {
  border: 0px !important;
}
.w2ui-toolbar table.w2ui-button {
  margin: 0 1px 0 0;
  border-radius: 4px;
  height: 24px;
  min-width: 24px;
  border: 1px solid transparent;
  background-color: transparent;
}
.w2ui-toolbar table.w2ui-button .w2ui-tb-image {
  width: 22px;
  height: 16px;
  padding: 0;
  margin: 5px 1px 3px 1px!important;
  border: 0!important;
  text-align: center;
}
.w2ui-toolbar table.w2ui-button .w2ui-tb-image > span {
  font-size: 15px;
  display: block;
  color: #8D99A7;
}
.w2ui-toolbar table.w2ui-button .w2ui-tb-image > span:before {
  vertical-align: top !important;
}
.w2ui-toolbar table.w2ui-button .w2ui-tb-text {
  color: black;
  padding: 0px 4px 0px 2px;
}
.w2ui-toolbar table.w2ui-button .w2ui-tb-count {
  padding: 0px 3px 0px 1px;
}
.w2ui-toolbar table.w2ui-button .w2ui-tb-count > span {
  border: 1px solid #F6FCF4;
  border-radius: 11px;
  width: auto;
  height: 18px;
  padding: 0px 6px 1px 6px;
  background-color: #F2F8F0;
  color: #666;
  box-shadow: 0px 0px 2px #474545;
  text-shadow: 1px 1px 0px #FFF;
}
.w2ui-toolbar table.w2ui-button .w2ui-tb-down {
  padding: 1px 3px 1px 1px;
}
.w2ui-toolbar table.w2ui-button .w2ui-tb-down > div {
  border: 4px solid transparent;
  border-top: 5px solid #8D99A7;
  margin-top: 5px;
}
.w2ui-toolbar table.w2ui-button.over {
  border: 1px solid #ccc;
  background-color: #eee;
}
.w2ui-toolbar table.w2ui-button.over .w2ui-tb-text {
  color: black;
}
.w2ui-toolbar table.w2ui-button.down {
  border: 1px solid #aaa;
  background-color: #ddd;
}
.w2ui-toolbar table.w2ui-button.down .w2ui-tb-text {
  color: #666;
}
.w2ui-toolbar table.w2ui-button.checked {
  border: 1px solid #aaa;
  background-color: white;
}
.w2ui-toolbar table.w2ui-button.checked .w2ui-tb-text {
  color: black;
}
.w2ui-toolbar table.w2ui-button table {
  height: 17px;
  border-radius: 4px;
  cursor: default;
}
.w2ui-toolbar .w2ui-break {
  background-image: -webkit-linear-gradient(top, rgba(153, 153, 153, 0.1) 0%, #999 40%, #999 60%, rgba(153, 153, 153, 0.1) 100%);
  background-image: -moz-linear-gradient(top, rgba(153, 153, 153, 0.1) 0%, #999 40%, #999 60%, rgba(153, 153, 153, 0.1) 100%);
  background-image: -ms-linear-gradient(top, rgba(153, 153, 153, 0.1) 0%, #999 40%, #999 60%, rgba(153, 153, 153, 0.1) 100%);
  background-image: -o-linear-gradient(top, rgba(153, 153, 153, 0.1) 0%, #999 40%, #999 60%, rgba(153, 153, 153, 0.1) 100%);
  background-image: linear-gradient(to bottom, rgba(153, 153, 153, 0.1) 0%, #999 40%, #999 60%, rgba(153, 153, 153, 0.1) 100%);
  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff999999', endColorstr='#ff999999', GradientType=0);
  width: 1px !important;
  height: 22px;
  padding: 0px;
  margin: 0px 6px;
}
.w2ui-listview {
  overflow: auto !important;
  background-color: white !important;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-listview * {
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  -ms-box-sizing: border-box;
  -o-box-sizing: border-box;
  box-sizing: border-box;
}
.w2ui-listview > ul {
  list-style-type: none;
  margin: 0;
  cursor: default;
}
.w2ui-listview > ul > li {
  display: inline-block;
  vertical-align: top;
  overflow: hidden;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  -o-user-select: none;
  user-select: none;
  border: 1px solid transparent;
  border-radius: 4px;
}
.w2ui-listview > ul > li.w2ui-focused {
  border: 1px solid #2661A6;
}
.w2ui-listview > ul > li.w2ui-selected {
  border: 1px solid #2661A6;
}
.w2ui-listview > ul > li.w2ui-selected,
.w2ui-listview > ul > li.w2ui-selected.hover {
  background-color: #E9E9E9;
}
.w2ui-listview > ul > li.w2ui-selected > div > div.caption,
.w2ui-listview > ul > li.w2ui-selected.hover > div > div.caption {
  color: inherit;
}
.w2ui-listview > ul > li.w2ui-selected > div > div.description,
.w2ui-listview > ul > li.w2ui-selected.hover > div > div.description {
  color: #DDDDDD;
}
.w2ui-listview > ul > li.w2ui-selected > div > div.extra > div > div,
.w2ui-listview > ul > li.w2ui-selected.hover > div > div.extra > div > div {
  color: #DDDDDD;
}
.w2ui-listview > ul > li.hover {
  background-color: #f1f1f1;
  border: 1px solid #2661A6;
}
.w2ui-listview > ul > li div {
  vertical-align: middle;
}
.w2ui-listview > ul > li > div > div.caption {
  display: block;
  text-align: center;
  word-wrap: break-word;
  max-height: 50px;
  color: black;
  font-size: 12px;
}
.w2ui-listview > ul > li > div > div.description {
  display: none;
  text-align: left;
  color: #777777;
  font-size: 12px;
}
.w2ui-listview > ul > li > div > div.extra {
  display: none;
}
.w2ui-listview > ul > li > div > div.extra > div > div {
  color: #777777;
}
.w2ui-icon-small > ul {
  padding: 1px 0px 0px 1px;
}
.w2ui-icon-small > ul > li {
  margin: 0px 1px 1px 0px;
  padding: 2px;
  width: 250px;
  white-space: nowrap;
}
.w2ui-icon-small > ul > li > div > div.w2ui-listview-img {
  display: inline-block;
  width: 26px;
  height: 22px;
  font-size: 21px;
  margin-right: 2px;
}
.w2ui-icon-small > ul > li > div > div.caption {
  display: inline-block;
}
.w2ui-icon-medium > ul {
  padding: 4px 0px 0px 4px;
}
.w2ui-icon-medium > ul > li {
  margin: 0px 4px 4px 0px;
  padding: 4px;
  width: 100px;
}
.w2ui-icon-medium > ul > li > div > div.w2ui-listview-img {
  display: block;
  width: 92px;
  height: 60px;
  font-size: 57px;
  margin-left: auto;
  margin-right: auto;
  background-position: center;
}
.w2ui-icon-large > ul {
  padding: 4px 0px 0px 4px;
}
.w2ui-icon-large > ul > li {
  margin: 0px 4px 4px 0px;
  padding: 4px;
  width: 160px;
}
.w2ui-icon-large > ul > li > div > div.w2ui-listview-img {
  display: block;
  width: 152px;
  height: 120px;
  font-size: 114px;
  margin-left: auto;
  margin-right: auto;
  background-position: center;
}
.w2ui-icon-tile > ul {
  padding: 1px 0px 0px 1px;
}
.w2ui-icon-tile > ul > li {
  margin: 0px 1px 1px 0px;
  padding: 4px;
  width: 250px;
  white-space: nowrap;
}
.w2ui-icon-tile > ul > li > div > div.w2ui-listview-img {
  display: inline-block;
  width: 72px;
  height: 60px;
  font-size: 57px;
  float: left;
  margin-right: 4px;
}
.w2ui-icon-tile > ul > li > div > div.caption {
  text-align: left;
}
.w2ui-icon-tile > ul > li > div > div.description {
  display: block;
}
.w2ui-table > ul {
  padding: 0;
}
.w2ui-table > ul > li {
  width: 100%;
  padding: 2px;
  border-radius: 0px;
  border-bottom: 1px dotted lightgray;
}
.w2ui-table > ul > li > div {
  display: inline-block;
  position: relative;
  width: 100%;
  white-space: nowrap;
  overflow: hidden;
}
.w2ui-table > ul > li > div > div.w2ui-listview-img {
  display: inline-block;
  width: 38px;
  height: 32px;
  font-size: 31px;
  margin-right: 2px;
}
.w2ui-table > ul > li > div > div.caption {
  display: inline-block;
}
.w2ui-table > ul > li > div > div.extra {
  display: inline-block;
  position: absolute;
  right: 0;
  height: 100%;
  background-color: white;
}
.w2ui-table > ul > li > div > div.extra > div:before {
  display: inline-block;
  height: 100%;
  width: 0;
  content: '';
  vertical-align: middle;
}
.w2ui-table > ul > li > div > div.extra > div {
  display: inline;
}
.w2ui-table > ul > li > div > div.extra > div > div {
  display: inline-block;
  font-size: 12px;
}
.w2ui-table > ul > li.w2ui-selected div.extra,
.w2ui-table > ul > li.w2ui-selected.hover div.extra {
  background-color: #E9E9E9;
}
.w2ui-table > ul > li.hover div.extra {
  background-color: #f1f1f1;
}
.w2ui-listview > ul > li div.icon-none {
  border: 1px solid rgba(102, 102, 102, 0.35);
}
",
{"status":false}
],

[
"uikit.min.css_3.2.0",
"/*! UIkit 3.2.0 | http://www.getuikit.com | (c) 2014 - 2019 YOOtheme | MIT License */html{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";font-size:16px;font-weight:400;line-height:1.5;-webkit-text-size-adjust:100%;background:#fff;color:#666}body{margin:0}a:active,a:hover{outline:0}.uk-link,a{color:#1e87f0;text-decoration:none;cursor:pointer}.uk-link-toggle:focus .uk-link,.uk-link-toggle:hover .uk-link,.uk-link:hover,a:hover{color:#0f6ecd;text-decoration:underline}abbr[title]{text-decoration:underline dotted;-webkit-text-decoration-style:dotted}b,strong{font-weight:bolder}:not(pre)>code,:not(pre)>kbd,:not(pre)>samp{font-family:Consolas,monaco,monospace;font-size:.875rem;color:#f0506e;white-space:nowrap;padding:2px 6px;background:#f8f8f8}em{color:#f0506e}ins{background:#ffd;color:#666;text-decoration:none}mark{background:#ffd;color:#666}q{font-style:italic}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}audio,canvas,iframe,img,svg,video{vertical-align:middle}canvas,img,video{max-width:100%;height:auto;box-sizing:border-box}@supports (display:block){svg{max-width:100%;height:auto;box-sizing:border-box}}svg:not(:root){overflow:hidden}img:not([src]){min-width:1px;visibility:hidden}iframe{border:0}address,dl,fieldset,figure,ol,p,pre,ul{margin:0 0 20px 0}*+address,*+dl,*+fieldset,*+figure,*+ol,*+p,*+pre,*+ul{margin-top:20px}.uk-h1,.uk-h2,.uk-h3,.uk-h4,.uk-h5,.uk-h6,.uk-heading-2xlarge,.uk-heading-large,.uk-heading-medium,.uk-heading-small,.uk-heading-xlarge,h1,h2,h3,h4,h5,h6{margin:0 0 20px 0;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";font-weight:400;color:#333;text-transform:none}*+.uk-h1,*+.uk-h2,*+.uk-h3,*+.uk-h4,*+.uk-h5,*+.uk-h6,*+.uk-heading-2xlarge,*+.uk-heading-large,*+.uk-heading-medium,*+.uk-heading-small,*+.uk-heading-xlarge,*+h1,*+h2,*+h3,*+h4,*+h5,*+h6{margin-top:40px}.uk-h1,h1{font-size:2.23125rem;line-height:1.2}.uk-h2,h2{font-size:1.7rem;line-height:1.3}.uk-h3,h3{font-size:1.5rem;line-height:1.4}.uk-h4,h4{font-size:1.25rem;line-height:1.4}.uk-h5,h5{font-size:16px;line-height:1.4}.uk-h6,h6{font-size:.875rem;line-height:1.4}@media (min-width:960px){.uk-h1,h1{font-size:2.625rem}.uk-h2,h2{font-size:2rem}}ol,ul{padding-left:30px}ol>li>ol,ol>li>ul,ul>li>ol,ul>li>ul{margin:0}dt{font-weight:700}dd{margin-left:0}.uk-hr,hr{overflow:visible;text-align:inherit;margin:0 0 20px 0;border:0;border-top:1px solid #e5e5e5}*+.uk-hr,*+hr{margin-top:20px}address{font-style:normal}blockquote{margin:0 0 20px 0;font-size:1.25rem;line-height:1.5;font-style:italic;color:#333}*+blockquote{margin-top:20px}blockquote p:last-of-type{margin-bottom:0}blockquote footer{margin-top:10px;font-size:.875rem;line-height:1.5;color:#666}blockquote footer::before{content:"тАФ "}pre{font:.875rem/1.5 Consolas,monaco,monospace;color:#666;-moz-tab-size:4;tab-size:4;overflow:auto;padding:10px;border:1px solid #e5e5e5;border-radius:3px;background:#fff}pre code{font-family:Consolas,monaco,monospace}::selection{background:#39f;color:#fff;text-shadow:none}details,main{display:block}summary{display:list-item}template{display:none}.uk-breakpoint-s::before{content:'640px'}.uk-breakpoint-m::before{content:'960px'}.uk-breakpoint-l::before{content:'1200px'}.uk-breakpoint-xl::before{content:'1600px'}:root{--uk-breakpoint-s:640px;--uk-breakpoint-m:960px;--uk-breakpoint-l:1200px;--uk-breakpoint-xl:1600px}.uk-link-muted a,a.uk-link-muted{color:#999}.uk-link-muted a:hover,.uk-link-toggle:focus .uk-link-muted,.uk-link-toggle:hover .uk-link-muted,a.uk-link-muted:hover{color:#666}.uk-link-text a,a.uk-link-text{color:inherit}.uk-link-text a:hover,.uk-link-toggle:focus .uk-link-text,.uk-link-toggle:hover .uk-link-text,a.uk-link-text:hover{color:#999}.uk-link-heading a,a.uk-link-heading{color:inherit}.uk-link-heading a:hover,.uk-link-toggle:focus .uk-link-heading,.uk-link-toggle:hover .uk-link-heading,a.uk-link-heading:hover{color:#1e87f0;text-decoration:none}.uk-link-reset a,a.uk-link-reset{color:inherit!important;text-decoration:none!important}.uk-link-toggle{color:inherit!important;text-decoration:none!important}.uk-link-toggle:focus{outline:0}.uk-heading-small{font-size:2.6rem;line-height:1.2}.uk-heading-medium{font-size:2.8875rem;line-height:1.1}.uk-heading-large{font-size:3.4rem;line-height:1.1}.uk-heading-xlarge{font-size:4rem;line-height:1}.uk-heading-2xlarge{font-size:6rem;line-height:1}@media (min-width:960px){.uk-heading-small{font-size:3.25rem}.uk-heading-medium{font-size:3.5rem}.uk-heading-large{font-size:4rem}.uk-heading-xlarge{font-size:6rem}.uk-heading-2xlarge{font-size:8rem}}@media (min-width:1200px){.uk-heading-medium{font-size:4rem}.uk-heading-large{font-size:6rem}.uk-heading-xlarge{font-size:8rem}.uk-heading-2xlarge{font-size:11rem}}.uk-heading-divider{padding-bottom:calc(5px + .1em);border-bottom:calc(.2px + .05em) solid #e5e5e5}.uk-heading-bullet{position:relative}.uk-heading-bullet::before{content:"";display:inline-block;position:relative;top:calc(-.1 * 1em);vertical-align:middle;height:calc(4px + .7em);margin-right:calc(5px + .2em);border-left:calc(5px + .1em) solid #e5e5e5}.uk-heading-line{overflow:hidden}.uk-heading-line>*{display:inline-block;position:relative}.uk-heading-line>::after,.uk-heading-line>::before{content:"";position:absolute;top:calc(50% - ((.2px + .05em)/ 2));width:2000px;border-bottom:calc(.2px + .05em) solid #e5e5e5}.uk-heading-line>::before{right:100%;margin-right:calc(5px + .3em)}.uk-heading-line>::after{left:100%;margin-left:calc(5px + .3em)}[class*=uk-divider]{border:none;margin-bottom:20px}*+[class*=uk-divider]{margin-top:20px}.uk-divider-icon{position:relative;height:20px;background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2220%22%20height%3D%2220%22%20viewBox%3D%220%200%2020%2020%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22none%22%20stroke%3D%22%23e5e5e5%22%20stroke-width%3D%222%22%20cx%3D%2210%22%20cy%3D%2210%22%20r%3D%227%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");background-repeat:no-repeat;background-position:50% 50%}.uk-divider-icon::after,.uk-divider-icon::before{content:"";position:absolute;top:50%;max-width:calc(50% - (50px / 2));border-bottom:1px solid #e5e5e5}.uk-divider-icon::before{right:calc(50% + (50px / 2));width:100%}.uk-divider-icon::after{left:calc(50% + (50px / 2));width:100%}.uk-divider-small{line-height:0}.uk-divider-small::after{content:"";display:inline-block;width:100px;max-width:100%;border-top:1px solid #e5e5e5;vertical-align:top}.uk-divider-vertical{width:1px;height:100px;margin-left:auto;margin-right:auto;border-left:1px solid #e5e5e5}.uk-list{padding:0;list-style:none}.uk-list>li::after,.uk-list>li::before{content:"";display:table}.uk-list>li::after{clear:both}.uk-list>li>:last-child{margin-bottom:0}.uk-list ul{margin:0;padding-left:30px;list-style:none}.uk-list>li:nth-child(n+2),.uk-list>li>ul{margin-top:10px}.uk-list-divider>li:nth-child(n+2){margin-top:10px;padding-top:10px;border-top:1px solid #e5e5e5}.uk-list-striped>li{padding:10px 10px}.uk-list-striped>li:nth-of-type(odd){border-top:1px solid #e5e5e5;border-bottom:1px solid #e5e5e5}.uk-list-striped>li:nth-of-type(odd){background:#f8f8f8}.uk-list-striped>li:nth-child(n+2){margin-top:0}.uk-list-bullet>li{position:relative;padding-left:calc(1.5em + 10px)}.uk-list-bullet>li::before{content:"";position:absolute;top:0;left:0;width:1.5em;height:1.5em;background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%226%22%20height%3D%226%22%20viewBox%3D%220%200%206%206%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22%23666%22%20cx%3D%223%22%20cy%3D%223%22%20r%3D%223%22%20%2F%3E%0A%3C%2Fsvg%3E");background-repeat:no-repeat;background-position:50% 50%;display:block}.uk-list-large>li:nth-child(n+2),.uk-list-large>li>ul{margin-top:20px}.uk-list-large.uk-list-divider>li:nth-child(n+2){margin-top:20px;padding-top:20px}.uk-list-large.uk-list-striped>li{padding:20px 10px}.uk-list-large.uk-list-striped>li:nth-of-type(odd){border-top:1px solid #e5e5e5;border-bottom:1px solid #e5e5e5}.uk-list-large.uk-list-striped>li:nth-child(n+2){margin-top:0}.uk-description-list>dt{color:#333;font-size:.875rem;font-weight:400;text-transform:uppercase}.uk-description-list>dt:nth-child(n+2){margin-top:20px}.uk-description-list-divider>dt:nth-child(n+2){margin-top:20px;padding-top:20px;border-top:1px solid #e5e5e5}.uk-table{border-collapse:collapse;border-spacing:0;width:100%;margin-bottom:20px}*+.uk-table{margin-top:20px}.uk-table th{padding:16px 12px;text-align:left;vertical-align:bottom;font-size:.875rem;font-weight:400;color:#999;text-transform:uppercase}.uk-table td{padding:16px 12px;vertical-align:top}.uk-table td>:last-child{margin-bottom:0}.uk-table tfoot{font-size:.875rem}.uk-table caption{font-size:.875rem;text-align:left;color:#999}.uk-table-middle,.uk-table-middle td{vertical-align:middle!important}.uk-table-divider>:first-child>tr:not(:first-child),.uk-table-divider>:not(:first-child)>tr,.uk-table-divider>tr:not(:first-child){border-top:1px solid #e5e5e5}.uk-table-striped tbody tr:nth-of-type(odd),.uk-table-striped>tr:nth-of-type(odd){background:#f8f8f8;border-top:1px solid #e5e5e5;border-bottom:1px solid #e5e5e5}.uk-table-hover tbody tr:hover,.uk-table-hover>tr:hover{background:#ffd}.uk-table tbody tr.uk-active,.uk-table>tr.uk-active{background:#ffd}.uk-table-small td,.uk-table-small th{padding:10px 12px}.uk-table-large td,.uk-table-large th{padding:22px 12px}.uk-table-justify td:first-child,.uk-table-justify th:first-child{padding-left:0}.uk-table-justify td:last-child,.uk-table-justify th:last-child{padding-right:0}.uk-table-shrink{width:1px}.uk-table-expand{min-width:150px}.uk-table-link{padding:0!important}.uk-table-link>a{display:block;padding:16px 12px}.uk-table-small .uk-table-link>a{padding:10px 12px}@media (max-width:959px){.uk-table-responsive,.uk-table-responsive tbody,.uk-table-responsive td,.uk-table-responsive th,.uk-table-responsive tr{display:block}.uk-table-responsive thead{display:none}.uk-table-responsive td,.uk-table-responsive th{width:auto!important;max-width:none!important;min-width:0!important;overflow:visible!important;white-space:normal!important}.uk-table-responsive .uk-table-link:not(:first-child)>a,.uk-table-responsive td:not(:first-child):not(.uk-table-link),.uk-table-responsive th:not(:first-child):not(.uk-table-link){padding-top:5px!important}.uk-table-responsive .uk-table-link:not(:last-child)>a,.uk-table-responsive td:not(:last-child):not(.uk-table-link),.uk-table-responsive th:not(:last-child):not(.uk-table-link){padding-bottom:5px!important}.uk-table-justify.uk-table-responsive td,.uk-table-justify.uk-table-responsive th{padding-left:0;padding-right:0}}.uk-table tbody tr{transition:background-color .1s linear}.uk-icon{margin:0;border:none;border-radius:0;overflow:visible;font:inherit;color:inherit;text-transform:none;padding:0;background-color:transparent;display:inline-block;fill:currentcolor;line-height:0}button.uk-icon:not(:disabled){cursor:pointer}.uk-icon::-moz-focus-inner{border:0;padding:0}.uk-icon:not(.uk-preserve) [fill*='#']:not(.uk-preserve){fill:currentcolor}.uk-icon:not(.uk-preserve) [stroke*='#']:not(.uk-preserve){stroke:currentcolor}.uk-icon>*{transform:translate(0,0)}.uk-icon-image{width:20px;height:20px;background-position:50% 50%;background-repeat:no-repeat;background-size:contain;vertical-align:middle}.uk-icon-link{color:#999}.uk-icon-link:focus,.uk-icon-link:hover{color:#666;outline:0}.uk-active>.uk-icon-link,.uk-icon-link:active{color:#595959}.uk-icon-button{box-sizing:border-box;width:36px;height:36px;border-radius:500px;background:#f8f8f8;color:#999;vertical-align:middle;display:inline-flex;justify-content:center;align-items:center;transition:.1s ease-in-out;transition-property:color,background-color}.uk-icon-button:focus,.uk-icon-button:hover{background-color:#ebebeb;color:#666;outline:0}.uk-active>.uk-icon-button,.uk-icon-button:active{background-color:#dfdfdf;color:#666}.uk-range{box-sizing:border-box;margin:0;vertical-align:middle;max-width:100%;width:100%;-webkit-appearance:none;background:0 0;padding:0}.uk-range:focus{outline:0}.uk-range::-moz-focus-outer{border:none}.uk-range::-ms-track{height:15px;background:0 0;border-color:transparent;color:transparent}.uk-range:not(:disabled)::-webkit-slider-thumb{cursor:pointer}.uk-range:not(:disabled)::-moz-range-thumb{cursor:pointer}.uk-range:not(:disabled)::-ms-thumb{cursor:pointer}.uk-range::-webkit-slider-thumb{-webkit-appearance:none;margin-top:-7px;height:15px;width:15px;border-radius:500px;background:#fff;border:1px solid #ccc}.uk-range::-moz-range-thumb{border:none;height:15px;width:15px;border-radius:500px;background:#fff;border:1px solid #ccc}.uk-range::-ms-thumb{margin-top:0}.uk-range::-ms-thumb{border:none;height:15px;width:15px;border-radius:500px;background:#fff;border:1px solid #ccc}.uk-range::-ms-tooltip{display:none}.uk-range::-webkit-slider-runnable-track{height:3px;background:#ebebeb;border-radius:500px}.uk-range:active::-webkit-slider-runnable-track,.uk-range:focus::-webkit-slider-runnable-track{background:#d2d2d2}.uk-range::-moz-range-track{height:3px;background:#ebebeb;border-radius:500px}.uk-range:focus::-moz-range-track{background:#d2d2d2}.uk-range::-ms-fill-lower,.uk-range::-ms-fill-upper{height:3px;background:#ebebeb;border-radius:500px}.uk-range:focus::-ms-fill-lower,.uk-range:focus::-ms-fill-upper{background:#d2d2d2}.uk-checkbox,.uk-input,.uk-radio,.uk-select,.uk-textarea{box-sizing:border-box;margin:0;border-radius:0;font:inherit}.uk-input{overflow:visible}.uk-select{text-transform:none}.uk-select optgroup{font:inherit;font-weight:700}.uk-textarea{overflow:auto}.uk-input[type=search]::-webkit-search-cancel-button,.uk-input[type=search]::-webkit-search-decoration{-webkit-appearance:none}.uk-input[type=number]::-webkit-inner-spin-button,.uk-input[type=number]::-webkit-outer-spin-button{height:auto}.uk-input::-moz-placeholder,.uk-textarea::-moz-placeholder{opacity:1}.uk-checkbox:not(:disabled),.uk-radio:not(:disabled){cursor:pointer}.uk-fieldset{border:none;margin:0;padding:0}.uk-input,.uk-textarea{-webkit-appearance:none}.uk-input,.uk-select,.uk-textarea{max-width:100%;width:100%;border:0 none;padding:0 10px;background:#fff;color:#666;border:1px solid #e5e5e5;transition:.2s ease-in-out;transition-property:color,background-color,border}.uk-input,.uk-select:not([multiple]):not([size]){height:40px;vertical-align:middle;display:inline-block}.uk-input:not(input),.uk-select:not(select){line-height:38px}.uk-select[multiple],.uk-select[size],.uk-textarea{padding-top:4px;padding-bottom:4px;vertical-align:top}.uk-input:focus,.uk-select:focus,.uk-textarea:focus{outline:0;background-color:#fff;color:#666;border-color:#1e87f0}.uk-input:disabled,.uk-select:disabled,.uk-textarea:disabled{background-color:#f8f8f8;color:#999;border-color:#e5e5e5}.uk-input::-ms-input-placeholder{color:#999!important}.uk-input::placeholder{color:#999}.uk-textarea::-ms-input-placeholder{color:#999!important}.uk-textarea::placeholder{color:#999}.uk-form-small{font-size:.875rem}.uk-form-small:not(textarea):not([multiple]):not([size]){height:30px;padding-left:8px;padding-right:8px}.uk-form-small:not(select):not(input):not(textarea){line-height:28px}.uk-form-large{font-size:1.25rem}.uk-form-large:not(textarea):not([multiple]):not([size]){height:55px;padding-left:12px;padding-right:12px}.uk-form-large:not(select):not(input):not(textarea){line-height:53px}.uk-form-danger,.uk-form-danger:focus{color:#f0506e;border-color:#f0506e}.uk-form-success,.uk-form-success:focus{color:#32d296;border-color:#32d296}.uk-form-blank{background:0 0;border-color:transparent}.uk-form-blank:focus{border-color:#e5e5e5;border-style:dashed}input.uk-form-width-xsmall{width:50px}select.uk-form-width-xsmall{width:75px}.uk-form-width-small{width:130px}.uk-form-width-medium{width:200px}.uk-form-width-large{width:500px}.uk-select:not([multiple]):not([size]){-webkit-appearance:none;-moz-appearance:none;padding-right:20px;background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23666%22%20points%3D%2212%201%209%206%2015%206%22%20%2F%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23666%22%20points%3D%2212%2013%209%208%2015%208%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");background-repeat:no-repeat;background-position:100% 50%}.uk-select:not([multiple]):not([size])::-ms-expand{display:none}.uk-select:not([multiple]):not([size]) option{color:#444}.uk-select:not([multiple]):not([size]):disabled{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23999%22%20points%3D%2212%201%209%206%2015%206%22%20%2F%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23999%22%20points%3D%2212%2013%209%208%2015%208%22%20%2F%3E%0A%3C%2Fsvg%3E%0A")}.uk-input[list]{padding-right:20px;background-repeat:no-repeat;background-position:100% 50%}.uk-input[list]:focus,.uk-input[list]:hover{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23666%22%20points%3D%2212%2012%208%206%2016%206%22%20%2F%3E%0A%3C%2Fsvg%3E%0A")}.uk-input[list]::-webkit-calendar-picker-indicator{display:none}.uk-checkbox,.uk-radio{display:inline-block;height:16px;width:16px;overflow:hidden;margin-top:-4px;vertical-align:middle;-webkit-appearance:none;-moz-appearance:none;background-color:transparent;background-repeat:no-repeat;background-position:50% 50%;border:1px solid #ccc;transition:.2s ease-in-out;transition-property:background-color,border}.uk-radio{border-radius:50%}.uk-checkbox:focus,.uk-radio:focus{outline:0;border-color:#1e87f0}.uk-checkbox:checked,.uk-checkbox:indeterminate,.uk-radio:checked{background-color:#1e87f0;border-color:transparent}.uk-checkbox:checked:focus,.uk-checkbox:indeterminate:focus,.uk-radio:checked:focus{background-color:#0e6dcd}.uk-radio:checked{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22%23fff%22%20cx%3D%228%22%20cy%3D%228%22%20r%3D%222%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-checkbox:checked{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2211%22%20viewBox%3D%220%200%2014%2011%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23fff%22%20points%3D%2212%201%205%207.5%202%205%201%205.5%205%2010%2013%201.5%22%20%2F%3E%0A%3C%2Fsvg%3E%0A")}.uk-checkbox:indeterminate{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23fff%22%20x%3D%223%22%20y%3D%228%22%20width%3D%2210%22%20height%3D%221%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-checkbox:disabled,.uk-radio:disabled{background-color:#f8f8f8;border-color:#e5e5e5}.uk-radio:disabled:checked{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22%23999%22%20cx%3D%228%22%20cy%3D%228%22%20r%3D%222%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-checkbox:disabled:checked{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2211%22%20viewBox%3D%220%200%2014%2011%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23999%22%20points%3D%2212%201%205%207.5%202%205%201%205.5%205%2010%2013%201.5%22%20%2F%3E%0A%3C%2Fsvg%3E%0A")}.uk-checkbox:disabled:indeterminate{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23999%22%20x%3D%223%22%20y%3D%228%22%20width%3D%2210%22%20height%3D%221%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-legend{width:100%;color:inherit;padding:0;font-size:1.5rem;line-height:1.4}.uk-form-custom{display:inline-block;position:relative;max-width:100%;vertical-align:middle}.uk-form-custom input[type=file],.uk-form-custom select{position:absolute;top:0;z-index:1;width:100%;height:100%;left:0;-webkit-appearance:none;opacity:0;cursor:pointer}.uk-form-custom input[type=file]{font-size:500px;overflow:hidden}.uk-form-label{color:#333;font-size:.875rem}.uk-form-stacked .uk-form-label{display:block;margin-bottom:5px}@media (max-width:959px){.uk-form-horizontal .uk-form-label{display:block;margin-bottom:5px}}@media (min-width:960px){.uk-form-horizontal .uk-form-label{width:200px;margin-top:7px;float:left}.uk-form-horizontal .uk-form-controls{margin-left:215px}.uk-form-horizontal .uk-form-controls-text{padding-top:7px}}.uk-form-icon{position:absolute;top:0;bottom:0;left:0;width:40px;display:inline-flex;justify-content:center;align-items:center;color:#999}.uk-form-icon:hover{color:#666}.uk-form-icon:not(a):not(button):not(input){pointer-events:none}.uk-form-icon:not(.uk-form-icon-flip)~.uk-input{padding-left:40px!important}.uk-form-icon-flip{right:0;left:auto}.uk-form-icon-flip~.uk-input{padding-right:40px!important}.uk-button{margin:0;border:none;overflow:visible;font:inherit;color:inherit;text-transform:none;display:inline-block;box-sizing:border-box;padding:0 30px;vertical-align:middle;font-size:.875rem;line-height:38px;text-align:center;text-decoration:none;text-transform:uppercase;transition:.1s ease-in-out;transition-property:color,background-color,border-color}.uk-button:not(:disabled){cursor:pointer}.uk-button::-moz-focus-inner{border:0;padding:0}.uk-button:hover{text-decoration:none}.uk-button:focus{outline:0}.uk-button-default{background-color:transparent;color:#333;border:1px solid #e5e5e5}.uk-button-default:focus,.uk-button-default:hover{background-color:transparent;color:#333;border-color:#b2b2b2}.uk-button-default.uk-active,.uk-button-default:active{background-color:transparent;color:#333;border-color:#999}.uk-button-primary{background-color:#1e87f0;color:#fff;border:1px solid transparent}.uk-button-primary:focus,.uk-button-primary:hover{background-color:#0f7ae5;color:#fff}.uk-button-primary.uk-active,.uk-button-primary:active{background-color:#0e6dcd;color:#fff}.uk-button-secondary{background-color:#222;color:#fff;border:1px solid transparent}.uk-button-secondary:focus,.uk-button-secondary:hover{background-color:#151515;color:#fff}.uk-button-secondary.uk-active,.uk-button-secondary:active{background-color:#080808;color:#fff}.uk-button-danger{background-color:#f0506e;color:#fff;border:1px solid transparent}.uk-button-danger:focus,.uk-button-danger:hover{background-color:#ee395b;color:#fff}.uk-button-danger.uk-active,.uk-button-danger:active{background-color:#ec2147;color:#fff}.uk-button-danger:disabled,.uk-button-default:disabled,.uk-button-primary:disabled,.uk-button-secondary:disabled{background-color:transparent;color:#999;border-color:#e5e5e5}.uk-button-small{padding:0 15px;line-height:28px;font-size:.875rem}.uk-button-large{padding:0 40px;line-height:53px;font-size:.875rem}.uk-button-text{padding:0;line-height:1.5;background:0 0;color:#333;position:relative}.uk-button-text::before{content:"";position:absolute;bottom:0;left:0;right:100%;border-bottom:1px solid #333;transition:right .3s ease-out}.uk-button-text:focus,.uk-button-text:hover{color:#333}.uk-button-text:focus::before,.uk-button-text:hover::before{right:0}.uk-button-text:disabled{color:#999}.uk-button-text:disabled::before{display:none}.uk-button-link{padding:0;line-height:1.5;background:0 0;color:#1e87f0}.uk-button-link:focus,.uk-button-link:hover{color:#0f6ecd;text-decoration:underline}.uk-button-link:disabled{color:#999;text-decoration:none}.uk-button-group{display:inline-flex;vertical-align:middle;position:relative}.uk-button-group>.uk-button:nth-child(n+2),.uk-button-group>div:nth-child(n+2) .uk-button{margin-left:-1px}.uk-button-group .uk-button.uk-active,.uk-button-group .uk-button:active,.uk-button-group .uk-button:focus,.uk-button-group .uk-button:hover{position:relative;z-index:1}.uk-section{box-sizing:border-box;padding-top:40px;padding-bottom:40px}@media (min-width:960px){.uk-section{padding-top:70px;padding-bottom:70px}}.uk-section::after,.uk-section::before{content:"";display:table}.uk-section::after{clear:both}.uk-section>:last-child{margin-bottom:0}.uk-section-xsmall{padding-top:20px;padding-bottom:20px}.uk-section-small{padding-top:40px;padding-bottom:40px}.uk-section-large{padding-top:70px;padding-bottom:70px}@media (min-width:960px){.uk-section-large{padding-top:140px;padding-bottom:140px}}.uk-section-xlarge{padding-top:140px;padding-bottom:140px}@media (min-width:960px){.uk-section-xlarge{padding-top:210px;padding-bottom:210px}}.uk-section-default{background:#fff}.uk-section-muted{background:#f8f8f8}.uk-section-primary{background:#1e87f0}.uk-section-secondary{background:#222}.uk-container{box-sizing:content-box;max-width:1200px;margin-left:auto;margin-right:auto;padding-left:15px;padding-right:15px}@media (min-width:640px){.uk-container{padding-left:30px;padding-right:30px}}@media (min-width:960px){.uk-container{padding-left:40px;padding-right:40px}}.uk-container::after,.uk-container::before{content:"";display:table}.uk-container::after{clear:both}.uk-container>:last-child{margin-bottom:0}.uk-container .uk-container{padding-left:0;padding-right:0}.uk-container-xsmall{max-width:750px}.uk-container-small{max-width:900px}.uk-container-large{max-width:1600px}.uk-container-expand{max-width:none}.uk-container-expand-left{margin-left:0}.uk-container-expand-right{margin-right:0}@media (min-width:640px){.uk-container-expand-left.uk-container-xsmall,.uk-container-expand-right.uk-container-xsmall{max-width:calc(50% + (750px / 2) - 30px)}.uk-container-expand-left.uk-container-small,.uk-container-expand-right.uk-container-small{max-width:calc(50% + (900px / 2) - 30px)}}@media (min-width:960px){.uk-container-expand-left,.uk-container-expand-right{max-width:calc(50% + (1200px / 2) - 40px)}.uk-container-expand-left.uk-container-xsmall,.uk-container-expand-right.uk-container-xsmall{max-width:calc(50% + (750px / 2) - 40px)}.uk-container-expand-left.uk-container-small,.uk-container-expand-right.uk-container-small{max-width:calc(50% + (900px / 2) - 40px)}.uk-container-expand-left.uk-container-large,.uk-container-expand-right.uk-container-large{max-width:calc(50% + (1600px / 2) - 40px)}}.uk-container-item-padding-remove-left,.uk-container-item-padding-remove-right{width:calc(100% + 15px)}.uk-container-item-padding-remove-left{margin-left:-15px}.uk-container-item-padding-remove-right{margin-right:-15px}@media (min-width:640px){.uk-container-item-padding-remove-left,.uk-container-item-padding-remove-right{width:calc(100% + 30px)}.uk-container-item-padding-remove-left{margin-left:-30px}.uk-container-item-padding-remove-right{margin-right:-30px}}@media (min-width:960px){.uk-container-item-padding-remove-left,.uk-container-item-padding-remove-right{width:calc(100% + 40px)}.uk-container-item-padding-remove-left{margin-left:-40px}.uk-container-item-padding-remove-right{margin-right:-40px}}.uk-grid{display:flex;flex-wrap:wrap;margin:0;padding:0;list-style:none}.uk-grid>*{margin:0}.uk-grid>*>:last-child{margin-bottom:0}.uk-grid{margin-left:-30px}.uk-grid>*{padding-left:30px}*+.uk-grid-margin,.uk-grid+.uk-grid,.uk-grid>.uk-grid-margin{margin-top:30px}@media (min-width:1200px){.uk-grid{margin-left:-40px}.uk-grid>*{padding-left:40px}*+.uk-grid-margin,.uk-grid+.uk-grid,.uk-grid>.uk-grid-margin{margin-top:40px}}.uk-grid-column-small,.uk-grid-small{margin-left:-15px}.uk-grid-column-small>*,.uk-grid-small>*{padding-left:15px}*+.uk-grid-margin-small,.uk-grid+.uk-grid-row-small,.uk-grid+.uk-grid-small,.uk-grid-row-small>.uk-grid-margin,.uk-grid-small>.uk-grid-margin{margin-top:15px}.uk-grid-column-medium,.uk-grid-medium{margin-left:-30px}.uk-grid-column-medium>*,.uk-grid-medium>*{padding-left:30px}*+.uk-grid-margin-medium,.uk-grid+.uk-grid-medium,.uk-grid+.uk-grid-row-medium,.uk-grid-medium>.uk-grid-margin,.uk-grid-row-medium>.uk-grid-margin{margin-top:30px}.uk-grid-column-large,.uk-grid-large{margin-left:-40px}.uk-grid-column-large>*,.uk-grid-large>*{padding-left:40px}*+.uk-grid-margin-large,.uk-grid+.uk-grid-large,.uk-grid+.uk-grid-row-large,.uk-grid-large>.uk-grid-margin,.uk-grid-row-large>.uk-grid-margin{margin-top:40px}@media (min-width:1200px){.uk-grid-column-large,.uk-grid-large{margin-left:-70px}.uk-grid-column-large>*,.uk-grid-large>*{padding-left:70px}*+.uk-grid-margin-large,.uk-grid+.uk-grid-large,.uk-grid+.uk-grid-row-large,.uk-grid-large>.uk-grid-margin,.uk-grid-row-large>.uk-grid-margin{margin-top:70px}}.uk-grid-collapse,.uk-grid-column-collapse{margin-left:0}.uk-grid-collapse>*,.uk-grid-column-collapse>*{padding-left:0}.uk-grid+.uk-grid-collapse,.uk-grid+.uk-grid-row-collapse,.uk-grid-collapse>.uk-grid-margin,.uk-grid-row-collapse>.uk-grid-margin{margin-top:0}.uk-grid-divider>*{position:relative}.uk-grid-divider>:not(.uk-first-column)::before{content:"";position:absolute;top:0;bottom:0;border-left:1px solid #e5e5e5}.uk-grid-divider.uk-grid-stack>.uk-grid-margin::before{content:"";position:absolute;left:0;right:0;border-top:1px solid #e5e5e5}.uk-grid-divider{margin-left:-60px}.uk-grid-divider>*{padding-left:60px}.uk-grid-divider>:not(.uk-first-column)::before{left:30px}.uk-grid-divider.uk-grid-stack>.uk-grid-margin{margin-top:60px}.uk-grid-divider.uk-grid-stack>.uk-grid-margin::before{top:-30px;left:60px}@media (min-width:1200px){.uk-grid-divider{margin-left:-80px}.uk-grid-divider>*{padding-left:80px}.uk-grid-divider>:not(.uk-first-column)::before{left:40px}.uk-grid-divider.uk-grid-stack>.uk-grid-margin{margin-top:80px}.uk-grid-divider.uk-grid-stack>.uk-grid-margin::before{top:-40px;left:80px}}.uk-grid-divider.uk-grid-column-small,.uk-grid-divider.uk-grid-small{margin-left:-30px}.uk-grid-divider.uk-grid-column-small>*,.uk-grid-divider.uk-grid-small>*{padding-left:30px}.uk-grid-divider.uk-grid-column-small>:not(.uk-first-column)::before,.uk-grid-divider.uk-grid-small>:not(.uk-first-column)::before{left:15px}.uk-grid-divider.uk-grid-row-small.uk-grid-stack>.uk-grid-margin,.uk-grid-divider.uk-grid-small.uk-grid-stack>.uk-grid-margin{margin-top:30px}.uk-grid-divider.uk-grid-small.uk-grid-stack>.uk-grid-margin::before{top:-15px;left:30px}.uk-grid-divider.uk-grid-row-small.uk-grid-stack>.uk-grid-margin::before{top:-15px}.uk-grid-divider.uk-grid-column-small.uk-grid-stack>.uk-grid-margin::before{left:30px}.uk-grid-divider.uk-grid-column-medium,.uk-grid-divider.uk-grid-medium{margin-left:-60px}.uk-grid-divider.uk-grid-column-medium>*,.uk-grid-divider.uk-grid-medium>*{padding-left:60px}.uk-grid-divider.uk-grid-column-medium>:not(.uk-first-column)::before,.uk-grid-divider.uk-grid-medium>:not(.uk-first-column)::before{left:30px}.uk-grid-divider.uk-grid-medium.uk-grid-stack>.uk-grid-margin,.uk-grid-divider.uk-grid-row-medium.uk-grid-stack>.uk-grid-margin{margin-top:60px}.uk-grid-divider.uk-grid-medium.uk-grid-stack>.uk-grid-margin::before{top:-30px;left:60px}.uk-grid-divider.uk-grid-row-medium.uk-grid-stack>.uk-grid-margin::before{top:-30px}.uk-grid-divider.uk-grid-column-medium.uk-grid-stack>.uk-grid-margin::before{left:60px}.uk-grid-divider.uk-grid-column-large,.uk-grid-divider.uk-grid-large{margin-left:-80px}.uk-grid-divider.uk-grid-column-large>*,.uk-grid-divider.uk-grid-large>*{padding-left:80px}.uk-grid-divider.uk-grid-column-large>:not(.uk-first-column)::before,.uk-grid-divider.uk-grid-large>:not(.uk-first-column)::before{left:40px}.uk-grid-divider.uk-grid-large.uk-grid-stack>.uk-grid-margin,.uk-grid-divider.uk-grid-row-large.uk-grid-stack>.uk-grid-margin{margin-top:80px}.uk-grid-divider.uk-grid-large.uk-grid-stack>.uk-grid-margin::before{top:-40px;left:80px}.uk-grid-divider.uk-grid-row-large.uk-grid-stack>.uk-grid-margin::before{top:-40px}.uk-grid-divider.uk-grid-column-large.uk-grid-stack>.uk-grid-margin::before{left:80px}@media (min-width:1200px){.uk-grid-divider.uk-grid-column-large,.uk-grid-divider.uk-grid-large{margin-left:-140px}.uk-grid-divider.uk-grid-column-large>*,.uk-grid-divider.uk-grid-large>*{padding-left:140px}.uk-grid-divider.uk-grid-column-large>:not(.uk-first-column)::before,.uk-grid-divider.uk-grid-large>:not(.uk-first-column)::before{left:70px}.uk-grid-divider.uk-grid-large.uk-grid-stack>.uk-grid-margin,.uk-grid-divider.uk-grid-row-large.uk-grid-stack>.uk-grid-margin{margin-top:140px}.uk-grid-divider.uk-grid-large.uk-grid-stack>.uk-grid-margin::before{top:-70px;left:140px}.uk-grid-divider.uk-grid-row-large.uk-grid-stack>.uk-grid-margin::before{top:-70px}.uk-grid-divider.uk-grid-column-large.uk-grid-stack>.uk-grid-margin::before{left:140px}}.uk-grid-item-match,.uk-grid-match>*{display:flex;flex-wrap:wrap}.uk-grid-item-match>:not([class*=uk-width]),.uk-grid-match>*>:not([class*=uk-width]){box-sizing:border-box;width:100%;flex:auto}.uk-tile{position:relative;box-sizing:border-box;padding-left:15px;padding-right:15px;padding-top:40px;padding-bottom:40px}@media (min-width:640px){.uk-tile{padding-left:30px;padding-right:30px}}@media (min-width:960px){.uk-tile{padding-left:40px;padding-right:40px;padding-top:70px;padding-bottom:70px}}.uk-tile::after,.uk-tile::before{content:"";display:table}.uk-tile::after{clear:both}.uk-tile>:last-child{margin-bottom:0}.uk-tile-xsmall{padding-top:20px;padding-bottom:20px}.uk-tile-small{padding-top:40px;padding-bottom:40px}.uk-tile-large{padding-top:70px;padding-bottom:70px}@media (min-width:960px){.uk-tile-large{padding-top:140px;padding-bottom:140px}}.uk-tile-xlarge{padding-top:140px;padding-bottom:140px}@media (min-width:960px){.uk-tile-xlarge{padding-top:210px;padding-bottom:210px}}.uk-tile-default{background:#fff}.uk-tile-muted{background:#f8f8f8}.uk-tile-primary{background:#1e87f0}.uk-tile-secondary{background:#222}.uk-card{position:relative;box-sizing:border-box;transition:box-shadow .1s ease-in-out}.uk-card-body{padding:30px 30px}.uk-card-header{padding:15px 30px}.uk-card-footer{padding:15px 30px}@media (min-width:1200px){.uk-card-body{padding:40px 40px}.uk-card-header{padding:20px 40px}.uk-card-footer{padding:20px 40px}}.uk-card-body::after,.uk-card-body::before,.uk-card-footer::after,.uk-card-footer::before,.uk-card-header::after,.uk-card-header::before{content:"";display:table}.uk-card-body::after,.uk-card-footer::after,.uk-card-header::after{clear:both}.uk-card-body>:last-child,.uk-card-footer>:last-child,.uk-card-header>:last-child{margin-bottom:0}.uk-card-title{font-size:1.5rem;line-height:1.4}.uk-card-badge{position:absolute;top:30px;right:30px;z-index:1}.uk-card-badge:first-child+*{margin-top:0}.uk-card-hover:not(.uk-card-default):not(.uk-card-primary):not(.uk-card-secondary):hover{background:#fff;box-shadow:0 14px 25px rgba(0,0,0,.16)}.uk-card-default{background:#fff;color:#666;box-shadow:0 5px 15px rgba(0,0,0,.08)}.uk-card-default .uk-card-title{color:#333}.uk-card-default.uk-card-hover:hover{background-color:#fff;box-shadow:0 14px 25px rgba(0,0,0,.16)}.uk-card-default .uk-card-header{border-bottom:1px solid #e5e5e5}.uk-card-default .uk-card-footer{border-top:1px solid #e5e5e5}.uk-card-primary{background:#1e87f0;color:#fff;box-shadow:0 5px 15px rgba(0,0,0,.08)}.uk-card-primary .uk-card-title{color:#fff}.uk-card-primary.uk-card-hover:hover{background-color:#1e87f0;box-shadow:0 14px 25px rgba(0,0,0,.16)}.uk-card-secondary{background:#222;color:#fff;box-shadow:0 5px 15px rgba(0,0,0,.08)}.uk-card-secondary .uk-card-title{color:#fff}.uk-card-secondary.uk-card-hover:hover{background-color:#222;box-shadow:0 14px 25px rgba(0,0,0,.16)}.uk-card-small .uk-card-body,.uk-card-small.uk-card-body{padding:20px 20px}.uk-card-small .uk-card-header{padding:13px 20px}.uk-card-small .uk-card-footer{padding:13px 20px}@media (min-width:1200px){.uk-card-large .uk-card-body,.uk-card-large.uk-card-body{padding:70px 70px}.uk-card-large .uk-card-header{padding:35px 70px}.uk-card-large .uk-card-footer{padding:35px 70px}}.uk-card-body>.uk-nav-default{margin-left:-30px;margin-right:-30px}.uk-card-body>.uk-nav-default:only-child{margin-top:-15px;margin-bottom:-15px}.uk-card-body .uk-nav-default .uk-nav-divider,.uk-card-body .uk-nav-default .uk-nav-header,.uk-card-body .uk-nav-default>li>a{padding-left:30px;padding-right:30px}.uk-card-body .uk-nav-default .uk-nav-sub{padding-left:45px}@media (min-width:1200px){.uk-card-body>.uk-nav-default{margin-left:-40px;margin-right:-40px}.uk-card-body>.uk-nav-default:only-child{margin-top:-25px;margin-bottom:-25px}.uk-card-body .uk-nav-default .uk-nav-divider,.uk-card-body .uk-nav-default .uk-nav-header,.uk-card-body .uk-nav-default>li>a{padding-left:40px;padding-right:40px}.uk-card-body .uk-nav-default .uk-nav-sub{padding-left:55px}}.uk-card-small>.uk-nav-default{margin-left:-20px;margin-right:-20px}.uk-card-small>.uk-nav-default:only-child{margin-top:-5px;margin-bottom:-5px}.uk-card-small .uk-nav-default .uk-nav-divider,.uk-card-small .uk-nav-default .uk-nav-header,.uk-card-small .uk-nav-default>li>a{padding-left:20px;padding-right:20px}.uk-card-small .uk-nav-default .uk-nav-sub{padding-left:35px}@media (min-width:1200px){.uk-card-large>.uk-nav-default{margin:0}.uk-card-large>.uk-nav-default:only-child{margin:0}.uk-card-large .uk-nav-default .uk-nav-divider,.uk-card-large .uk-nav-default .uk-nav-header,.uk-card-large .uk-nav-default>li>a{padding-left:0;padding-right:0}.uk-card-large .uk-nav-default .uk-nav-sub{padding-left:15px}}.uk-close{color:#999;transition:.1s ease-in-out;transition-property:color,opacity}.uk-close:focus,.uk-close:hover{color:#666;outline:0}.uk-spinner>*{animation:uk-spinner-rotate 1.4s linear infinite}@keyframes uk-spinner-rotate{0%{transform:rotate(0)}100%{transform:rotate(270deg)}}.uk-spinner>*>*{stroke-dasharray:88px;stroke-dashoffset:0;transform-origin:center;animation:uk-spinner-dash 1.4s ease-in-out infinite;stroke-width:1;stroke-linecap:round}@keyframes uk-spinner-dash{0%{stroke-dashoffset:88px}50%{stroke-dashoffset:22px;transform:rotate(135deg)}100%{stroke-dashoffset:88px;transform:rotate(450deg)}}.uk-totop{padding:5px;color:#999;transition:color .1s ease-in-out}.uk-totop:focus,.uk-totop:hover{color:#666;outline:0}.uk-totop:active{color:#333}.uk-marker{padding:5px;background:#222;color:#fff;border-radius:500px}.uk-marker:focus,.uk-marker:hover{color:#fff;outline:0}.uk-alert{position:relative;margin-bottom:20px;padding:15px 29px 15px 15px;background:#f8f8f8;color:#666}*+.uk-alert{margin-top:20px}.uk-alert>:last-child{margin-bottom:0}.uk-alert-close{position:absolute;top:20px;right:15px;color:inherit;opacity:.4}.uk-alert-close:first-child+*{margin-top:0}.uk-alert-close:focus,.uk-alert-close:hover{color:inherit;opacity:.8}.uk-alert-primary{background:#d8eafc;color:#1e87f0}.uk-alert-success{background:#edfbf6;color:#32d296}.uk-alert-warning{background:#fff6ee;color:#faa05a}.uk-alert-danger{background:#fef4f6;color:#f0506e}.uk-alert h1,.uk-alert h2,.uk-alert h3,.uk-alert h4,.uk-alert h5,.uk-alert h6{color:inherit}.uk-alert a:not([class]){color:inherit;text-decoration:underline}.uk-alert a:not([class]):hover{color:inherit;text-decoration:underline}.uk-badge{box-sizing:border-box;min-width:22px;height:22px;padding:0 5px;border-radius:500px;vertical-align:middle;background:#1e87f0;color:#fff;font-size:.875rem;display:inline-flex;justify-content:center;align-items:center}.uk-badge:focus,.uk-badge:hover{color:#fff;text-decoration:none;outline:0}.uk-label{display:inline-block;padding:0 10px;background:#1e87f0;line-height:1.5;font-size:.875rem;color:#fff;vertical-align:middle;white-space:nowrap;border-radius:2px;text-transform:uppercase}.uk-label-success{background-color:#32d296;color:#fff}.uk-label-warning{background-color:#faa05a;color:#fff}.uk-label-danger{background-color:#f0506e;color:#fff}.uk-overlay{padding:30px 30px}.uk-overlay>:last-child{margin-bottom:0}.uk-overlay-default{background:rgba(255,255,255,.8)}.uk-overlay-primary{background:rgba(34,34,34,.8)}.uk-article::after,.uk-article::before{content:"";display:table}.uk-article::after{clear:both}.uk-article>:last-child{margin-bottom:0}.uk-article+.uk-article{margin-top:70px}.uk-article-title{font-size:2.23125rem;line-height:1.2}@media (min-width:960px){.uk-article-title{font-size:2.625rem}}.uk-article-meta{font-size:.875rem;line-height:1.4;color:#999}.uk-article-meta a{color:#999}.uk-article-meta a:hover{color:#666;text-decoration:none}.uk-comment-body{overflow-wrap:break-word;word-wrap:break-word}.uk-comment-header{margin-bottom:20px}.uk-comment-body::after,.uk-comment-body::before,.uk-comment-header::after,.uk-comment-header::before{content:"";display:table}.uk-comment-body::after,.uk-comment-header::after{clear:both}.uk-comment-body>:last-child,.uk-comment-header>:last-child{margin-bottom:0}.uk-comment-title{font-size:1.25rem;line-height:1.4}.uk-comment-meta{font-size:.875rem;line-height:1.4;color:#999}.uk-comment-list{padding:0;list-style:none}.uk-comment-list>:nth-child(n+2){margin-top:70px}.uk-comment-list .uk-comment~ul{margin:70px 0 0 0;padding-left:30px;list-style:none}@media (min-width:960px){.uk-comment-list .uk-comment~ul{padding-left:100px}}.uk-comment-list .uk-comment~ul>:nth-child(n+2){margin-top:70px}.uk-comment-primary{padding:30px;background-color:#f8f8f8}.uk-search{display:inline-block;position:relative;max-width:100%;margin:0}.uk-search-input::-webkit-search-cancel-button,.uk-search-input::-webkit-search-decoration{-webkit-appearance:none}.uk-search-input::-moz-placeholder{opacity:1}.uk-search-input{box-sizing:border-box;margin:0;border-radius:0;font:inherit;overflow:visible;-webkit-appearance:none;vertical-align:middle;width:100%;border:none;color:#666}.uk-search-input:focus{outline:0}.uk-search-input:-ms-input-placeholder{color:#999!important}.uk-search-input::placeholder{color:#999}.uk-search-icon:focus{outline:0}.uk-search .uk-search-icon{position:absolute;top:0;bottom:0;left:0;display:inline-flex;justify-content:center;align-items:center;color:#999}.uk-search .uk-search-icon:hover{color:#999}.uk-search .uk-search-icon:not(a):not(button):not(input){pointer-events:none}.uk-search .uk-search-icon-flip{right:0;left:auto}.uk-search-default{width:180px}.uk-search-default .uk-search-input{height:40px;padding-left:6px;padding-right:6px;background:0 0;border:1px solid #e5e5e5}.uk-search-default .uk-search-input:focus{background-color:transparent}.uk-search-default .uk-search-icon{width:40px}.uk-search-default .uk-search-icon:not(.uk-search-icon-flip)~.uk-search-input{padding-left:40px}.uk-search-default .uk-search-icon-flip~.uk-search-input{padding-right:40px}.uk-search-navbar{width:400px}.uk-search-navbar .uk-search-input{height:40px;background:0 0;font-size:1.5rem}.uk-search-navbar .uk-search-icon{width:40px}.uk-search-navbar .uk-search-icon:not(.uk-search-icon-flip)~.uk-search-input{padding-left:40px}.uk-search-navbar .uk-search-icon-flip~.uk-search-input{padding-right:40px}.uk-search-large{width:500px}.uk-search-large .uk-search-input{height:80px;background:0 0;font-size:2.625rem}.uk-search-large .uk-search-icon{width:80px}.uk-search-large .uk-search-icon:not(.uk-search-icon-flip)~.uk-search-input{padding-left:80px}.uk-search-large .uk-search-icon-flip~.uk-search-input{padding-right:80px}.uk-search-toggle{color:#999}.uk-search-toggle:focus,.uk-search-toggle:hover{color:#666}.uk-nav,.uk-nav ul{margin:0;padding:0;list-style:none}.uk-nav li>a{display:block;text-decoration:none}.uk-nav li>a:focus{outline:0}.uk-nav>li>a{padding:5px 0}ul.uk-nav-sub{padding:5px 0 5px 15px}.uk-nav-sub ul{padding-left:15px}.uk-nav-sub a{padding:2px 0}.uk-nav-parent-icon>.uk-parent>a::after{content:"";width:1.5em;height:1.5em;float:right;background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2214%22%20viewBox%3D%220%200%2014%2014%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolyline%20fill%3D%22none%22%20stroke%3D%22%23666%22%20stroke-width%3D%221.1%22%20points%3D%2210%201%204%207%2010%2013%22%20%2F%3E%0A%3C%2Fsvg%3E");background-repeat:no-repeat;background-position:50% 50%}.uk-nav-parent-icon>.uk-parent.uk-open>a::after{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2214%22%20viewBox%3D%220%200%2014%2014%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolyline%20fill%3D%22none%22%20stroke%3D%22%23666%22%20stroke-width%3D%221.1%22%20points%3D%221%204%207%2010%2013%204%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-nav-header{padding:5px 0;text-transform:uppercase;font-size:.875rem}.uk-nav-header:not(:first-child){margin-top:20px}.uk-nav-divider{margin:5px 0}.uk-nav-default{font-size:.875rem}.uk-nav-default>li>a{color:#999}.uk-nav-default>li>a:focus,.uk-nav-default>li>a:hover{color:#666}.uk-nav-default>li.uk-active>a{color:#333}.uk-nav-default .uk-nav-header{color:#333}.uk-nav-default .uk-nav-divider{border-top:1px solid #e5e5e5}.uk-nav-default .uk-nav-sub a{color:#999}.uk-nav-default .uk-nav-sub a:focus,.uk-nav-default .uk-nav-sub a:hover{color:#666}.uk-nav-default .uk-nav-sub li.uk-active>a{color:#333}.uk-nav-primary>li>a{font-size:1.5rem;line-height:1.5;color:#999}.uk-nav-primary>li>a:focus,.uk-nav-primary>li>a:hover{color:#666}.uk-nav-primary>li.uk-active>a{color:#333}.uk-nav-primary .uk-nav-header{color:#333}.uk-nav-primary .uk-nav-divider{border-top:1px solid #e5e5e5}.uk-nav-primary .uk-nav-sub a{color:#999}.uk-nav-primary .uk-nav-sub a:focus,.uk-nav-primary .uk-nav-sub a:hover{color:#666}.uk-nav-primary .uk-nav-sub li.uk-active>a{color:#333}.uk-nav-center{text-align:center}.uk-nav-center .uk-nav-sub,.uk-nav-center .uk-nav-sub ul{padding-left:0}.uk-nav-center.uk-nav-parent-icon>.uk-parent>a::after{position:absolute}.uk-navbar{display:flex;position:relative}.uk-navbar-container:not(.uk-navbar-transparent){background:#f8f8f8}.uk-navbar-container>::after,.uk-navbar-container>::before{display:none!important}.uk-navbar-center,.uk-navbar-center-left>*,.uk-navbar-center-right>*,.uk-navbar-left,.uk-navbar-right{display:flex;align-items:center}.uk-navbar-right{margin-left:auto}.uk-navbar-center:only-child{margin-left:auto;margin-right:auto;position:relative}.uk-navbar-center:not(:only-child){position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:max-content;box-sizing:border-box;z-index:990}.uk-navbar-center-left,.uk-navbar-center-right{position:absolute;top:0}.uk-navbar-center-left{right:100%}.uk-navbar-center-right{left:100%}[class*=uk-navbar-center-]{width:max-content;box-sizing:border-box}.uk-navbar-nav{display:flex;margin:0;padding:0;list-style:none}.uk-navbar-center:only-child,.uk-navbar-left,.uk-navbar-right{flex-wrap:wrap}.uk-navbar-item,.uk-navbar-nav>li>a,.uk-navbar-toggle{display:flex;justify-content:center;align-items:center;box-sizing:border-box;min-height:80px;padding:0 15px;font-size:.875rem;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";text-decoration:none}.uk-navbar-nav>li>a{color:#999;text-transform:uppercase;transition:.1s ease-in-out;transition-property:color,background-color}.uk-navbar-nav>li:hover>a,.uk-navbar-nav>li>a.uk-open,.uk-navbar-nav>li>a:focus{color:#666;outline:0}.uk-navbar-nav>li>a:active{color:#333}.uk-navbar-nav>li.uk-active>a{color:#333}.uk-navbar-item{color:#666}.uk-navbar-toggle{color:#999}.uk-navbar-toggle.uk-open,.uk-navbar-toggle:focus,.uk-navbar-toggle:hover{color:#666;outline:0;text-decoration:none}.uk-navbar-subtitle{font-size:.875rem}.uk-navbar-dropdown{display:none;position:absolute;z-index:1020;box-sizing:border-box;width:200px;padding:25px;background:#fff;color:#666;box-shadow:0 5px 12px rgba(0,0,0,.15)}.uk-navbar-dropdown.uk-open{display:block}[class*=uk-navbar-dropdown-top]{margin-top:-15px}[class*=uk-navbar-dropdown-bottom]{margin-top:15px}[class*=uk-navbar-dropdown-left]{margin-left:-15px}[class*=uk-navbar-dropdown-right]{margin-left:15px}.uk-navbar-dropdown-grid{margin-left:-50px}.uk-navbar-dropdown-grid>*{padding-left:50px}.uk-navbar-dropdown-grid>.uk-grid-margin{margin-top:50px}.uk-navbar-dropdown-stack .uk-navbar-dropdown-grid>*{width:100%!important}.uk-navbar-dropdown-width-2:not(.uk-navbar-dropdown-stack){width:400px}.uk-navbar-dropdown-width-3:not(.uk-navbar-dropdown-stack){width:600px}.uk-navbar-dropdown-width-4:not(.uk-navbar-dropdown-stack){width:800px}.uk-navbar-dropdown-width-5:not(.uk-navbar-dropdown-stack){width:1000px}.uk-navbar-dropdown-dropbar{margin-top:0;margin-bottom:0;box-shadow:none}.uk-navbar-dropdown-nav{font-size:.875rem}.uk-navbar-dropdown-nav>li>a{color:#999}.uk-navbar-dropdown-nav>li>a:focus,.uk-navbar-dropdown-nav>li>a:hover{color:#666}.uk-navbar-dropdown-nav>li.uk-active>a{color:#333}.uk-navbar-dropdown-nav .uk-nav-header{color:#333}.uk-navbar-dropdown-nav .uk-nav-divider{border-top:1px solid #e5e5e5}.uk-navbar-dropdown-nav .uk-nav-sub a{color:#999}.uk-navbar-dropdown-nav .uk-nav-sub a:focus,.uk-navbar-dropdown-nav .uk-nav-sub a:hover{color:#666}.uk-navbar-dropdown-nav .uk-nav-sub li.uk-active>a{color:#333}.uk-navbar-dropbar{background:#fff}.uk-navbar-dropbar-slide{position:absolute;z-index:980;left:0;right:0;box-shadow:0 5px 7px rgba(0,0,0,.05)}.uk-navbar-container>.uk-container .uk-navbar-left{margin-left:-15px;margin-right:-15px}.uk-navbar-container>.uk-container .uk-navbar-right{margin-right:-15px}.uk-navbar-dropdown-grid>*{position:relative}.uk-navbar-dropdown-grid>:not(.uk-first-column)::before{content:"";position:absolute;top:0;bottom:0;left:25px;border-left:1px solid #e5e5e5}.uk-navbar-dropdown-grid.uk-grid-stack>.uk-grid-margin::before{content:"";position:absolute;top:-25px;left:50px;right:0;border-top:1px solid #e5e5e5}.uk-subnav{display:flex;flex-wrap:wrap;margin-left:-20px;padding:0;list-style:none}.uk-subnav>*{flex:none;padding-left:20px;position:relative}.uk-subnav>*>:first-child{display:block;color:#999;font-size:.875rem;text-transform:uppercase;transition:.1s ease-in-out;transition-property:color,background-color}.uk-subnav>*>a:focus,.uk-subnav>*>a:hover{color:#666;text-decoration:none;outline:0}.uk-subnav>.uk-active>a{color:#333}.uk-subnav-divider>*{display:flex;align-items:center}.uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before{content:"";height:1.5em;margin-left:0;margin-right:20px;border-left:1px solid #e5e5e5}.uk-subnav-pill>*>:first-child{padding:5px 10px;background:0 0;color:#999}.uk-subnav-pill>*>a:focus,.uk-subnav-pill>*>a:hover{background-color:#f8f8f8;color:#666}.uk-subnav-pill>*>a:active{background-color:#f8f8f8;color:#666}.uk-subnav-pill>.uk-active>a{background-color:#1e87f0;color:#fff}.uk-subnav>.uk-disabled>a{color:#999}.uk-breadcrumb{display:flex;flex-wrap:wrap;padding:0;list-style:none}.uk-breadcrumb>*{flex:none}.uk-breadcrumb>*>*{display:inline-block;font-size:.875rem;color:#999}.uk-breadcrumb>*>:focus,.uk-breadcrumb>*>:hover{color:#666;text-decoration:none}.uk-breadcrumb>:last-child>*{color:#666}.uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before{content:"/";display:inline-block;margin:0 20px;color:#999}.uk-pagination{display:flex;flex-wrap:wrap;margin-left:-20px;padding:0;list-style:none}.uk-pagination>*{flex:none;padding-left:20px;position:relative}.uk-pagination>*>*{display:block;color:#999;transition:color .1s ease-in-out}.uk-pagination>*>:focus,.uk-pagination>*>:hover{color:#666;text-decoration:none}.uk-pagination>.uk-active>*{color:#666}.uk-pagination>.uk-disabled>*{color:#999}.uk-tab{display:flex;flex-wrap:wrap;margin-left:-20px;padding:0;list-style:none;position:relative}.uk-tab::before{content:"";position:absolute;bottom:0;left:20px;right:0;border-bottom:1px solid #e5e5e5}.uk-tab>*{flex:none;padding-left:20px;position:relative}.uk-tab>*>a{display:block;text-align:center;padding:5px 10px;color:#999;border-bottom:1px solid transparent;font-size:.875rem;text-transform:uppercase;transition:color .1s ease-in-out}.uk-tab>*>a:focus,.uk-tab>*>a:hover{color:#666;text-decoration:none}.uk-tab>.uk-active>a{color:#333;border-color:#1e87f0}.uk-tab>.uk-disabled>a{color:#999}.uk-tab-bottom::before{top:0;bottom:auto}.uk-tab-bottom>*>a{border-top:1px solid transparent;border-bottom:none}.uk-tab-left,.uk-tab-right{flex-direction:column;margin-left:0}.uk-tab-left>*,.uk-tab-right>*{padding-left:0}.uk-tab-left::before{top:0;bottom:0;left:auto;right:0;border-left:1px solid #e5e5e5;border-bottom:none}.uk-tab-right::before{top:0;bottom:0;left:0;right:auto;border-left:1px solid #e5e5e5;border-bottom:none}.uk-tab-left>*>a{text-align:left;border-right:1px solid transparent;border-bottom:none}.uk-tab-right>*>a{text-align:left;border-left:1px solid transparent;border-bottom:none}.uk-tab .uk-dropdown{margin-left:30px}.uk-slidenav{padding:5px 10px;color:rgba(102,102,102,.5);transition:color .1s ease-in-out}.uk-slidenav:focus,.uk-slidenav:hover{color:rgba(102,102,102,.9);outline:0}.uk-slidenav:active{color:rgba(102,102,102,.5)}.uk-slidenav-large{padding:10px 10px}.uk-slidenav-container{display:flex}.uk-dotnav{display:flex;flex-wrap:wrap;margin:0;padding:0;list-style:none;margin-left:-12px}.uk-dotnav>*{flex:none;padding-left:12px}.uk-dotnav>*>*{display:block;box-sizing:border-box;width:10px;height:10px;border-radius:50%;background:0 0;text-indent:100%;overflow:hidden;white-space:nowrap;border:1px solid rgba(102,102,102,.4);transition:.2s ease-in-out;transition-property:background-color,border-color}.uk-dotnav>*>:focus,.uk-dotnav>*>:hover{background-color:rgba(102,102,102,.6);outline:0;border-color:transparent}.uk-dotnav>*>:active{background-color:rgba(102,102,102,.2);border-color:transparent}.uk-dotnav>.uk-active>*{background-color:rgba(102,102,102,.6);border-color:transparent}.uk-dotnav-vertical{flex-direction:column;margin-left:0;margin-top:-12px}.uk-dotnav-vertical>*{padding-left:0;padding-top:12px}.uk-thumbnav{display:flex;flex-wrap:wrap;margin:0;padding:0;list-style:none;margin-left:-15px}.uk-thumbnav>*{padding-left:15px}.uk-thumbnav>*>*{display:inline-block;position:relative}.uk-thumbnav>*>::after{content:"";position:absolute;top:0;bottom:0;left:0;right:0;background:rgba(255,255,255,.4);transition:background-color .1s ease-in-out}.uk-thumbnav>*>:focus,.uk-thumbnav>*>:hover{outline:0}.uk-thumbnav>*>:focus::after,.uk-thumbnav>*>:hover::after{background-color:transparent}.uk-thumbnav>.uk-active>::after{background-color:transparent}.uk-thumbnav-vertical{flex-direction:column;margin-left:0;margin-top:-15px}.uk-thumbnav-vertical>*{padding-left:0;padding-top:15px}.uk-accordion{padding:0;list-style:none}.uk-accordion>:nth-child(n+2){margin-top:20px}.uk-accordion-title{display:block;font-size:1.25rem;line-height:1.4;color:#333;overflow:hidden}.uk-accordion-title::before{content:"";width:1.4em;height:1.4em;margin-left:10px;float:right;background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23666%22%20width%3D%2213%22%20height%3D%221%22%20x%3D%220%22%20y%3D%226%22%20%2F%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23666%22%20width%3D%221%22%20height%3D%2213%22%20x%3D%226%22%20y%3D%220%22%20%2F%3E%0A%3C%2Fsvg%3E");background-repeat:no-repeat;background-position:50% 50%}.uk-open>.uk-accordion-title::before{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23666%22%20width%3D%2213%22%20height%3D%221%22%20x%3D%220%22%20y%3D%226%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-accordion-title:focus,.uk-accordion-title:hover{color:#666;text-decoration:none;outline:0}.uk-accordion-content{margin-top:20px}.uk-accordion-content::after,.uk-accordion-content::before{content:"";display:table}.uk-accordion-content::after{clear:both}.uk-accordion-content>:last-child{margin-bottom:0}.uk-drop{display:none;position:absolute;z-index:1020;box-sizing:border-box;width:300px}.uk-drop.uk-open{display:block}[class*=uk-drop-top]{margin-top:-20px}[class*=uk-drop-bottom]{margin-top:20px}[class*=uk-drop-left]{margin-left:-20px}[class*=uk-drop-right]{margin-left:20px}.uk-drop-stack .uk-drop-grid>*{width:100%!important}.uk-dropdown{display:none;position:absolute;z-index:1020;box-sizing:border-box;min-width:200px;padding:25px;background:#fff;color:#666;box-shadow:0 5px 12px rgba(0,0,0,.15)}.uk-dropdown.uk-open{display:block}.uk-dropdown-nav{white-space:nowrap;font-size:.875rem}.uk-dropdown-nav>li>a{color:#999}.uk-dropdown-nav>li.uk-active>a,.uk-dropdown-nav>li>a:focus,.uk-dropdown-nav>li>a:hover{color:#666}.uk-dropdown-nav .uk-nav-header{color:#333}.uk-dropdown-nav .uk-nav-divider{border-top:1px solid #e5e5e5}.uk-dropdown-nav .uk-nav-sub a{color:#999}.uk-dropdown-nav .uk-nav-sub a:focus,.uk-dropdown-nav .uk-nav-sub a:hover,.uk-dropdown-nav .uk-nav-sub li.uk-active>a{color:#666}[class*=uk-dropdown-top]{margin-top:-10px}[class*=uk-dropdown-bottom]{margin-top:10px}[class*=uk-dropdown-left]{margin-left:-10px}[class*=uk-dropdown-right]{margin-left:10px}.uk-dropdown-stack .uk-dropdown-grid>*{width:100%!important}.uk-modal{display:none;position:fixed;top:0;right:0;bottom:0;left:0;z-index:1010;overflow-y:auto;-webkit-overflow-scrolling:touch;padding:15px 15px;background:rgba(0,0,0,.6);opacity:0;transition:opacity .15s linear}@media (min-width:640px){.uk-modal{padding:50px 30px}}@media (min-width:960px){.uk-modal{padding-left:40px;padding-right:40px}}.uk-modal.uk-open{opacity:1}.uk-modal-page{overflow:hidden}.uk-modal-dialog{position:relative;box-sizing:border-box;margin:0 auto;width:600px;max-width:calc(100% - .01px)!important;background:#fff;opacity:0;transform:translateY(-100px);transition:.3s linear;transition-property:opacity,transform}.uk-open>.uk-modal-dialog{opacity:1;transform:translateY(0)}.uk-modal-container .uk-modal-dialog{width:1200px}.uk-modal-full{padding:0;background:0 0}.uk-modal-full .uk-modal-dialog{margin:0;width:100%;max-width:100%;transform:translateY(0)}.uk-modal-body{padding:30px 30px}.uk-modal-header{padding:15px 30px;background:#fff;border-bottom:1px solid #e5e5e5}.uk-modal-footer{padding:15px 30px;background:#fff;border-top:1px solid #e5e5e5}.uk-modal-body::after,.uk-modal-body::before,.uk-modal-footer::after,.uk-modal-footer::before,.uk-modal-header::after,.uk-modal-header::before{content:"";display:table}.uk-modal-body::after,.uk-modal-footer::after,.uk-modal-header::after{clear:both}.uk-modal-body>:last-child,.uk-modal-footer>:last-child,.uk-modal-header>:last-child{margin-bottom:0}.uk-modal-title{font-size:2rem;line-height:1.3}[class*=uk-modal-close-]{position:absolute;z-index:1010;top:10px;right:10px;padding:5px}[class*=uk-modal-close-]:first-child+*{margin-top:0}.uk-modal-close-outside{top:0;right:-5px;transform:translate(0,-100%);color:#fff}.uk-modal-close-outside:hover{color:#fff}@media (min-width:960px){.uk-modal-close-outside{right:0;transform:translate(100%,-100%)}}.uk-modal-close-full{top:0;right:0;padding:20px;background:#fff}.uk-lightbox{display:none;position:fixed;top:0;right:0;bottom:0;left:0;z-index:1010;background:#000;opacity:0;transition:opacity .15s linear}.uk-lightbox.uk-open{display:block;opacity:1}.uk-lightbox-page{overflow:hidden}.uk-lightbox-items>*{position:absolute;top:0;right:0;bottom:0;left:0;display:none;justify-content:center;align-items:center;color:rgba(255,255,255,.7);will-change:transform,opacity}.uk-lightbox-items>*>*{max-width:100vw;max-height:100vh}.uk-lightbox-items>:focus{outline:0}.uk-lightbox-items>*>:not(iframe){width:auto;height:auto}.uk-lightbox-items>.uk-active{display:flex}.uk-lightbox-toolbar{padding:10px 10px;background:rgba(0,0,0,.3);color:rgba(255,255,255,.7)}.uk-lightbox-toolbar>*{color:rgba(255,255,255,.7)}.uk-lightbox-toolbar-icon{padding:5px;color:rgba(255,255,255,.7)}.uk-lightbox-toolbar-icon:hover{color:#fff}.uk-lightbox-button{box-sizing:border-box;width:50px;height:50px;background:rgba(0,0,0,.3);color:rgba(255,255,255,.7);display:inline-flex;justify-content:center;align-items:center}.uk-lightbox-button:hover{color:#fff}.uk-lightbox-iframe{width:80%;height:80%}.uk-slideshow{-webkit-tap-highlight-color:transparent}.uk-slideshow-items{position:relative;z-index:0;margin:0;padding:0;list-style:none;overflow:hidden;-webkit-touch-callout:none}.uk-slideshow-items>*{position:absolute;top:0;left:0;right:0;bottom:0;overflow:hidden;will-change:transform,opacity;touch-action:pan-y}.uk-slideshow-items>:focus{outline:0}.uk-slideshow-items>:not(.uk-active){display:none}.uk-slider{-webkit-tap-highlight-color:transparent}.uk-slider-container{overflow:hidden}.uk-slider-items{will-change:transform;position:relative}.uk-slider-items:not(.uk-grid){display:flex;margin:0;padding:0;list-style:none;-webkit-touch-callout:none}.uk-slider-items.uk-grid{flex-wrap:nowrap}.uk-slider-items>*{flex:none;position:relative;touch-action:pan-y}.uk-slider-items>:focus{outline:0}.uk-sticky-fixed{z-index:980;box-sizing:border-box;margin:0!important;-webkit-backface-visibility:hidden;backface-visibility:hidden}.uk-sticky[class*=uk-animation-]{animation-duration:.2s}.uk-sticky.uk-animation-reverse{animation-duration:.2s}.uk-offcanvas{display:none;position:fixed;top:0;bottom:0;left:0;z-index:1000}.uk-offcanvas-flip .uk-offcanvas{right:0;left:auto}.uk-offcanvas-bar{position:absolute;top:0;bottom:0;left:-270px;box-sizing:border-box;width:270px;padding:20px 20px;background:#222;overflow-y:auto;-webkit-overflow-scrolling:touch}@media (min-width:960px){.uk-offcanvas-bar{left:-350px;width:350px;padding:40px 40px}}.uk-offcanvas-flip .uk-offcanvas-bar{left:auto;right:-270px}@media (min-width:960px){.uk-offcanvas-flip .uk-offcanvas-bar{right:-350px}}.uk-open>.uk-offcanvas-bar{left:0}.uk-offcanvas-flip .uk-open>.uk-offcanvas-bar{left:auto;right:0}.uk-offcanvas-bar-animation{transition:left .3s ease-out}.uk-offcanvas-flip .uk-offcanvas-bar-animation{transition-property:right}.uk-offcanvas-reveal{position:absolute;top:0;bottom:0;left:0;width:0;overflow:hidden;transition:width .3s ease-out}.uk-offcanvas-reveal .uk-offcanvas-bar{left:0}.uk-offcanvas-flip .uk-offcanvas-reveal .uk-offcanvas-bar{left:auto;right:0}.uk-open>.uk-offcanvas-reveal{width:270px}@media (min-width:960px){.uk-open>.uk-offcanvas-reveal{width:350px}}.uk-offcanvas-flip .uk-offcanvas-reveal{right:0;left:auto}.uk-offcanvas-close{position:absolute;z-index:1000;top:20px;right:20px;padding:5px}.uk-offcanvas-overlay{width:100vw;touch-action:none}.uk-offcanvas-overlay::before{content:"";position:absolute;top:0;bottom:0;left:0;right:0;background:rgba(0,0,0,.1);opacity:0;transition:opacity .15s linear}.uk-offcanvas-overlay.uk-open::before{opacity:1}.uk-offcanvas-container,.uk-offcanvas-page{overflow-x:hidden}.uk-offcanvas-container{position:relative;left:0;transition:left .3s ease-out;box-sizing:border-box;width:100%}:not(.uk-offcanvas-flip).uk-offcanvas-container-animation{left:270px}.uk-offcanvas-flip.uk-offcanvas-container-animation{left:-270px}@media (min-width:960px){:not(.uk-offcanvas-flip).uk-offcanvas-container-animation{left:350px}.uk-offcanvas-flip.uk-offcanvas-container-animation{left:-350px}}.uk-switcher{margin:0;padding:0;list-style:none}.uk-switcher>:not(.uk-active){display:none}.uk-switcher>*>:last-child{margin-bottom:0}.uk-leader{overflow:hidden}.uk-leader-fill::after{display:inline-block;margin-left:15px;width:0;content:attr(data-fill);white-space:nowrap}.uk-leader-fill.uk-leader-hide::after{display:none}.uk-leader-fill-content::before{content:'.'}:root{--uk-leader-fill-content:.}.uk-iconnav{display:flex;flex-wrap:wrap;margin:0;padding:0;list-style:none;margin-left:-10px}.uk-iconnav>*{padding-left:10px}.uk-iconnav>*>a{display:block;color:#999}.uk-iconnav>*>a:focus,.uk-iconnav>*>a:hover{color:#666;outline:0}.uk-iconnav>.uk-active>a{color:#666}.uk-iconnav-vertical{flex-direction:column;margin-left:0;margin-top:-10px}.uk-iconnav-vertical>*{padding-left:0;padding-top:10px}.uk-notification{position:fixed;top:10px;left:10px;z-index:1040;box-sizing:border-box;width:350px}.uk-notification-bottom-right,.uk-notification-top-right{left:auto;right:10px}.uk-notification-bottom-center,.uk-notification-top-center{left:50%;margin-left:-175px}.uk-notification-bottom-center,.uk-notification-bottom-left,.uk-notification-bottom-right{top:auto;bottom:10px}@media (max-width:639px){.uk-notification{left:10px;right:10px;width:auto;margin:0}}.uk-notification-message{position:relative;padding:15px;background:#f8f8f8;color:#666;font-size:1.25rem;line-height:1.4;cursor:pointer}*+.uk-notification-message{margin-top:10px}.uk-notification-close{display:none;position:absolute;top:20px;right:15px}.uk-notification-message:hover .uk-notification-close{display:block}.uk-notification-message-primary{color:#1e87f0}.uk-notification-message-success{color:#32d296}.uk-notification-message-warning{color:#faa05a}.uk-notification-message-danger{color:#f0506e}.uk-tooltip{display:none;position:absolute;z-index:1030;box-sizing:border-box;max-width:200px;padding:3px 6px;background:#666;border-radius:2px;color:#fff;font-size:12px}.uk-tooltip.uk-active{display:block}[class*=uk-tooltip-top]{margin-top:-10px}[class*=uk-tooltip-bottom]{margin-top:10px}[class*=uk-tooltip-left]{margin-left:-10px}[class*=uk-tooltip-right]{margin-left:10px}.uk-placeholder{margin-bottom:20px;padding:30px 30px;background:0 0;border:1px dashed #e5e5e5}*+.uk-placeholder{margin-top:20px}.uk-placeholder>:last-child{margin-bottom:0}.uk-progress{vertical-align:baseline;-webkit-appearance:none;-moz-appearance:none;display:block;width:100%;border:0;background-color:#f8f8f8;margin-bottom:20px;height:15px;border-radius:500px;overflow:hidden}*+.uk-progress{margin-top:20px}.uk-progress:indeterminate{color:transparent}.uk-progress::-webkit-progress-bar{background-color:#f8f8f8;border-radius:500px;overflow:hidden}.uk-progress:indeterminate::-moz-progress-bar{width:0}.uk-progress::-webkit-progress-value{background-color:#1e87f0;transition:width .6s ease}.uk-progress::-moz-progress-bar{background-color:#1e87f0}.uk-progress::-ms-fill{background-color:#1e87f0;transition:width .6s ease;border:0}.uk-sortable{position:relative}.uk-sortable svg{pointer-events:none}.uk-sortable>:last-child{margin-bottom:0}.uk-sortable-drag{position:absolute!important;z-index:1050!important;pointer-events:none}.uk-sortable-placeholder{opacity:0;pointer-events:none}.uk-sortable-empty{min-height:50px}.uk-sortable-handle:hover{cursor:move}.uk-countdown-number,.uk-countdown-separator{line-height:.8}.uk-countdown-number{font-size:2rem}@media (min-width:640px){.uk-countdown-number{font-size:4rem}}@media (min-width:960px){.uk-countdown-number{font-size:6rem}}.uk-countdown-separator{font-size:1rem}@media (min-width:640px){.uk-countdown-separator{font-size:2rem}}@media (min-width:960px){.uk-countdown-separator{font-size:3rem}}[class*=uk-animation-]{animation-duration:.5s;animation-timing-function:ease-out;animation-fill-mode:both}.uk-animation-fade{animation-name:uk-fade;animation-duration:.8s;animation-timing-function:linear}.uk-animation-scale-up{animation-name:uk-fade-scale-02}.uk-animation-scale-down{animation-name:uk-fade-scale-18}.uk-animation-slide-top{animation-name:uk-fade-top}.uk-animation-slide-bottom{animation-name:uk-fade-bottom}.uk-animation-slide-left{animation-name:uk-fade-left}.uk-animation-slide-right{animation-name:uk-fade-right}.uk-animation-slide-top-small{animation-name:uk-fade-top-small}.uk-animation-slide-bottom-small{animation-name:uk-fade-bottom-small}.uk-animation-slide-left-small{animation-name:uk-fade-left-small}.uk-animation-slide-right-small{animation-name:uk-fade-right-small}.uk-animation-slide-top-medium{animation-name:uk-fade-top-medium}.uk-animation-slide-bottom-medium{animation-name:uk-fade-bottom-medium}.uk-animation-slide-left-medium{animation-name:uk-fade-left-medium}.uk-animation-slide-right-medium{animation-name:uk-fade-right-medium}.uk-animation-kenburns{animation-name:uk-scale-kenburns;animation-duration:15s}.uk-animation-shake{animation-name:uk-shake}.uk-animation-stroke{animation-name:uk-stroke;stroke-dasharray:var(--uk-animation-stroke);animation-duration:2s}.uk-animation-reverse{animation-direction:reverse;animation-timing-function:ease-in}.uk-animation-fast{animation-duration:.1s}.uk-animation-toggle:not(:hover):not(:focus) [class*=uk-animation-]{animation-name:none}.uk-animation-toggle{-webkit-tap-highlight-color:transparent}.uk-animation-toggle:focus{outline:0}@keyframes uk-fade{0%{opacity:0}100%{opacity:1}}@keyframes uk-fade-top{0%{opacity:0;transform:translateY(-100%)}100%{opacity:1;transform:translateY(0)}}@keyframes uk-fade-bottom{0%{opacity:0;transform:translateY(100%)}100%{opacity:1;transform:translateY(0)}}@keyframes uk-fade-left{0%{opacity:0;transform:translateX(-100%)}100%{opacity:1;transform:translateX(0)}}@keyframes uk-fade-right{0%{opacity:0;transform:translateX(100%)}100%{opacity:1;transform:translateX(0)}}@keyframes uk-fade-top-small{0%{opacity:0;transform:translateY(-10px)}100%{opacity:1;transform:translateY(0)}}@keyframes uk-fade-bottom-small{0%{opacity:0;transform:translateY(10px)}100%{opacity:1;transform:translateY(0)}}@keyframes uk-fade-left-small{0%{opacity:0;transform:translateX(-10px)}100%{opacity:1;transform:translateX(0)}}@keyframes uk-fade-right-small{0%{opacity:0;transform:translateX(10px)}100%{opacity:1;transform:translateX(0)}}@keyframes uk-fade-top-medium{0%{opacity:0;transform:translateY(-50px)}100%{opacity:1;transform:translateY(0)}}@keyframes uk-fade-bottom-medium{0%{opacity:0;transform:translateY(50px)}100%{opacity:1;transform:translateY(0)}}@keyframes uk-fade-left-medium{0%{opacity:0;transform:translateX(-50px)}100%{opacity:1;transform:translateX(0)}}@keyframes uk-fade-right-medium{0%{opacity:0;transform:translateX(50px)}100%{opacity:1;transform:translateX(0)}}@keyframes uk-fade-scale-02{0%{opacity:0;transform:scale(.2)}100%{opacity:1;transform:scale(1)}}@keyframes uk-fade-scale-18{0%{opacity:0;transform:scale(1.8)}100%{opacity:1;transform:scale(1)}}@keyframes uk-scale-kenburns{0%{transform:scale(1)}100%{transform:scale(1.2)}}@keyframes uk-shake{0%,100%{transform:translateX(0)}10%{transform:translateX(-9px)}20%{transform:translateX(8px)}30%{transform:translateX(-7px)}40%{transform:translateX(6px)}50%{transform:translateX(-5px)}60%{transform:translateX(4px)}70%{transform:translateX(-3px)}80%{transform:translateX(2px)}90%{transform:translateX(-1px)}}@keyframes uk-stroke{0%{stroke-dashoffset:var(--uk-animation-stroke)}100%{stroke-dashoffset:0}}[class*=uk-child-width]>*{box-sizing:border-box;width:100%}.uk-child-width-1-2>*{width:50%}.uk-child-width-1-3>*{width:calc(100% * 1 / 3.001)}.uk-child-width-1-4>*{width:25%}.uk-child-width-1-5>*{width:20%}.uk-child-width-1-6>*{width:calc(100% * 1 / 6.001)}.uk-child-width-auto>*{width:auto}.uk-child-width-expand>:not([class*=uk-width]){flex:1;min-width:1px}@media (min-width:640px){.uk-child-width-1-1\@s>*{width:100%}.uk-child-width-1-2\@s>*{width:50%}.uk-child-width-1-3\@s>*{width:calc(100% * 1 / 3.001)}.uk-child-width-1-4\@s>*{width:25%}.uk-child-width-1-5\@s>*{width:20%}.uk-child-width-1-6\@s>*{width:calc(100% * 1 / 6.001)}.uk-child-width-auto\@s>*{width:auto}.uk-child-width-expand\@s>:not([class*=uk-width]){flex:1;min-width:1px}}@media (min-width:960px){.uk-child-width-1-1\@m>*{width:100%}.uk-child-width-1-2\@m>*{width:50%}.uk-child-width-1-3\@m>*{width:calc(100% * 1 / 3.001)}.uk-child-width-1-4\@m>*{width:25%}.uk-child-width-1-5\@m>*{width:20%}.uk-child-width-1-6\@m>*{width:calc(100% * 1 / 6.001)}.uk-child-width-auto\@m>*{width:auto}.uk-child-width-expand\@m>:not([class*=uk-width]){flex:1;min-width:1px}}@media (min-width:1200px){.uk-child-width-1-1\@l>*{width:100%}.uk-child-width-1-2\@l>*{width:50%}.uk-child-width-1-3\@l>*{width:calc(100% * 1 / 3.001)}.uk-child-width-1-4\@l>*{width:25%}.uk-child-width-1-5\@l>*{width:20%}.uk-child-width-1-6\@l>*{width:calc(100% * 1 / 6.001)}.uk-child-width-auto\@l>*{width:auto}.uk-child-width-expand\@l>:not([class*=uk-width]){flex:1;min-width:1px}}@media (min-width:1600px){.uk-child-width-1-1\@xl>*{width:100%}.uk-child-width-1-2\@xl>*{width:50%}.uk-child-width-1-3\@xl>*{width:calc(100% * 1 / 3.001)}.uk-child-width-1-4\@xl>*{width:25%}.uk-child-width-1-5\@xl>*{width:20%}.uk-child-width-1-6\@xl>*{width:calc(100% * 1 / 6.001)}.uk-child-width-auto\@xl>*{width:auto}.uk-child-width-expand\@xl>:not([class*=uk-width]){flex:1;min-width:1px}}[class*=uk-width]{box-sizing:border-box;width:100%;max-width:100%}.uk-width-1-2{width:50%}.uk-width-1-3{width:calc(100% * 1 / 3.001)}.uk-width-2-3{width:calc(100% * 2 / 3.001)}.uk-width-1-4{width:25%}.uk-width-3-4{width:75%}.uk-width-1-5{width:20%}.uk-width-2-5{width:40%}.uk-width-3-5{width:60%}.uk-width-4-5{width:80%}.uk-width-1-6{width:calc(100% * 1 / 6.001)}.uk-width-5-6{width:calc(100% * 5 / 6.001)}.uk-width-small{width:150px}.uk-width-medium{width:300px}.uk-width-large{width:450px}.uk-width-xlarge{width:600px}.uk-width-xxlarge{width:750px}.uk-width-auto{width:auto}.uk-width-expand{flex:1;min-width:1px}@media (min-width:640px){.uk-width-1-1\@s{width:100%}.uk-width-1-2\@s{width:50%}.uk-width-1-3\@s{width:calc(100% * 1 / 3.001)}.uk-width-2-3\@s{width:calc(100% * 2 / 3.001)}.uk-width-1-4\@s{width:25%}.uk-width-3-4\@s{width:75%}.uk-width-1-5\@s{width:20%}.uk-width-2-5\@s{width:40%}.uk-width-3-5\@s{width:60%}.uk-width-4-5\@s{width:80%}.uk-width-1-6\@s{width:calc(100% * 1 / 6.001)}.uk-width-5-6\@s{width:calc(100% * 5 / 6.001)}.uk-width-small\@s{width:150px}.uk-width-medium\@s{width:300px}.uk-width-large\@s{width:450px}.uk-width-xlarge\@s{width:600px}.uk-width-xxlarge\@s{width:750px}.uk-width-auto\@s{width:auto}.uk-width-expand\@s{flex:1;min-width:1px}}@media (min-width:960px){.uk-width-1-1\@m{width:100%}.uk-width-1-2\@m{width:50%}.uk-width-1-3\@m{width:calc(100% * 1 / 3.001)}.uk-width-2-3\@m{width:calc(100% * 2 / 3.001)}.uk-width-1-4\@m{width:25%}.uk-width-3-4\@m{width:75%}.uk-width-1-5\@m{width:20%}.uk-width-2-5\@m{width:40%}.uk-width-3-5\@m{width:60%}.uk-width-4-5\@m{width:80%}.uk-width-1-6\@m{width:calc(100% * 1 / 6.001)}.uk-width-5-6\@m{width:calc(100% * 5 / 6.001)}.uk-width-small\@m{width:150px}.uk-width-medium\@m{width:300px}.uk-width-large\@m{width:450px}.uk-width-xlarge\@m{width:600px}.uk-width-xxlarge\@m{width:750px}.uk-width-auto\@m{width:auto}.uk-width-expand\@m{flex:1;min-width:1px}}@media (min-width:1200px){.uk-width-1-1\@l{width:100%}.uk-width-1-2\@l{width:50%}.uk-width-1-3\@l{width:calc(100% * 1 / 3.001)}.uk-width-2-3\@l{width:calc(100% * 2 / 3.001)}.uk-width-1-4\@l{width:25%}.uk-width-3-4\@l{width:75%}.uk-width-1-5\@l{width:20%}.uk-width-2-5\@l{width:40%}.uk-width-3-5\@l{width:60%}.uk-width-4-5\@l{width:80%}.uk-width-1-6\@l{width:calc(100% * 1 / 6.001)}.uk-width-5-6\@l{width:calc(100% * 5 / 6.001)}.uk-width-small\@l{width:150px}.uk-width-medium\@l{width:300px}.uk-width-large\@l{width:450px}.uk-width-xlarge\@l{width:600px}.uk-width-xxlarge\@l{width:750px}.uk-width-auto\@l{width:auto}.uk-width-expand\@l{flex:1;min-width:1px}}@media (min-width:1600px){.uk-width-1-1\@xl{width:100%}.uk-width-1-2\@xl{width:50%}.uk-width-1-3\@xl{width:calc(100% * 1 / 3.001)}.uk-width-2-3\@xl{width:calc(100% * 2 / 3.001)}.uk-width-1-4\@xl{width:25%}.uk-width-3-4\@xl{width:75%}.uk-width-1-5\@xl{width:20%}.uk-width-2-5\@xl{width:40%}.uk-width-3-5\@xl{width:60%}.uk-width-4-5\@xl{width:80%}.uk-width-1-6\@xl{width:calc(100% * 1 / 6.001)}.uk-width-5-6\@xl{width:calc(100% * 5 / 6.001)}.uk-width-small\@xl{width:150px}.uk-width-medium\@xl{width:300px}.uk-width-large\@xl{width:450px}.uk-width-xlarge\@xl{width:600px}.uk-width-xxlarge\@xl{width:750px}.uk-width-auto\@xl{width:auto}.uk-width-expand\@xl{flex:1;min-width:1px}}[class*=uk-height]{box-sizing:border-box}.uk-height-1-1{height:100%}.uk-height-viewport{min-height:100vh}.uk-height-small{height:150px}.uk-height-medium{height:300px}.uk-height-large{height:450px}.uk-height-max-small{max-height:150px}.uk-height-max-medium{max-height:300px}.uk-height-max-large{max-height:450px}.uk-text-lead{font-size:1.5rem;line-height:1.5;color:#333}.uk-text-meta{font-size:.875rem;line-height:1.4;color:#999}.uk-text-meta a{color:#999}.uk-text-meta a:hover{color:#666;text-decoration:none}.uk-text-small{font-size:.875rem;line-height:1.5}.uk-text-large{font-size:1.5rem;line-height:1.5}.uk-text-light{font-weight:300}.uk-text-normal{font-weight:400}.uk-text-bold{font-weight:700}.uk-text-lighter{font-weight:lighter}.uk-text-bolder{font-weight:bolder}.uk-text-italic{font-style:italic}.uk-text-capitalize{text-transform:capitalize!important}.uk-text-uppercase{text-transform:uppercase!important}.uk-text-lowercase{text-transform:lowercase!important}.uk-text-muted{color:#999!important}.uk-text-emphasis{color:#333!important}.uk-text-primary{color:#1e87f0!important}.uk-text-secondary{color:#222!important}.uk-text-success{color:#32d296!important}.uk-text-warning{color:#faa05a!important}.uk-text-danger{color:#f0506e!important}.uk-text-background{-webkit-background-clip:text;-webkit-text-fill-color:transparent;display:inline-block;color:#1e87f0!important}@supports (-webkit-background-clip:text){.uk-text-background{background-color:#1e87f0}}.uk-text-left{text-align:left!important}.uk-text-right{text-align:right!important}.uk-text-center{text-align:center!important}.uk-text-justify{text-align:justify!important}@media (min-width:640px){.uk-text-left\@s{text-align:left!important}.uk-text-right\@s{text-align:right!important}.uk-text-center\@s{text-align:center!important}}@media (min-width:960px){.uk-text-left\@m{text-align:left!important}.uk-text-right\@m{text-align:right!important}.uk-text-center\@m{text-align:center!important}}@media (min-width:1200px){.uk-text-left\@l{text-align:left!important}.uk-text-right\@l{text-align:right!important}.uk-text-center\@l{text-align:center!important}}@media (min-width:1600px){.uk-text-left\@xl{text-align:left!important}.uk-text-right\@xl{text-align:right!important}.uk-text-center\@xl{text-align:center!important}}.uk-text-top{vertical-align:top!important}.uk-text-middle{vertical-align:middle!important}.uk-text-bottom{vertical-align:bottom!important}.uk-text-baseline{vertical-align:baseline!important}.uk-text-nowrap{white-space:nowrap}.uk-text-truncate{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}td.uk-text-truncate,th.uk-text-truncate{max-width:0}.uk-text-break{overflow-wrap:break-word;word-wrap:break-word}td.uk-text-break,th.uk-text-break{word-break:break-all}[class*=uk-column-]{column-gap:30px}@media (min-width:1200px){[class*=uk-column-]{column-gap:40px}}[class*=uk-column-] img{transform:translate3d(0,0,0)}.uk-column-divider{column-rule:1px solid #e5e5e5;column-gap:60px}@media (min-width:1200px){.uk-column-divider{column-gap:80px}}.uk-column-1-2{column-count:2}.uk-column-1-3{column-count:3}.uk-column-1-4{column-count:4}.uk-column-1-5{column-count:5}.uk-column-1-6{column-count:6}@media (min-width:640px){.uk-column-1-2\@s{column-count:2}.uk-column-1-3\@s{column-count:3}.uk-column-1-4\@s{column-count:4}.uk-column-1-5\@s{column-count:5}.uk-column-1-6\@s{column-count:6}}@media (min-width:960px){.uk-column-1-2\@m{column-count:2}.uk-column-1-3\@m{column-count:3}.uk-column-1-4\@m{column-count:4}.uk-column-1-5\@m{column-count:5}.uk-column-1-6\@m{column-count:6}}@media (min-width:1200px){.uk-column-1-2\@l{column-count:2}.uk-column-1-3\@l{column-count:3}.uk-column-1-4\@l{column-count:4}.uk-column-1-5\@l{column-count:5}.uk-column-1-6\@l{column-count:6}}@media (min-width:1600px){.uk-column-1-2\@xl{column-count:2}.uk-column-1-3\@xl{column-count:3}.uk-column-1-4\@xl{column-count:4}.uk-column-1-5\@xl{column-count:5}.uk-column-1-6\@xl{column-count:6}}.uk-column-span{column-span:all}.uk-cover{max-width:none;position:absolute;left:50%;top:50%;transform:translate(-50%,-50%)}iframe.uk-cover{pointer-events:none}.uk-cover-container{overflow:hidden;position:relative}.uk-background-default{background-color:#fff}.uk-background-muted{background-color:#f8f8f8}.uk-background-primary{background-color:#1e87f0}.uk-background-secondary{background-color:#222}.uk-background-contain,.uk-background-cover{background-position:50% 50%;background-repeat:no-repeat}.uk-background-cover{background-size:cover}.uk-background-contain{background-size:contain}.uk-background-top-left{background-position:0 0}.uk-background-top-center{background-position:50% 0}.uk-background-top-right{background-position:100% 0}.uk-background-center-left{background-position:0 50%}.uk-background-center-center{background-position:50% 50%}.uk-background-center-right{background-position:100% 50%}.uk-background-bottom-left{background-position:0 100%}.uk-background-bottom-center{background-position:50% 100%}.uk-background-bottom-right{background-position:100% 100%}.uk-background-norepeat{background-repeat:no-repeat}.uk-background-fixed{background-attachment:fixed;backface-visibility:hidden}@media (pointer:coarse){.uk-background-fixed{background-attachment:scroll}}@media (max-width:639px){.uk-background-image\@s{background-image:none!important}}@media (max-width:959px){.uk-background-image\@m{background-image:none!important}}@media (max-width:1199px){.uk-background-image\@l{background-image:none!important}}@media (max-width:1599px){.uk-background-image\@xl{background-image:none!important}}.uk-background-blend-multiply{background-blend-mode:multiply}.uk-background-blend-screen{background-blend-mode:screen}.uk-background-blend-overlay{background-blend-mode:overlay}.uk-background-blend-darken{background-blend-mode:darken}.uk-background-blend-lighten{background-blend-mode:lighten}.uk-background-blend-color-dodge{background-blend-mode:color-dodge}.uk-background-blend-color-burn{background-blend-mode:color-burn}.uk-background-blend-hard-light{background-blend-mode:hard-light}.uk-background-blend-soft-light{background-blend-mode:soft-light}.uk-background-blend-difference{background-blend-mode:difference}.uk-background-blend-exclusion{background-blend-mode:exclusion}.uk-background-blend-hue{background-blend-mode:hue}.uk-background-blend-saturation{background-blend-mode:saturation}.uk-background-blend-color{background-blend-mode:color}.uk-background-blend-luminosity{background-blend-mode:luminosity}[class*=uk-align]{display:block;margin-bottom:30px}*+[class*=uk-align]{margin-top:30px}.uk-align-center{margin-left:auto;margin-right:auto}.uk-align-left{margin-top:0;margin-right:30px;float:left}.uk-align-right{margin-top:0;margin-left:30px;float:right}@media (min-width:640px){.uk-align-left\@s{margin-top:0;margin-right:30px;float:left}.uk-align-right\@s{margin-top:0;margin-left:30px;float:right}}@media (min-width:960px){.uk-align-left\@m{margin-top:0;margin-right:30px;float:left}.uk-align-right\@m{margin-top:0;margin-left:30px;float:right}}@media (min-width:1200px){.uk-align-left\@l{margin-top:0;float:left}.uk-align-right\@l{margin-top:0;float:right}.uk-align-left,.uk-align-left\@l,.uk-align-left\@m,.uk-align-left\@s{margin-right:40px}.uk-align-right,.uk-align-right\@l,.uk-align-right\@m,.uk-align-right\@s{margin-left:40px}}@media (min-width:1600px){.uk-align-left\@xl{margin-top:0;margin-right:40px;float:left}.uk-align-right\@xl{margin-top:0;margin-left:40px;float:right}}.uk-svg,.uk-svg:not(.uk-preserve) [fill*='#']:not(.uk-preserve){fill:currentcolor}.uk-svg:not(.uk-preserve) [stroke*='#']:not(.uk-preserve){stroke:currentcolor}.uk-svg{transform:translate(0,0)}.uk-panel{position:relative;box-sizing:border-box}.uk-panel::after,.uk-panel::before{content:"";display:table}.uk-panel::after{clear:both}.uk-panel>:last-child{margin-bottom:0}.uk-panel-scrollable{height:170px;padding:10px;border:1px solid #e5e5e5;overflow:auto;-webkit-overflow-scrolling:touch;resize:both}.uk-clearfix::before{content:"";display:table-cell}.uk-clearfix::after{content:"";display:table;clear:both}.uk-float-left{float:left}.uk-float-right{float:right}[class*=uk-float-]{max-width:100%}.uk-overflow-hidden{overflow:hidden}.uk-overflow-auto{overflow:auto;-webkit-overflow-scrolling:touch}.uk-overflow-auto>:last-child{margin-bottom:0}.uk-resize{resize:both}.uk-resize-vertical{resize:vertical}.uk-display-block{display:block!important}.uk-display-inline{display:inline!important}.uk-display-inline-block{display:inline-block!important}[class*=uk-inline]{display:inline-block;position:relative;max-width:100%;vertical-align:middle;-webkit-backface-visibility:hidden}.uk-inline-clip{overflow:hidden}.uk-preserve-width,.uk-preserve-width canvas,.uk-preserve-width img,.uk-preserve-width svg,.uk-preserve-width video{max-width:none}.uk-responsive-height,.uk-responsive-width{box-sizing:border-box}.uk-responsive-width{max-width:100%!important;height:auto}.uk-responsive-height{max-height:100%;width:auto;max-width:none}.uk-border-circle{border-radius:50%}.uk-border-pill{border-radius:500px}.uk-border-rounded{border-radius:5px}.uk-inline-clip[class*=uk-border-]{-webkit-transform:translateZ(0)}.uk-box-shadow-small{box-shadow:0 2px 8px rgba(0,0,0,.08)}.uk-box-shadow-medium{box-shadow:0 5px 15px rgba(0,0,0,.08)}.uk-box-shadow-large{box-shadow:0 14px 25px rgba(0,0,0,.16)}.uk-box-shadow-xlarge{box-shadow:0 28px 50px rgba(0,0,0,.16)}[class*=uk-box-shadow-hover]{transition:box-shadow .1s ease-in-out}.uk-box-shadow-hover-small:hover{box-shadow:0 2px 8px rgba(0,0,0,.08)}.uk-box-shadow-hover-medium:hover{box-shadow:0 5px 15px rgba(0,0,0,.08)}.uk-box-shadow-hover-large:hover{box-shadow:0 14px 25px rgba(0,0,0,.16)}.uk-box-shadow-hover-xlarge:hover{box-shadow:0 28px 50px rgba(0,0,0,.16)}@supports (filter:blur(0)){.uk-box-shadow-bottom{display:inline-block;position:relative;max-width:100%;vertical-align:middle}.uk-box-shadow-bottom::before{content:'';position:absolute;bottom:-30px;left:0;right:0;height:30px;border-radius:100%;background:#444;filter:blur(20px)}.uk-box-shadow-bottom>*{position:relative}}.uk-dropcap::first-letter,.uk-dropcap>p:first-of-type::first-letter{display:block;margin-right:10px;float:left;font-size:4.5em;line-height:1;margin-bottom:-2px}@-moz-document url-prefix(){.uk-dropcap::first-letter,.uk-dropcap>p:first-of-type::first-letter{margin-top:1.1%}}@supports (-ms-ime-align:auto){.uk-dropcap>p:first-of-type::first-letter{font-size:1em}}.uk-logo{font-size:1.5rem;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";color:#666;text-decoration:none}.uk-logo:focus,.uk-logo:hover{color:#666;outline:0;text-decoration:none}.uk-logo-inverse{display:none}.uk-disabled{pointer-events:none}.uk-drag,.uk-drag *{cursor:move}.uk-drag iframe{pointer-events:none}.uk-dragover{box-shadow:0 0 20px rgba(100,100,100,.3)}.uk-blend-multiply{mix-blend-mode:multiply}.uk-blend-screen{mix-blend-mode:screen}.uk-blend-overlay{mix-blend-mode:overlay}.uk-blend-darken{mix-blend-mode:darken}.uk-blend-lighten{mix-blend-mode:lighten}.uk-blend-color-dodge{mix-blend-mode:color-dodge}.uk-blend-color-burn{mix-blend-mode:color-burn}.uk-blend-hard-light{mix-blend-mode:hard-light}.uk-blend-soft-light{mix-blend-mode:soft-light}.uk-blend-difference{mix-blend-mode:difference}.uk-blend-exclusion{mix-blend-mode:exclusion}.uk-blend-hue{mix-blend-mode:hue}.uk-blend-saturation{mix-blend-mode:saturation}.uk-blend-color{mix-blend-mode:color}.uk-blend-luminosity{mix-blend-mode:luminosity}.uk-transform-center{transform:translate(-50%,-50%)}.uk-transform-origin-top-left{transform-origin:0 0}.uk-transform-origin-top-center{transform-origin:50% 0}.uk-transform-origin-top-right{transform-origin:100% 0}.uk-transform-origin-center-left{transform-origin:0 50%}.uk-transform-origin-center-right{transform-origin:100% 50%}.uk-transform-origin-bottom-left{transform-origin:0 100%}.uk-transform-origin-bottom-center{transform-origin:50% 100%}.uk-transform-origin-bottom-right{transform-origin:100% 100%}.uk-flex{display:flex}.uk-flex-inline{display:inline-flex}.uk-flex-inline::after,.uk-flex-inline::before,.uk-flex::after,.uk-flex::before{display:none}.uk-flex-left{justify-content:flex-start}.uk-flex-center{justify-content:center}.uk-flex-right{justify-content:flex-end}.uk-flex-between{justify-content:space-between}.uk-flex-around{justify-content:space-around}@media (min-width:640px){.uk-flex-left\@s{justify-content:flex-start}.uk-flex-center\@s{justify-content:center}.uk-flex-right\@s{justify-content:flex-end}.uk-flex-between\@s{justify-content:space-between}.uk-flex-around\@s{justify-content:space-around}}@media (min-width:960px){.uk-flex-left\@m{justify-content:flex-start}.uk-flex-center\@m{justify-content:center}.uk-flex-right\@m{justify-content:flex-end}.uk-flex-between\@m{justify-content:space-between}.uk-flex-around\@m{justify-content:space-around}}@media (min-width:1200px){.uk-flex-left\@l{justify-content:flex-start}.uk-flex-center\@l{justify-content:center}.uk-flex-right\@l{justify-content:flex-end}.uk-flex-between\@l{justify-content:space-between}.uk-flex-around\@l{justify-content:space-around}}@media (min-width:1600px){.uk-flex-left\@xl{justify-content:flex-start}.uk-flex-center\@xl{justify-content:center}.uk-flex-right\@xl{justify-content:flex-end}.uk-flex-between\@xl{justify-content:space-between}.uk-flex-around\@xl{justify-content:space-around}}.uk-flex-stretch{align-items:stretch}.uk-flex-top{align-items:flex-start}.uk-flex-middle{align-items:center}.uk-flex-bottom{align-items:flex-end}.uk-flex-row{flex-direction:row}.uk-flex-row-reverse{flex-direction:row-reverse}.uk-flex-column{flex-direction:column}.uk-flex-column-reverse{flex-direction:column-reverse}.uk-flex-nowrap{flex-wrap:nowrap}.uk-flex-wrap{flex-wrap:wrap}.uk-flex-wrap-reverse{flex-wrap:wrap-reverse}.uk-flex-wrap-stretch{align-content:stretch}.uk-flex-wrap-top{align-content:flex-start}.uk-flex-wrap-middle{align-content:center}.uk-flex-wrap-bottom{align-content:flex-end}.uk-flex-wrap-between{align-content:space-between}.uk-flex-wrap-around{align-content:space-around}.uk-flex-first{order:-1}.uk-flex-last{order:99}@media (min-width:640px){.uk-flex-first\@s{order:-1}.uk-flex-last\@s{order:99}}@media (min-width:960px){.uk-flex-first\@m{order:-1}.uk-flex-last\@m{order:99}}@media (min-width:1200px){.uk-flex-first\@l{order:-1}.uk-flex-last\@l{order:99}}@media (min-width:1600px){.uk-flex-first\@xl{order:-1}.uk-flex-last\@xl{order:99}}.uk-flex-none{flex:none}.uk-flex-auto{flex:auto}.uk-flex-1{flex:1}.uk-margin{margin-bottom:20px}*+.uk-margin{margin-top:20px!important}.uk-margin-top{margin-top:20px!important}.uk-margin-bottom{margin-bottom:20px!important}.uk-margin-left{margin-left:20px!important}.uk-margin-right{margin-right:20px!important}.uk-margin-small{margin-bottom:10px}*+.uk-margin-small{margin-top:10px!important}.uk-margin-small-top{margin-top:10px!important}.uk-margin-small-bottom{margin-bottom:10px!important}.uk-margin-small-left{margin-left:10px!important}.uk-margin-small-right{margin-right:10px!important}.uk-margin-medium{margin-bottom:40px}*+.uk-margin-medium{margin-top:40px!important}.uk-margin-medium-top{margin-top:40px!important}.uk-margin-medium-bottom{margin-bottom:40px!important}.uk-margin-medium-left{margin-left:40px!important}.uk-margin-medium-right{margin-right:40px!important}.uk-margin-large{margin-bottom:40px}*+.uk-margin-large{margin-top:40px!important}.uk-margin-large-top{margin-top:40px!important}.uk-margin-large-bottom{margin-bottom:40px!important}.uk-margin-large-left{margin-left:40px!important}.uk-margin-large-right{margin-right:40px!important}@media (min-width:1200px){.uk-margin-large{margin-bottom:70px}*+.uk-margin-large{margin-top:70px!important}.uk-margin-large-top{margin-top:70px!important}.uk-margin-large-bottom{margin-bottom:70px!important}.uk-margin-large-left{margin-left:70px!important}.uk-margin-large-right{margin-right:70px!important}}.uk-margin-xlarge{margin-bottom:70px}*+.uk-margin-xlarge{margin-top:70px!important}.uk-margin-xlarge-top{margin-top:70px!important}.uk-margin-xlarge-bottom{margin-bottom:70px!important}.uk-margin-xlarge-left{margin-left:70px!important}.uk-margin-xlarge-right{margin-right:70px!important}@media (min-width:1200px){.uk-margin-xlarge{margin-bottom:140px}*+.uk-margin-xlarge{margin-top:140px!important}.uk-margin-xlarge-top{margin-top:140px!important}.uk-margin-xlarge-bottom{margin-bottom:140px!important}.uk-margin-xlarge-left{margin-left:140px!important}.uk-margin-xlarge-right{margin-right:140px!important}}.uk-margin-auto{margin-left:auto!important;margin-right:auto!important}.uk-margin-auto-top{margin-top:auto!important}.uk-margin-auto-bottom{margin-bottom:auto!important}.uk-margin-auto-left{margin-left:auto!important}.uk-margin-auto-right{margin-right:auto!important}.uk-margin-auto-vertical{margin-top:auto!important;margin-bottom:auto!important}@media (min-width:640px){.uk-margin-auto\@s{margin-left:auto!important;margin-right:auto!important}.uk-margin-auto-left\@s{margin-left:auto!important}.uk-margin-auto-right\@s{margin-right:auto!important}}@media (min-width:960px){.uk-margin-auto\@m{margin-left:auto!important;margin-right:auto!important}.uk-margin-auto-left\@m{margin-left:auto!important}.uk-margin-auto-right\@m{margin-right:auto!important}}@media (min-width:1200px){.uk-margin-auto\@l{margin-left:auto!important;margin-right:auto!important}.uk-margin-auto-left\@l{margin-left:auto!important}.uk-margin-auto-right\@l{margin-right:auto!important}}@media (min-width:1600px){.uk-margin-auto\@xl{margin-left:auto!important;margin-right:auto!important}.uk-margin-auto-left\@xl{margin-left:auto!important}.uk-margin-auto-right\@xl{margin-right:auto!important}}.uk-margin-remove{margin:0!important}.uk-margin-remove-top{margin-top:0!important}.uk-margin-remove-bottom{margin-bottom:0!important}.uk-margin-remove-left{margin-left:0!important}.uk-margin-remove-right{margin-right:0!important}.uk-margin-remove-vertical{margin-top:0!important;margin-bottom:0!important}.uk-margin-remove-adjacent+*,.uk-margin-remove-first-child>:first-child{margin-top:0!important}.uk-margin-remove-last-child>:last-child{margin-bottom:0!important}@media (min-width:640px){.uk-margin-remove-left\@s{margin-left:0!important}.uk-margin-remove-right\@s{margin-right:0!important}}@media (min-width:960px){.uk-margin-remove-left\@m{margin-left:0!important}.uk-margin-remove-right\@m{margin-right:0!important}}@media (min-width:1200px){.uk-margin-remove-left\@l{margin-left:0!important}.uk-margin-remove-right\@l{margin-right:0!important}}@media (min-width:1600px){.uk-margin-remove-left\@xl{margin-left:0!important}.uk-margin-remove-right\@xl{margin-right:0!important}}.uk-padding{padding:30px}@media (min-width:1200px){.uk-padding{padding:40px}}.uk-padding-small{padding:15px}.uk-padding-large{padding:30px}@media (min-width:1200px){.uk-padding-large{padding:70px}}.uk-padding-remove{padding:0!important}.uk-padding-remove-top{padding-top:0!important}.uk-padding-remove-bottom{padding-bottom:0!important}.uk-padding-remove-left{padding-left:0!important}.uk-padding-remove-right{padding-right:0!important}.uk-padding-remove-vertical{padding-top:0!important;padding-bottom:0!important}.uk-padding-remove-horizontal{padding-left:0!important;padding-right:0!important}[class*=uk-position-bottom],[class*=uk-position-center],[class*=uk-position-left],[class*=uk-position-right],[class*=uk-position-top]{position:absolute!important}.uk-position-top{top:0;left:0;right:0}.uk-position-bottom{bottom:0;left:0;right:0}.uk-position-left{top:0;bottom:0;left:0}.uk-position-right{top:0;bottom:0;right:0}.uk-position-top-left{top:0;left:0}.uk-position-top-right{top:0;right:0}.uk-position-bottom-left{bottom:0;left:0}.uk-position-bottom-right{bottom:0;right:0}.uk-position-center{top:50%;left:50%;transform:translate(-50%,-50%);width:max-content;max-width:100%;box-sizing:border-box}[class*=uk-position-center-left],[class*=uk-position-center-right]{top:50%;transform:translateY(-50%)}.uk-position-center-left{left:0}.uk-position-center-right{right:0}.uk-position-center-left-out{right:100%;width:max-content}.uk-position-center-right-out{left:100%;width:max-content}.uk-position-bottom-center,.uk-position-top-center{left:50%;transform:translateX(-50%);width:max-content;max-width:100%;box-sizing:border-box}.uk-position-top-center{top:0}.uk-position-bottom-center{bottom:0}.uk-position-cover{position:absolute;top:0;bottom:0;left:0;right:0}.uk-position-relative{position:relative!important}.uk-position-absolute{position:absolute!important}.uk-position-fixed{position:fixed!important}.uk-position-z-index{z-index:1}.uk-position-small{max-width:calc(100% - (15px * 2));margin:15px}.uk-position-small.uk-position-center{transform:translate(-50%,-50%) translate(-15px,-15px)}.uk-position-small[class*=uk-position-center-left],.uk-position-small[class*=uk-position-center-right]{transform:translateY(-50%) translateY(-15px)}.uk-position-small.uk-position-bottom-center,.uk-position-small.uk-position-top-center{transform:translateX(-50%) translateX(-15px)}.uk-position-medium{max-width:calc(100% - (30px * 2));margin:30px}.uk-position-medium.uk-position-center{transform:translate(-50%,-50%) translate(-30px,-30px)}.uk-position-medium[class*=uk-position-center-left],.uk-position-medium[class*=uk-position-center-right]{transform:translateY(-50%) translateY(-30px)}.uk-position-medium.uk-position-bottom-center,.uk-position-medium.uk-position-top-center{transform:translateX(-50%) translateX(-30px)}.uk-position-large{max-width:calc(100% - (30px * 2));margin:30px}.uk-position-large.uk-position-center{transform:translate(-50%,-50%) translate(-30px,-30px)}.uk-position-large[class*=uk-position-center-left],.uk-position-large[class*=uk-position-center-right]{transform:translateY(-50%) translateY(-30px)}.uk-position-large.uk-position-bottom-center,.uk-position-large.uk-position-top-center{transform:translateX(-50%) translateX(-30px)}@media (min-width:1200px){.uk-position-large{max-width:calc(100% - (50px * 2));margin:50px}.uk-position-large.uk-position-center{transform:translate(-50%,-50%) translate(-50px,-50px)}.uk-position-large[class*=uk-position-center-left],.uk-position-large[class*=uk-position-center-right]{transform:translateY(-50%) translateY(-50px)}.uk-position-large.uk-position-bottom-center,.uk-position-large.uk-position-top-center{transform:translateX(-50%) translateX(-50px)}}.uk-transition-toggle{-webkit-tap-highlight-color:transparent}.uk-transition-toggle:focus{outline:0}.uk-transition-fade,[class*=uk-transition-scale],[class*=uk-transition-slide]{transition:.3s ease-out;transition-property:opacity,transform,filter;opacity:0}.uk-transition-active.uk-active .uk-transition-fade,.uk-transition-toggle:focus .uk-transition-fade,.uk-transition-toggle:hover .uk-transition-fade{opacity:1}.uk-transition-scale-up{transform:scale(1,1)}.uk-transition-scale-down{transform:scale(1.1,1.1)}.uk-transition-active.uk-active .uk-transition-scale-up,.uk-transition-toggle:focus .uk-transition-scale-up,.uk-transition-toggle:hover .uk-transition-scale-up{opacity:1;transform:scale(1.1,1.1)}.uk-transition-active.uk-active .uk-transition-scale-down,.uk-transition-toggle:focus .uk-transition-scale-down,.uk-transition-toggle:hover .uk-transition-scale-down{opacity:1;transform:scale(1,1)}.uk-transition-slide-top{transform:translateY(-100%)}.uk-transition-slide-bottom{transform:translateY(100%)}.uk-transition-slide-left{transform:translateX(-100%)}.uk-transition-slide-right{transform:translateX(100%)}.uk-transition-slide-top-small{transform:translateY(-10px)}.uk-transition-slide-bottom-small{transform:translateY(10px)}.uk-transition-slide-left-small{transform:translateX(-10px)}.uk-transition-slide-right-small{transform:translateX(10px)}.uk-transition-slide-top-medium{transform:translateY(-50px)}.uk-transition-slide-bottom-medium{transform:translateY(50px)}.uk-transition-slide-left-medium{transform:translateX(-50px)}.uk-transition-slide-right-medium{transform:translateX(50px)}.uk-transition-active.uk-active [class*=uk-transition-slide],.uk-transition-toggle:focus [class*=uk-transition-slide],.uk-transition-toggle:hover [class*=uk-transition-slide]{opacity:1;transform:translate(0,0)}.uk-transition-opaque{opacity:1}.uk-transition-slow{transition-duration:.7s}.uk-hidden,[hidden]{display:none!important}@media (min-width:640px){.uk-hidden\@s{display:none!important}}@media (min-width:960px){.uk-hidden\@m{display:none!important}}@media (min-width:1200px){.uk-hidden\@l{display:none!important}}@media (min-width:1600px){.uk-hidden\@xl{display:none!important}}@media (max-width:639px){.uk-visible\@s{display:none!important}}@media (max-width:959px){.uk-visible\@m{display:none!important}}@media (max-width:1199px){.uk-visible\@l{display:none!important}}@media (max-width:1599px){.uk-visible\@xl{display:none!important}}.uk-invisible{visibility:hidden!important}.uk-visible-toggle:not(:hover):not(:focus) .uk-hidden-hover:not(:focus-within){position:absolute!important;width:0!important;height:0!important;padding:0!important;margin:0!important;overflow:hidden!important}.uk-visible-toggle:not(:hover):not(:focus) .uk-invisible-hover:not(:focus-within){opacity:0!important}.uk-visible-toggle{-webkit-tap-highlight-color:transparent}.uk-visible-toggle:focus{outline:0}@media (pointer:coarse){.uk-hidden-touch{display:none!important}}.uk-hidden-notouch{display:none!important}@media (pointer:coarse){.uk-hidden-notouch{display:block!important}}.uk-card-primary.uk-card-body,.uk-card-primary>:not([class*=uk-card-media]),.uk-card-secondary.uk-card-body,.uk-card-secondary>:not([class*=uk-card-media]),.uk-light,.uk-offcanvas-bar,.uk-overlay-primary,.uk-section-primary:not(.uk-preserve-color),.uk-section-secondary:not(.uk-preserve-color),.uk-tile-primary:not(.uk-preserve-color),.uk-tile-secondary:not(.uk-preserve-color){color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-link,.uk-card-primary.uk-card-body a,.uk-card-primary>:not([class*=uk-card-media]) .uk-link,.uk-card-primary>:not([class*=uk-card-media]) a,.uk-card-secondary.uk-card-body .uk-link,.uk-card-secondary.uk-card-body a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link,.uk-card-secondary>:not([class*=uk-card-media]) a,.uk-light .uk-link,.uk-light a,.uk-offcanvas-bar .uk-link,.uk-offcanvas-bar a,.uk-overlay-primary .uk-link,.uk-overlay-primary a,.uk-section-primary:not(.uk-preserve-color) .uk-link,.uk-section-primary:not(.uk-preserve-color) a,.uk-section-secondary:not(.uk-preserve-color) .uk-link,.uk-section-secondary:not(.uk-preserve-color) a,.uk-tile-primary:not(.uk-preserve-color) .uk-link,.uk-tile-primary:not(.uk-preserve-color) a,.uk-tile-secondary:not(.uk-preserve-color) .uk-link,.uk-tile-secondary:not(.uk-preserve-color) a{color:#fff}.uk-card-primary.uk-card-body .uk-link:hover,.uk-card-primary.uk-card-body a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-link:hover,.uk-card-primary>:not([class*=uk-card-media]) a:hover,.uk-card-secondary.uk-card-body .uk-link:hover,.uk-card-secondary.uk-card-body a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link:hover,.uk-card-secondary>:not([class*=uk-card-media]) a:hover,.uk-light .uk-link:hover,.uk-light a:hover,.uk-offcanvas-bar .uk-link:hover,.uk-offcanvas-bar a:hover,.uk-overlay-primary .uk-link:hover,.uk-overlay-primary a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-link:hover,.uk-section-primary:not(.uk-preserve-color) a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-link:hover,.uk-section-secondary:not(.uk-preserve-color) a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-link:hover,.uk-tile-primary:not(.uk-preserve-color) a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-link:hover,.uk-tile-secondary:not(.uk-preserve-color) a:hover{color:#fff}.uk-card-primary.uk-card-body :not(pre)>code,.uk-card-primary.uk-card-body :not(pre)>kbd,.uk-card-primary.uk-card-body :not(pre)>samp,.uk-card-primary>:not([class*=uk-card-media]) :not(pre)>code,.uk-card-primary>:not([class*=uk-card-media]) :not(pre)>kbd,.uk-card-primary>:not([class*=uk-card-media]) :not(pre)>samp,.uk-card-secondary.uk-card-body :not(pre)>code,.uk-card-secondary.uk-card-body :not(pre)>kbd,.uk-card-secondary.uk-card-body :not(pre)>samp,.uk-card-secondary>:not([class*=uk-card-media]) :not(pre)>code,.uk-card-secondary>:not([class*=uk-card-media]) :not(pre)>kbd,.uk-card-secondary>:not([class*=uk-card-media]) :not(pre)>samp,.uk-light :not(pre)>code,.uk-light :not(pre)>kbd,.uk-light :not(pre)>samp,.uk-offcanvas-bar :not(pre)>code,.uk-offcanvas-bar :not(pre)>kbd,.uk-offcanvas-bar :not(pre)>samp,.uk-overlay-primary :not(pre)>code,.uk-overlay-primary :not(pre)>kbd,.uk-overlay-primary :not(pre)>samp,.uk-section-primary:not(.uk-preserve-color) :not(pre)>code,.uk-section-primary:not(.uk-preserve-color) :not(pre)>kbd,.uk-section-primary:not(.uk-preserve-color) :not(pre)>samp,.uk-section-secondary:not(.uk-preserve-color) :not(pre)>code,.uk-section-secondary:not(.uk-preserve-color) :not(pre)>kbd,.uk-section-secondary:not(.uk-preserve-color) :not(pre)>samp,.uk-tile-primary:not(.uk-preserve-color) :not(pre)>code,.uk-tile-primary:not(.uk-preserve-color) :not(pre)>kbd,.uk-tile-primary:not(.uk-preserve-color) :not(pre)>samp,.uk-tile-secondary:not(.uk-preserve-color) :not(pre)>code,.uk-tile-secondary:not(.uk-preserve-color) :not(pre)>kbd,.uk-tile-secondary:not(.uk-preserve-color) :not(pre)>samp{color:rgba(255,255,255,.7);background:rgba(255,255,255,.1)}.uk-card-primary.uk-card-body em,.uk-card-primary>:not([class*=uk-card-media]) em,.uk-card-secondary.uk-card-body em,.uk-card-secondary>:not([class*=uk-card-media]) em,.uk-light em,.uk-offcanvas-bar em,.uk-overlay-primary em,.uk-section-primary:not(.uk-preserve-color) em,.uk-section-secondary:not(.uk-preserve-color) em,.uk-tile-primary:not(.uk-preserve-color) em,.uk-tile-secondary:not(.uk-preserve-color) em{color:#fff}.uk-card-primary.uk-card-body .uk-h1,.uk-card-primary.uk-card-body .uk-h2,.uk-card-primary.uk-card-body .uk-h3,.uk-card-primary.uk-card-body .uk-h4,.uk-card-primary.uk-card-body .uk-h5,.uk-card-primary.uk-card-body .uk-h6,.uk-card-primary.uk-card-body .uk-heading-2xlarge,.uk-card-primary.uk-card-body .uk-heading-large,.uk-card-primary.uk-card-body .uk-heading-medium,.uk-card-primary.uk-card-body .uk-heading-small,.uk-card-primary.uk-card-body .uk-heading-xlarge,.uk-card-primary.uk-card-body h1,.uk-card-primary.uk-card-body h2,.uk-card-primary.uk-card-body h3,.uk-card-primary.uk-card-body h4,.uk-card-primary.uk-card-body h5,.uk-card-primary.uk-card-body h6,.uk-card-primary>:not([class*=uk-card-media]) .uk-h1,.uk-card-primary>:not([class*=uk-card-media]) .uk-h2,.uk-card-primary>:not([class*=uk-card-media]) .uk-h3,.uk-card-primary>:not([class*=uk-card-media]) .uk-h4,.uk-card-primary>:not([class*=uk-card-media]) .uk-h5,.uk-card-primary>:not([class*=uk-card-media]) .uk-h6,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-2xlarge,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-large,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-medium,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-small,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-xlarge,.uk-card-primary>:not([class*=uk-card-media]) h1,.uk-card-primary>:not([class*=uk-card-media]) h2,.uk-card-primary>:not([class*=uk-card-media]) h3,.uk-card-primary>:not([class*=uk-card-media]) h4,.uk-card-primary>:not([class*=uk-card-media]) h5,.uk-card-primary>:not([class*=uk-card-media]) h6,.uk-card-secondary.uk-card-body .uk-h1,.uk-card-secondary.uk-card-body .uk-h2,.uk-card-secondary.uk-card-body .uk-h3,.uk-card-secondary.uk-card-body .uk-h4,.uk-card-secondary.uk-card-body .uk-h5,.uk-card-secondary.uk-card-body .uk-h6,.uk-card-secondary.uk-card-body .uk-heading-2xlarge,.uk-card-secondary.uk-card-body .uk-heading-large,.uk-card-secondary.uk-card-body .uk-heading-medium,.uk-card-secondary.uk-card-body .uk-heading-small,.uk-card-secondary.uk-card-body .uk-heading-xlarge,.uk-card-secondary.uk-card-body h1,.uk-card-secondary.uk-card-body h2,.uk-card-secondary.uk-card-body h3,.uk-card-secondary.uk-card-body h4,.uk-card-secondary.uk-card-body h5,.uk-card-secondary.uk-card-body h6,.uk-card-secondary>:not([class*=uk-card-media]) .uk-h1,.uk-card-secondary>:not([class*=uk-card-media]) .uk-h2,.uk-card-secondary>:not([class*=uk-card-media]) .uk-h3,.uk-card-secondary>:not([class*=uk-card-media]) .uk-h4,.uk-card-secondary>:not([class*=uk-card-media]) .uk-h5,.uk-card-secondary>:not([class*=uk-card-media]) .uk-h6,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-2xlarge,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-large,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-medium,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-small,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-xlarge,.uk-card-secondary>:not([class*=uk-card-media]) h1,.uk-card-secondary>:not([class*=uk-card-media]) h2,.uk-card-secondary>:not([class*=uk-card-media]) h3,.uk-card-secondary>:not([class*=uk-card-media]) h4,.uk-card-secondary>:not([class*=uk-card-media]) h5,.uk-card-secondary>:not([class*=uk-card-media]) h6,.uk-light .uk-h1,.uk-light .uk-h2,.uk-light .uk-h3,.uk-light .uk-h4,.uk-light .uk-h5,.uk-light .uk-h6,.uk-light .uk-heading-2xlarge,.uk-light .uk-heading-large,.uk-light .uk-heading-medium,.uk-light .uk-heading-small,.uk-light .uk-heading-xlarge,.uk-light h1,.uk-light h2,.uk-light h3,.uk-light h4,.uk-light h5,.uk-light h6,.uk-offcanvas-bar .uk-h1,.uk-offcanvas-bar .uk-h2,.uk-offcanvas-bar .uk-h3,.uk-offcanvas-bar .uk-h4,.uk-offcanvas-bar .uk-h5,.uk-offcanvas-bar .uk-h6,.uk-offcanvas-bar .uk-heading-2xlarge,.uk-offcanvas-bar .uk-heading-large,.uk-offcanvas-bar .uk-heading-medium,.uk-offcanvas-bar .uk-heading-small,.uk-offcanvas-bar .uk-heading-xlarge,.uk-offcanvas-bar h1,.uk-offcanvas-bar h2,.uk-offcanvas-bar h3,.uk-offcanvas-bar h4,.uk-offcanvas-bar h5,.uk-offcanvas-bar h6,.uk-overlay-primary .uk-h1,.uk-overlay-primary .uk-h2,.uk-overlay-primary .uk-h3,.uk-overlay-primary .uk-h4,.uk-overlay-primary .uk-h5,.uk-overlay-primary .uk-h6,.uk-overlay-primary .uk-heading-2xlarge,.uk-overlay-primary .uk-heading-large,.uk-overlay-primary .uk-heading-medium,.uk-overlay-primary .uk-heading-small,.uk-overlay-primary .uk-heading-xlarge,.uk-overlay-primary h1,.uk-overlay-primary h2,.uk-overlay-primary h3,.uk-overlay-primary h4,.uk-overlay-primary h5,.uk-overlay-primary h6,.uk-section-primary:not(.uk-preserve-color) .uk-h1,.uk-section-primary:not(.uk-preserve-color) .uk-h2,.uk-section-primary:not(.uk-preserve-color) .uk-h3,.uk-section-primary:not(.uk-preserve-color) .uk-h4,.uk-section-primary:not(.uk-preserve-color) .uk-h5,.uk-section-primary:not(.uk-preserve-color) .uk-h6,.uk-section-primary:not(.uk-preserve-color) .uk-heading-2xlarge,.uk-section-primary:not(.uk-preserve-color) .uk-heading-large,.uk-section-primary:not(.uk-preserve-color) .uk-heading-medium,.uk-section-primary:not(.uk-preserve-color) .uk-heading-small,.uk-section-primary:not(.uk-preserve-color) .uk-heading-xlarge,.uk-section-primary:not(.uk-preserve-color) h1,.uk-section-primary:not(.uk-preserve-color) h2,.uk-section-primary:not(.uk-preserve-color) h3,.uk-section-primary:not(.uk-preserve-color) h4,.uk-section-primary:not(.uk-preserve-color) h5,.uk-section-primary:not(.uk-preserve-color) h6,.uk-section-secondary:not(.uk-preserve-color) .uk-h1,.uk-section-secondary:not(.uk-preserve-color) .uk-h2,.uk-section-secondary:not(.uk-preserve-color) .uk-h3,.uk-section-secondary:not(.uk-preserve-color) .uk-h4,.uk-section-secondary:not(.uk-preserve-color) .uk-h5,.uk-section-secondary:not(.uk-preserve-color) .uk-h6,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-2xlarge,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-large,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-medium,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-small,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-xlarge,.uk-section-secondary:not(.uk-preserve-color) h1,.uk-section-secondary:not(.uk-preserve-color) h2,.uk-section-secondary:not(.uk-preserve-color) h3,.uk-section-secondary:not(.uk-preserve-color) h4,.uk-section-secondary:not(.uk-preserve-color) h5,.uk-section-secondary:not(.uk-preserve-color) h6,.uk-tile-primary:not(.uk-preserve-color) .uk-h1,.uk-tile-primary:not(.uk-preserve-color) .uk-h2,.uk-tile-primary:not(.uk-preserve-color) .uk-h3,.uk-tile-primary:not(.uk-preserve-color) .uk-h4,.uk-tile-primary:not(.uk-preserve-color) .uk-h5,.uk-tile-primary:not(.uk-preserve-color) .uk-h6,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-2xlarge,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-large,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-medium,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-small,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-xlarge,.uk-tile-primary:not(.uk-preserve-color) h1,.uk-tile-primary:not(.uk-preserve-color) h2,.uk-tile-primary:not(.uk-preserve-color) h3,.uk-tile-primary:not(.uk-preserve-color) h4,.uk-tile-primary:not(.uk-preserve-color) h5,.uk-tile-primary:not(.uk-preserve-color) h6,.uk-tile-secondary:not(.uk-preserve-color) .uk-h1,.uk-tile-secondary:not(.uk-preserve-color) .uk-h2,.uk-tile-secondary:not(.uk-preserve-color) .uk-h3,.uk-tile-secondary:not(.uk-preserve-color) .uk-h4,.uk-tile-secondary:not(.uk-preserve-color) .uk-h5,.uk-tile-secondary:not(.uk-preserve-color) .uk-h6,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-2xlarge,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-large,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-medium,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-small,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-xlarge,.uk-tile-secondary:not(.uk-preserve-color) h1,.uk-tile-secondary:not(.uk-preserve-color) h2,.uk-tile-secondary:not(.uk-preserve-color) h3,.uk-tile-secondary:not(.uk-preserve-color) h4,.uk-tile-secondary:not(.uk-preserve-color) h5,.uk-tile-secondary:not(.uk-preserve-color) h6{color:#fff}.uk-card-primary.uk-card-body blockquote,.uk-card-primary>:not([class*=uk-card-media]) blockquote,.uk-card-secondary.uk-card-body blockquote,.uk-card-secondary>:not([class*=uk-card-media]) blockquote,.uk-light blockquote,.uk-offcanvas-bar blockquote,.uk-overlay-primary blockquote,.uk-section-primary:not(.uk-preserve-color) blockquote,.uk-section-secondary:not(.uk-preserve-color) blockquote,.uk-tile-primary:not(.uk-preserve-color) blockquote,.uk-tile-secondary:not(.uk-preserve-color) blockquote{color:#fff}.uk-card-primary.uk-card-body blockquote footer,.uk-card-primary>:not([class*=uk-card-media]) blockquote footer,.uk-card-secondary.uk-card-body blockquote footer,.uk-card-secondary>:not([class*=uk-card-media]) blockquote footer,.uk-light blockquote footer,.uk-offcanvas-bar blockquote footer,.uk-overlay-primary blockquote footer,.uk-section-primary:not(.uk-preserve-color) blockquote footer,.uk-section-secondary:not(.uk-preserve-color) blockquote footer,.uk-tile-primary:not(.uk-preserve-color) blockquote footer,.uk-tile-secondary:not(.uk-preserve-color) blockquote footer{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-hr,.uk-card-primary.uk-card-body hr,.uk-card-primary>:not([class*=uk-card-media]) .uk-hr,.uk-card-primary>:not([class*=uk-card-media]) hr,.uk-card-secondary.uk-card-body .uk-hr,.uk-card-secondary.uk-card-body hr,.uk-card-secondary>:not([class*=uk-card-media]) .uk-hr,.uk-card-secondary>:not([class*=uk-card-media]) hr,.uk-light .uk-hr,.uk-light hr,.uk-offcanvas-bar .uk-hr,.uk-offcanvas-bar hr,.uk-overlay-primary .uk-hr,.uk-overlay-primary hr,.uk-section-primary:not(.uk-preserve-color) .uk-hr,.uk-section-primary:not(.uk-preserve-color) hr,.uk-section-secondary:not(.uk-preserve-color) .uk-hr,.uk-section-secondary:not(.uk-preserve-color) hr,.uk-tile-primary:not(.uk-preserve-color) .uk-hr,.uk-tile-primary:not(.uk-preserve-color) hr,.uk-tile-secondary:not(.uk-preserve-color) .uk-hr,.uk-tile-secondary:not(.uk-preserve-color) hr{border-top-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-link-muted,.uk-card-primary.uk-card-body .uk-link-muted a,.uk-card-primary>:not([class*=uk-card-media]) .uk-link-muted,.uk-card-primary>:not([class*=uk-card-media]) .uk-link-muted a,.uk-card-secondary.uk-card-body .uk-link-muted,.uk-card-secondary.uk-card-body .uk-link-muted a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link-muted,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link-muted a,.uk-light .uk-link-muted,.uk-light .uk-link-muted a,.uk-offcanvas-bar .uk-link-muted,.uk-offcanvas-bar .uk-link-muted a,.uk-overlay-primary .uk-link-muted,.uk-overlay-primary .uk-link-muted a,.uk-section-primary:not(.uk-preserve-color) .uk-link-muted,.uk-section-primary:not(.uk-preserve-color) .uk-link-muted a,.uk-section-secondary:not(.uk-preserve-color) .uk-link-muted,.uk-section-secondary:not(.uk-preserve-color) .uk-link-muted a,.uk-tile-primary:not(.uk-preserve-color) .uk-link-muted,.uk-tile-primary:not(.uk-preserve-color) .uk-link-muted a,.uk-tile-secondary:not(.uk-preserve-color) .uk-link-muted,.uk-tile-secondary:not(.uk-preserve-color) .uk-link-muted a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-link-muted a:hover,.uk-card-primary.uk-card-body .uk-link-muted:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-link-muted a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-link-muted:hover,.uk-card-secondary.uk-card-body .uk-link-muted a:hover,.uk-card-secondary.uk-card-body .uk-link-muted:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link-muted a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link-muted:hover,.uk-light .uk-link-muted a:hover,.uk-light .uk-link-muted:hover,.uk-offcanvas-bar .uk-link-muted a:hover,.uk-offcanvas-bar .uk-link-muted:hover,.uk-overlay-primary .uk-link-muted a:hover,.uk-overlay-primary .uk-link-muted:hover,.uk-section-primary:not(.uk-preserve-color) .uk-link-muted a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-link-muted:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-link-muted a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-link-muted:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-link-muted a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-link-muted:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-link-muted a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-link-muted:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-link-text a:hover,.uk-card-primary.uk-card-body .uk-link-text:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-link-text a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-link-text:hover,.uk-card-secondary.uk-card-body .uk-link-text a:hover,.uk-card-secondary.uk-card-body .uk-link-text:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link-text a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link-text:hover,.uk-light .uk-link-text a:hover,.uk-light .uk-link-text:hover,.uk-offcanvas-bar .uk-link-text a:hover,.uk-offcanvas-bar .uk-link-text:hover,.uk-overlay-primary .uk-link-text a:hover,.uk-overlay-primary .uk-link-text:hover,.uk-section-primary:not(.uk-preserve-color) .uk-link-text a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-link-text:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-link-text a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-link-text:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-link-text a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-link-text:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-link-text a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-link-text:hover{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-link-heading a:hover,.uk-card-primary.uk-card-body .uk-link-heading:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-link-heading a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-link-heading:hover,.uk-card-secondary.uk-card-body .uk-link-heading a:hover,.uk-card-secondary.uk-card-body .uk-link-heading:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link-heading a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-link-heading:hover,.uk-light .uk-link-heading a:hover,.uk-light .uk-link-heading:hover,.uk-offcanvas-bar .uk-link-heading a:hover,.uk-offcanvas-bar .uk-link-heading:hover,.uk-overlay-primary .uk-link-heading a:hover,.uk-overlay-primary .uk-link-heading:hover,.uk-section-primary:not(.uk-preserve-color) .uk-link-heading a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-link-heading:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-link-heading a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-link-heading:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-link-heading a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-link-heading:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-link-heading a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-link-heading:hover{color:#fff}.uk-card-primary.uk-card-body .uk-heading-divider,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-divider,.uk-card-secondary.uk-card-body .uk-heading-divider,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-divider,.uk-light .uk-heading-divider,.uk-offcanvas-bar .uk-heading-divider,.uk-overlay-primary .uk-heading-divider,.uk-section-primary:not(.uk-preserve-color) .uk-heading-divider,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-divider,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-divider,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-divider{border-bottom-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-heading-bullet::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-bullet::before,.uk-card-secondary.uk-card-body .uk-heading-bullet::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-bullet::before,.uk-light .uk-heading-bullet::before,.uk-offcanvas-bar .uk-heading-bullet::before,.uk-overlay-primary .uk-heading-bullet::before,.uk-section-primary:not(.uk-preserve-color) .uk-heading-bullet::before,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-bullet::before,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-bullet::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-bullet::before{border-left-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-heading-line>::after,.uk-card-primary.uk-card-body .uk-heading-line>::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-line>::after,.uk-card-primary>:not([class*=uk-card-media]) .uk-heading-line>::before,.uk-card-secondary.uk-card-body .uk-heading-line>::after,.uk-card-secondary.uk-card-body .uk-heading-line>::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-line>::after,.uk-card-secondary>:not([class*=uk-card-media]) .uk-heading-line>::before,.uk-light .uk-heading-line>::after,.uk-light .uk-heading-line>::before,.uk-offcanvas-bar .uk-heading-line>::after,.uk-offcanvas-bar .uk-heading-line>::before,.uk-overlay-primary .uk-heading-line>::after,.uk-overlay-primary .uk-heading-line>::before,.uk-section-primary:not(.uk-preserve-color) .uk-heading-line>::after,.uk-section-primary:not(.uk-preserve-color) .uk-heading-line>::before,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-line>::after,.uk-section-secondary:not(.uk-preserve-color) .uk-heading-line>::before,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-line>::after,.uk-tile-primary:not(.uk-preserve-color) .uk-heading-line>::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-line>::after,.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-line>::before{border-bottom-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-divider-icon,.uk-card-primary>:not([class*=uk-card-media]) .uk-divider-icon,.uk-card-secondary.uk-card-body .uk-divider-icon,.uk-card-secondary>:not([class*=uk-card-media]) .uk-divider-icon,.uk-light .uk-divider-icon,.uk-offcanvas-bar .uk-divider-icon,.uk-overlay-primary .uk-divider-icon,.uk-section-primary:not(.uk-preserve-color) .uk-divider-icon,.uk-section-secondary:not(.uk-preserve-color) .uk-divider-icon,.uk-tile-primary:not(.uk-preserve-color) .uk-divider-icon,.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-icon{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2220%22%20height%3D%2220%22%20viewBox%3D%220%200%2020%2020%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22none%22%20stroke%3D%22rgba%28255,%20255,%20255,%200.2%29%22%20stroke-width%3D%222%22%20cx%3D%2210%22%20cy%3D%2210%22%20r%3D%227%22%20%2F%3E%0A%3C%2Fsvg%3E%0A")}.uk-card-primary.uk-card-body .uk-divider-icon::after,.uk-card-primary.uk-card-body .uk-divider-icon::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-divider-icon::after,.uk-card-primary>:not([class*=uk-card-media]) .uk-divider-icon::before,.uk-card-secondary.uk-card-body .uk-divider-icon::after,.uk-card-secondary.uk-card-body .uk-divider-icon::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-divider-icon::after,.uk-card-secondary>:not([class*=uk-card-media]) .uk-divider-icon::before,.uk-light .uk-divider-icon::after,.uk-light .uk-divider-icon::before,.uk-offcanvas-bar .uk-divider-icon::after,.uk-offcanvas-bar .uk-divider-icon::before,.uk-overlay-primary .uk-divider-icon::after,.uk-overlay-primary .uk-divider-icon::before,.uk-section-primary:not(.uk-preserve-color) .uk-divider-icon::after,.uk-section-primary:not(.uk-preserve-color) .uk-divider-icon::before,.uk-section-secondary:not(.uk-preserve-color) .uk-divider-icon::after,.uk-section-secondary:not(.uk-preserve-color) .uk-divider-icon::before,.uk-tile-primary:not(.uk-preserve-color) .uk-divider-icon::after,.uk-tile-primary:not(.uk-preserve-color) .uk-divider-icon::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-icon::after,.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-icon::before{border-bottom-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-divider-small::after,.uk-card-primary>:not([class*=uk-card-media]) .uk-divider-small::after,.uk-card-secondary.uk-card-body .uk-divider-small::after,.uk-card-secondary>:not([class*=uk-card-media]) .uk-divider-small::after,.uk-light .uk-divider-small::after,.uk-offcanvas-bar .uk-divider-small::after,.uk-overlay-primary .uk-divider-small::after,.uk-section-primary:not(.uk-preserve-color) .uk-divider-small::after,.uk-section-secondary:not(.uk-preserve-color) .uk-divider-small::after,.uk-tile-primary:not(.uk-preserve-color) .uk-divider-small::after,.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-small::after{border-top-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-divider-vertical,.uk-card-primary>:not([class*=uk-card-media]) .uk-divider-vertical,.uk-card-secondary.uk-card-body .uk-divider-vertical,.uk-card-secondary>:not([class*=uk-card-media]) .uk-divider-vertical,.uk-light .uk-divider-vertical,.uk-offcanvas-bar .uk-divider-vertical,.uk-overlay-primary .uk-divider-vertical,.uk-section-primary:not(.uk-preserve-color) .uk-divider-vertical,.uk-section-secondary:not(.uk-preserve-color) .uk-divider-vertical,.uk-tile-primary:not(.uk-preserve-color) .uk-divider-vertical,.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-vertical{border-left-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-list-divider>li:nth-child(n+2),.uk-card-primary>:not([class*=uk-card-media]) .uk-list-divider>li:nth-child(n+2),.uk-card-secondary.uk-card-body .uk-list-divider>li:nth-child(n+2),.uk-card-secondary>:not([class*=uk-card-media]) .uk-list-divider>li:nth-child(n+2),.uk-light .uk-list-divider>li:nth-child(n+2),.uk-offcanvas-bar .uk-list-divider>li:nth-child(n+2),.uk-overlay-primary .uk-list-divider>li:nth-child(n+2),.uk-section-primary:not(.uk-preserve-color) .uk-list-divider>li:nth-child(n+2),.uk-section-secondary:not(.uk-preserve-color) .uk-list-divider>li:nth-child(n+2),.uk-tile-primary:not(.uk-preserve-color) .uk-list-divider>li:nth-child(n+2),.uk-tile-secondary:not(.uk-preserve-color) .uk-list-divider>li:nth-child(n+2){border-top-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-list-striped>li:nth-of-type(odd),.uk-card-primary>:not([class*=uk-card-media]) .uk-list-striped>li:nth-of-type(odd),.uk-card-secondary.uk-card-body .uk-list-striped>li:nth-of-type(odd),.uk-card-secondary>:not([class*=uk-card-media]) .uk-list-striped>li:nth-of-type(odd),.uk-light .uk-list-striped>li:nth-of-type(odd),.uk-offcanvas-bar .uk-list-striped>li:nth-of-type(odd),.uk-overlay-primary .uk-list-striped>li:nth-of-type(odd),.uk-section-primary:not(.uk-preserve-color) .uk-list-striped>li:nth-of-type(odd),.uk-section-secondary:not(.uk-preserve-color) .uk-list-striped>li:nth-of-type(odd),.uk-tile-primary:not(.uk-preserve-color) .uk-list-striped>li:nth-of-type(odd),.uk-tile-secondary:not(.uk-preserve-color) .uk-list-striped>li:nth-of-type(odd){border-top-color:rgba(255,255,255,.2);border-bottom-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-list-striped>li:nth-of-type(odd),.uk-card-primary>:not([class*=uk-card-media]) .uk-list-striped>li:nth-of-type(odd),.uk-card-secondary.uk-card-body .uk-list-striped>li:nth-of-type(odd),.uk-card-secondary>:not([class*=uk-card-media]) .uk-list-striped>li:nth-of-type(odd),.uk-light .uk-list-striped>li:nth-of-type(odd),.uk-offcanvas-bar .uk-list-striped>li:nth-of-type(odd),.uk-overlay-primary .uk-list-striped>li:nth-of-type(odd),.uk-section-primary:not(.uk-preserve-color) .uk-list-striped>li:nth-of-type(odd),.uk-section-secondary:not(.uk-preserve-color) .uk-list-striped>li:nth-of-type(odd),.uk-tile-primary:not(.uk-preserve-color) .uk-list-striped>li:nth-of-type(odd),.uk-tile-secondary:not(.uk-preserve-color) .uk-list-striped>li:nth-of-type(odd){background-color:rgba(255,255,255,.1)}.uk-card-primary.uk-card-body .uk-list-bullet>li::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-list-bullet>li::before,.uk-card-secondary.uk-card-body .uk-list-bullet>li::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-list-bullet>li::before,.uk-light .uk-list-bullet>li::before,.uk-offcanvas-bar .uk-list-bullet>li::before,.uk-overlay-primary .uk-list-bullet>li::before,.uk-section-primary:not(.uk-preserve-color) .uk-list-bullet>li::before,.uk-section-secondary:not(.uk-preserve-color) .uk-list-bullet>li::before,.uk-tile-primary:not(.uk-preserve-color) .uk-list-bullet>li::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-list-bullet>li::before{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%226%22%20height%3D%226%22%20viewBox%3D%220%200%206%206%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20cx%3D%223%22%20cy%3D%223%22%20r%3D%223%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-card-primary.uk-card-body .uk-table th,.uk-card-primary>:not([class*=uk-card-media]) .uk-table th,.uk-card-secondary.uk-card-body .uk-table th,.uk-card-secondary>:not([class*=uk-card-media]) .uk-table th,.uk-light .uk-table th,.uk-offcanvas-bar .uk-table th,.uk-overlay-primary .uk-table th,.uk-section-primary:not(.uk-preserve-color) .uk-table th,.uk-section-secondary:not(.uk-preserve-color) .uk-table th,.uk-tile-primary:not(.uk-preserve-color) .uk-table th,.uk-tile-secondary:not(.uk-preserve-color) .uk-table th{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-table caption,.uk-card-primary>:not([class*=uk-card-media]) .uk-table caption,.uk-card-secondary.uk-card-body .uk-table caption,.uk-card-secondary>:not([class*=uk-card-media]) .uk-table caption,.uk-light .uk-table caption,.uk-offcanvas-bar .uk-table caption,.uk-overlay-primary .uk-table caption,.uk-section-primary:not(.uk-preserve-color) .uk-table caption,.uk-section-secondary:not(.uk-preserve-color) .uk-table caption,.uk-tile-primary:not(.uk-preserve-color) .uk-table caption,.uk-tile-secondary:not(.uk-preserve-color) .uk-table caption{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-table tbody tr.uk-active,.uk-card-primary.uk-card-body .uk-table>tr.uk-active,.uk-card-primary>:not([class*=uk-card-media]) .uk-table tbody tr.uk-active,.uk-card-primary>:not([class*=uk-card-media]) .uk-table>tr.uk-active,.uk-card-secondary.uk-card-body .uk-table tbody tr.uk-active,.uk-card-secondary.uk-card-body .uk-table>tr.uk-active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-table tbody tr.uk-active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-table>tr.uk-active,.uk-light .uk-table tbody tr.uk-active,.uk-light .uk-table>tr.uk-active,.uk-offcanvas-bar .uk-table tbody tr.uk-active,.uk-offcanvas-bar .uk-table>tr.uk-active,.uk-overlay-primary .uk-table tbody tr.uk-active,.uk-overlay-primary .uk-table>tr.uk-active,.uk-section-primary:not(.uk-preserve-color) .uk-table tbody tr.uk-active,.uk-section-primary:not(.uk-preserve-color) .uk-table>tr.uk-active,.uk-section-secondary:not(.uk-preserve-color) .uk-table tbody tr.uk-active,.uk-section-secondary:not(.uk-preserve-color) .uk-table>tr.uk-active,.uk-tile-primary:not(.uk-preserve-color) .uk-table tbody tr.uk-active,.uk-tile-primary:not(.uk-preserve-color) .uk-table>tr.uk-active,.uk-tile-secondary:not(.uk-preserve-color) .uk-table tbody tr.uk-active,.uk-tile-secondary:not(.uk-preserve-color) .uk-table>tr.uk-active{background:rgba(255,255,255,.08)}.uk-card-primary.uk-card-body .uk-table-divider>:first-child>tr:not(:first-child),.uk-card-primary.uk-card-body .uk-table-divider>:not(:first-child)>tr,.uk-card-primary.uk-card-body .uk-table-divider>tr:not(:first-child),.uk-card-primary>:not([class*=uk-card-media]) .uk-table-divider>:first-child>tr:not(:first-child),.uk-card-primary>:not([class*=uk-card-media]) .uk-table-divider>:not(:first-child)>tr,.uk-card-primary>:not([class*=uk-card-media]) .uk-table-divider>tr:not(:first-child),.uk-card-secondary.uk-card-body .uk-table-divider>:first-child>tr:not(:first-child),.uk-card-secondary.uk-card-body .uk-table-divider>:not(:first-child)>tr,.uk-card-secondary.uk-card-body .uk-table-divider>tr:not(:first-child),.uk-card-secondary>:not([class*=uk-card-media]) .uk-table-divider>:first-child>tr:not(:first-child),.uk-card-secondary>:not([class*=uk-card-media]) .uk-table-divider>:not(:first-child)>tr,.uk-card-secondary>:not([class*=uk-card-media]) .uk-table-divider>tr:not(:first-child),.uk-light .uk-table-divider>:first-child>tr:not(:first-child),.uk-light .uk-table-divider>:not(:first-child)>tr,.uk-light .uk-table-divider>tr:not(:first-child),.uk-offcanvas-bar .uk-table-divider>:first-child>tr:not(:first-child),.uk-offcanvas-bar .uk-table-divider>:not(:first-child)>tr,.uk-offcanvas-bar .uk-table-divider>tr:not(:first-child),.uk-overlay-primary .uk-table-divider>:first-child>tr:not(:first-child),.uk-overlay-primary .uk-table-divider>:not(:first-child)>tr,.uk-overlay-primary .uk-table-divider>tr:not(:first-child),.uk-section-primary:not(.uk-preserve-color) .uk-table-divider>:first-child>tr:not(:first-child),.uk-section-primary:not(.uk-preserve-color) .uk-table-divider>:not(:first-child)>tr,.uk-section-primary:not(.uk-preserve-color) .uk-table-divider>tr:not(:first-child),.uk-section-secondary:not(.uk-preserve-color) .uk-table-divider>:first-child>tr:not(:first-child),.uk-section-secondary:not(.uk-preserve-color) .uk-table-divider>:not(:first-child)>tr,.uk-section-secondary:not(.uk-preserve-color) .uk-table-divider>tr:not(:first-child),.uk-tile-primary:not(.uk-preserve-color) .uk-table-divider>:first-child>tr:not(:first-child),.uk-tile-primary:not(.uk-preserve-color) .uk-table-divider>:not(:first-child)>tr,.uk-tile-primary:not(.uk-preserve-color) .uk-table-divider>tr:not(:first-child),.uk-tile-secondary:not(.uk-preserve-color) .uk-table-divider>:first-child>tr:not(:first-child),.uk-tile-secondary:not(.uk-preserve-color) .uk-table-divider>:not(:first-child)>tr,.uk-tile-secondary:not(.uk-preserve-color) .uk-table-divider>tr:not(:first-child){border-top-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-table-striped tbody tr:nth-of-type(odd),.uk-card-primary.uk-card-body .uk-table-striped>tr:nth-of-type(odd),.uk-card-primary>:not([class*=uk-card-media]) .uk-table-striped tbody tr:nth-of-type(odd),.uk-card-primary>:not([class*=uk-card-media]) .uk-table-striped>tr:nth-of-type(odd),.uk-card-secondary.uk-card-body .uk-table-striped tbody tr:nth-of-type(odd),.uk-card-secondary.uk-card-body .uk-table-striped>tr:nth-of-type(odd),.uk-card-secondary>:not([class*=uk-card-media]) .uk-table-striped tbody tr:nth-of-type(odd),.uk-card-secondary>:not([class*=uk-card-media]) .uk-table-striped>tr:nth-of-type(odd),.uk-light .uk-table-striped tbody tr:nth-of-type(odd),.uk-light .uk-table-striped>tr:nth-of-type(odd),.uk-offcanvas-bar .uk-table-striped tbody tr:nth-of-type(odd),.uk-offcanvas-bar .uk-table-striped>tr:nth-of-type(odd),.uk-overlay-primary .uk-table-striped tbody tr:nth-of-type(odd),.uk-overlay-primary .uk-table-striped>tr:nth-of-type(odd),.uk-section-primary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(odd),.uk-section-primary:not(.uk-preserve-color) .uk-table-striped>tr:nth-of-type(odd),.uk-section-secondary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(odd),.uk-section-secondary:not(.uk-preserve-color) .uk-table-striped>tr:nth-of-type(odd),.uk-tile-primary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(odd),.uk-tile-primary:not(.uk-preserve-color) .uk-table-striped>tr:nth-of-type(odd),.uk-tile-secondary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(odd),.uk-tile-secondary:not(.uk-preserve-color) .uk-table-striped>tr:nth-of-type(odd){background:rgba(255,255,255,.1);border-top-color:rgba(255,255,255,.2);border-bottom-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-table-hover tbody tr:hover,.uk-card-primary.uk-card-body .uk-table-hover>tr:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-table-hover tbody tr:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-table-hover>tr:hover,.uk-card-secondary.uk-card-body .uk-table-hover tbody tr:hover,.uk-card-secondary.uk-card-body .uk-table-hover>tr:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-table-hover tbody tr:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-table-hover>tr:hover,.uk-light .uk-table-hover tbody tr:hover,.uk-light .uk-table-hover>tr:hover,.uk-offcanvas-bar .uk-table-hover tbody tr:hover,.uk-offcanvas-bar .uk-table-hover>tr:hover,.uk-overlay-primary .uk-table-hover tbody tr:hover,.uk-overlay-primary .uk-table-hover>tr:hover,.uk-section-primary:not(.uk-preserve-color) .uk-table-hover tbody tr:hover,.uk-section-primary:not(.uk-preserve-color) .uk-table-hover>tr:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-table-hover tbody tr:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-table-hover>tr:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-table-hover tbody tr:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-table-hover>tr:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-table-hover tbody tr:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-table-hover>tr:hover{background:rgba(255,255,255,.08)}.uk-card-primary.uk-card-body .uk-icon-link,.uk-card-primary>:not([class*=uk-card-media]) .uk-icon-link,.uk-card-secondary.uk-card-body .uk-icon-link,.uk-card-secondary>:not([class*=uk-card-media]) .uk-icon-link,.uk-light .uk-icon-link,.uk-offcanvas-bar .uk-icon-link,.uk-overlay-primary .uk-icon-link,.uk-section-primary:not(.uk-preserve-color) .uk-icon-link,.uk-section-secondary:not(.uk-preserve-color) .uk-icon-link,.uk-tile-primary:not(.uk-preserve-color) .uk-icon-link,.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-link{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-icon-link:focus,.uk-card-primary.uk-card-body .uk-icon-link:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-icon-link:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-icon-link:hover,.uk-card-secondary.uk-card-body .uk-icon-link:focus,.uk-card-secondary.uk-card-body .uk-icon-link:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-icon-link:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-icon-link:hover,.uk-light .uk-icon-link:focus,.uk-light .uk-icon-link:hover,.uk-offcanvas-bar .uk-icon-link:focus,.uk-offcanvas-bar .uk-icon-link:hover,.uk-overlay-primary .uk-icon-link:focus,.uk-overlay-primary .uk-icon-link:hover,.uk-section-primary:not(.uk-preserve-color) .uk-icon-link:focus,.uk-section-primary:not(.uk-preserve-color) .uk-icon-link:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-icon-link:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-icon-link:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-icon-link:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-icon-link:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-link:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-link:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-active>.uk-icon-link,.uk-card-primary.uk-card-body .uk-icon-link:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-active>.uk-icon-link,.uk-card-primary>:not([class*=uk-card-media]) .uk-icon-link:active,.uk-card-secondary.uk-card-body .uk-active>.uk-icon-link,.uk-card-secondary.uk-card-body .uk-icon-link:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-active>.uk-icon-link,.uk-card-secondary>:not([class*=uk-card-media]) .uk-icon-link:active,.uk-light .uk-active>.uk-icon-link,.uk-light .uk-icon-link:active,.uk-offcanvas-bar .uk-active>.uk-icon-link,.uk-offcanvas-bar .uk-icon-link:active,.uk-overlay-primary .uk-active>.uk-icon-link,.uk-overlay-primary .uk-icon-link:active,.uk-section-primary:not(.uk-preserve-color) .uk-active>.uk-icon-link,.uk-section-primary:not(.uk-preserve-color) .uk-icon-link:active,.uk-section-secondary:not(.uk-preserve-color) .uk-active>.uk-icon-link,.uk-section-secondary:not(.uk-preserve-color) .uk-icon-link:active,.uk-tile-primary:not(.uk-preserve-color) .uk-active>.uk-icon-link,.uk-tile-primary:not(.uk-preserve-color) .uk-icon-link:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-active>.uk-icon-link,.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-link:active{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-icon-button,.uk-card-primary>:not([class*=uk-card-media]) .uk-icon-button,.uk-card-secondary.uk-card-body .uk-icon-button,.uk-card-secondary>:not([class*=uk-card-media]) .uk-icon-button,.uk-light .uk-icon-button,.uk-offcanvas-bar .uk-icon-button,.uk-overlay-primary .uk-icon-button,.uk-section-primary:not(.uk-preserve-color) .uk-icon-button,.uk-section-secondary:not(.uk-preserve-color) .uk-icon-button,.uk-tile-primary:not(.uk-preserve-color) .uk-icon-button,.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-button{background-color:rgba(255,255,255,.1);color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-icon-button:focus,.uk-card-primary.uk-card-body .uk-icon-button:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-icon-button:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-icon-button:hover,.uk-card-secondary.uk-card-body .uk-icon-button:focus,.uk-card-secondary.uk-card-body .uk-icon-button:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-icon-button:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-icon-button:hover,.uk-light .uk-icon-button:focus,.uk-light .uk-icon-button:hover,.uk-offcanvas-bar .uk-icon-button:focus,.uk-offcanvas-bar .uk-icon-button:hover,.uk-overlay-primary .uk-icon-button:focus,.uk-overlay-primary .uk-icon-button:hover,.uk-section-primary:not(.uk-preserve-color) .uk-icon-button:focus,.uk-section-primary:not(.uk-preserve-color) .uk-icon-button:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-icon-button:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-icon-button:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-icon-button:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-icon-button:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-button:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-button:hover{background-color:rgba(242,242,242,.1);color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-icon-button:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-icon-button:active,.uk-card-secondary.uk-card-body .uk-icon-button:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-icon-button:active,.uk-light .uk-icon-button:active,.uk-offcanvas-bar .uk-icon-button:active,.uk-overlay-primary .uk-icon-button:active,.uk-section-primary:not(.uk-preserve-color) .uk-icon-button:active,.uk-section-secondary:not(.uk-preserve-color) .uk-icon-button:active,.uk-tile-primary:not(.uk-preserve-color) .uk-icon-button:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-button:active{background-color:rgba(230,230,230,.1);color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-input,.uk-card-primary.uk-card-body .uk-select,.uk-card-primary.uk-card-body .uk-textarea,.uk-card-primary>:not([class*=uk-card-media]) .uk-input,.uk-card-primary>:not([class*=uk-card-media]) .uk-select,.uk-card-primary>:not([class*=uk-card-media]) .uk-textarea,.uk-card-secondary.uk-card-body .uk-input,.uk-card-secondary.uk-card-body .uk-select,.uk-card-secondary.uk-card-body .uk-textarea,.uk-card-secondary>:not([class*=uk-card-media]) .uk-input,.uk-card-secondary>:not([class*=uk-card-media]) .uk-select,.uk-card-secondary>:not([class*=uk-card-media]) .uk-textarea,.uk-light .uk-input,.uk-light .uk-select,.uk-light .uk-textarea,.uk-offcanvas-bar .uk-input,.uk-offcanvas-bar .uk-select,.uk-offcanvas-bar .uk-textarea,.uk-overlay-primary .uk-input,.uk-overlay-primary .uk-select,.uk-overlay-primary .uk-textarea,.uk-section-primary:not(.uk-preserve-color) .uk-input,.uk-section-primary:not(.uk-preserve-color) .uk-select,.uk-section-primary:not(.uk-preserve-color) .uk-textarea,.uk-section-secondary:not(.uk-preserve-color) .uk-input,.uk-section-secondary:not(.uk-preserve-color) .uk-select,.uk-section-secondary:not(.uk-preserve-color) .uk-textarea,.uk-tile-primary:not(.uk-preserve-color) .uk-input,.uk-tile-primary:not(.uk-preserve-color) .uk-select,.uk-tile-primary:not(.uk-preserve-color) .uk-textarea,.uk-tile-secondary:not(.uk-preserve-color) .uk-input,.uk-tile-secondary:not(.uk-preserve-color) .uk-select,.uk-tile-secondary:not(.uk-preserve-color) .uk-textarea{background-color:rgba(255,255,255,.1);color:rgba(255,255,255,.7);background-clip:padding-box;border-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-input:focus,.uk-card-primary.uk-card-body .uk-select:focus,.uk-card-primary.uk-card-body .uk-textarea:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-input:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-select:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-textarea:focus,.uk-card-secondary.uk-card-body .uk-input:focus,.uk-card-secondary.uk-card-body .uk-select:focus,.uk-card-secondary.uk-card-body .uk-textarea:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-input:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-select:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-textarea:focus,.uk-light .uk-input:focus,.uk-light .uk-select:focus,.uk-light .uk-textarea:focus,.uk-offcanvas-bar .uk-input:focus,.uk-offcanvas-bar .uk-select:focus,.uk-offcanvas-bar .uk-textarea:focus,.uk-overlay-primary .uk-input:focus,.uk-overlay-primary .uk-select:focus,.uk-overlay-primary .uk-textarea:focus,.uk-section-primary:not(.uk-preserve-color) .uk-input:focus,.uk-section-primary:not(.uk-preserve-color) .uk-select:focus,.uk-section-primary:not(.uk-preserve-color) .uk-textarea:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-input:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-select:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-textarea:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-input:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-select:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-textarea:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-input:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-select:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-textarea:focus{background-color:rgba(255,255,255,.1);color:rgba(255,255,255,.7);border-color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-input::-ms-input-placeholder,.uk-card-primary>:not([class*=uk-card-media]) .uk-input::-ms-input-placeholder,.uk-card-secondary.uk-card-body .uk-input::-ms-input-placeholder,.uk-card-secondary>:not([class*=uk-card-media]) .uk-input::-ms-input-placeholder,.uk-light .uk-input::-ms-input-placeholder,.uk-offcanvas-bar .uk-input::-ms-input-placeholder,.uk-overlay-primary .uk-input::-ms-input-placeholder,.uk-section-primary:not(.uk-preserve-color) .uk-input::-ms-input-placeholder,.uk-section-secondary:not(.uk-preserve-color) .uk-input::-ms-input-placeholder,.uk-tile-primary:not(.uk-preserve-color) .uk-input::-ms-input-placeholder,.uk-tile-secondary:not(.uk-preserve-color) .uk-input::-ms-input-placeholder{color:rgba(255,255,255,.5)!important}.uk-card-primary.uk-card-body .uk-input::placeholder,.uk-card-primary>:not([class*=uk-card-media]) .uk-input::placeholder,.uk-card-secondary.uk-card-body .uk-input::placeholder,.uk-card-secondary>:not([class*=uk-card-media]) .uk-input::placeholder,.uk-light .uk-input::placeholder,.uk-offcanvas-bar .uk-input::placeholder,.uk-overlay-primary .uk-input::placeholder,.uk-section-primary:not(.uk-preserve-color) .uk-input::placeholder,.uk-section-secondary:not(.uk-preserve-color) .uk-input::placeholder,.uk-tile-primary:not(.uk-preserve-color) .uk-input::placeholder,.uk-tile-secondary:not(.uk-preserve-color) .uk-input::placeholder{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-textarea::-ms-input-placeholder,.uk-card-primary>:not([class*=uk-card-media]) .uk-textarea::-ms-input-placeholder,.uk-card-secondary.uk-card-body .uk-textarea::-ms-input-placeholder,.uk-card-secondary>:not([class*=uk-card-media]) .uk-textarea::-ms-input-placeholder,.uk-light .uk-textarea::-ms-input-placeholder,.uk-offcanvas-bar .uk-textarea::-ms-input-placeholder,.uk-overlay-primary .uk-textarea::-ms-input-placeholder,.uk-section-primary:not(.uk-preserve-color) .uk-textarea::-ms-input-placeholder,.uk-section-secondary:not(.uk-preserve-color) .uk-textarea::-ms-input-placeholder,.uk-tile-primary:not(.uk-preserve-color) .uk-textarea::-ms-input-placeholder,.uk-tile-secondary:not(.uk-preserve-color) .uk-textarea::-ms-input-placeholder{color:rgba(255,255,255,.5)!important}.uk-card-primary.uk-card-body .uk-textarea::placeholder,.uk-card-primary>:not([class*=uk-card-media]) .uk-textarea::placeholder,.uk-card-secondary.uk-card-body .uk-textarea::placeholder,.uk-card-secondary>:not([class*=uk-card-media]) .uk-textarea::placeholder,.uk-light .uk-textarea::placeholder,.uk-offcanvas-bar .uk-textarea::placeholder,.uk-overlay-primary .uk-textarea::placeholder,.uk-section-primary:not(.uk-preserve-color) .uk-textarea::placeholder,.uk-section-secondary:not(.uk-preserve-color) .uk-textarea::placeholder,.uk-tile-primary:not(.uk-preserve-color) .uk-textarea::placeholder,.uk-tile-secondary:not(.uk-preserve-color) .uk-textarea::placeholder{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-select:not([multiple]):not([size]),.uk-card-primary>:not([class*=uk-card-media]) .uk-select:not([multiple]):not([size]),.uk-card-secondary.uk-card-body .uk-select:not([multiple]):not([size]),.uk-card-secondary>:not([class*=uk-card-media]) .uk-select:not([multiple]):not([size]),.uk-light .uk-select:not([multiple]):not([size]),.uk-offcanvas-bar .uk-select:not([multiple]):not([size]),.uk-overlay-primary .uk-select:not([multiple]):not([size]),.uk-section-primary:not(.uk-preserve-color) .uk-select:not([multiple]):not([size]),.uk-section-secondary:not(.uk-preserve-color) .uk-select:not([multiple]):not([size]),.uk-tile-primary:not(.uk-preserve-color) .uk-select:not([multiple]):not([size]),.uk-tile-secondary:not(.uk-preserve-color) .uk-select:not([multiple]):not([size]){background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20points%3D%2212%201%209%206%2015%206%22%20%2F%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20points%3D%2212%2013%209%208%2015%208%22%20%2F%3E%0A%3C%2Fsvg%3E%0A")}.uk-card-primary.uk-card-body .uk-input[list]:focus,.uk-card-primary.uk-card-body .uk-input[list]:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-input[list]:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-input[list]:hover,.uk-card-secondary.uk-card-body .uk-input[list]:focus,.uk-card-secondary.uk-card-body .uk-input[list]:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-input[list]:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-input[list]:hover,.uk-light .uk-input[list]:focus,.uk-light .uk-input[list]:hover,.uk-offcanvas-bar .uk-input[list]:focus,.uk-offcanvas-bar .uk-input[list]:hover,.uk-overlay-primary .uk-input[list]:focus,.uk-overlay-primary .uk-input[list]:hover,.uk-section-primary:not(.uk-preserve-color) .uk-input[list]:focus,.uk-section-primary:not(.uk-preserve-color) .uk-input[list]:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-input[list]:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-input[list]:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-input[list]:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-input[list]:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-input[list]:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-input[list]:hover{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20points%3D%2212%2012%208%206%2016%206%22%20%2F%3E%0A%3C%2Fsvg%3E%0A")}.uk-card-primary.uk-card-body .uk-checkbox,.uk-card-primary.uk-card-body .uk-radio,.uk-card-primary>:not([class*=uk-card-media]) .uk-checkbox,.uk-card-primary>:not([class*=uk-card-media]) .uk-radio,.uk-card-secondary.uk-card-body .uk-checkbox,.uk-card-secondary.uk-card-body .uk-radio,.uk-card-secondary>:not([class*=uk-card-media]) .uk-checkbox,.uk-card-secondary>:not([class*=uk-card-media]) .uk-radio,.uk-light .uk-checkbox,.uk-light .uk-radio,.uk-offcanvas-bar .uk-checkbox,.uk-offcanvas-bar .uk-radio,.uk-overlay-primary .uk-checkbox,.uk-overlay-primary .uk-radio,.uk-section-primary:not(.uk-preserve-color) .uk-checkbox,.uk-section-primary:not(.uk-preserve-color) .uk-radio,.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox,.uk-section-secondary:not(.uk-preserve-color) .uk-radio,.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox,.uk-tile-primary:not(.uk-preserve-color) .uk-radio,.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox,.uk-tile-secondary:not(.uk-preserve-color) .uk-radio{background-color:rgba(242,242,242,.1);border-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-checkbox:focus,.uk-card-primary.uk-card-body .uk-radio:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-checkbox:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-radio:focus,.uk-card-secondary.uk-card-body .uk-checkbox:focus,.uk-card-secondary.uk-card-body .uk-radio:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-checkbox:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-radio:focus,.uk-light .uk-checkbox:focus,.uk-light .uk-radio:focus,.uk-offcanvas-bar .uk-checkbox:focus,.uk-offcanvas-bar .uk-radio:focus,.uk-overlay-primary .uk-checkbox:focus,.uk-overlay-primary .uk-radio:focus,.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:focus,.uk-section-primary:not(.uk-preserve-color) .uk-radio:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-radio:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-radio:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-radio:focus{border-color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-checkbox:checked,.uk-card-primary.uk-card-body .uk-checkbox:indeterminate,.uk-card-primary.uk-card-body .uk-radio:checked,.uk-card-primary>:not([class*=uk-card-media]) .uk-checkbox:checked,.uk-card-primary>:not([class*=uk-card-media]) .uk-checkbox:indeterminate,.uk-card-primary>:not([class*=uk-card-media]) .uk-radio:checked,.uk-card-secondary.uk-card-body .uk-checkbox:checked,.uk-card-secondary.uk-card-body .uk-checkbox:indeterminate,.uk-card-secondary.uk-card-body .uk-radio:checked,.uk-card-secondary>:not([class*=uk-card-media]) .uk-checkbox:checked,.uk-card-secondary>:not([class*=uk-card-media]) .uk-checkbox:indeterminate,.uk-card-secondary>:not([class*=uk-card-media]) .uk-radio:checked,.uk-light .uk-checkbox:checked,.uk-light .uk-checkbox:indeterminate,.uk-light .uk-radio:checked,.uk-offcanvas-bar .uk-checkbox:checked,.uk-offcanvas-bar .uk-checkbox:indeterminate,.uk-offcanvas-bar .uk-radio:checked,.uk-overlay-primary .uk-checkbox:checked,.uk-overlay-primary .uk-checkbox:indeterminate,.uk-overlay-primary .uk-radio:checked,.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:checked,.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate,.uk-section-primary:not(.uk-preserve-color) .uk-radio:checked,.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:checked,.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate,.uk-section-secondary:not(.uk-preserve-color) .uk-radio:checked,.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:checked,.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate,.uk-tile-primary:not(.uk-preserve-color) .uk-radio:checked,.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:checked,.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate,.uk-tile-secondary:not(.uk-preserve-color) .uk-radio:checked{background-color:#fff;border-color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-checkbox:checked:focus,.uk-card-primary.uk-card-body .uk-checkbox:indeterminate:focus,.uk-card-primary.uk-card-body .uk-radio:checked:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-checkbox:checked:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-checkbox:indeterminate:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-radio:checked:focus,.uk-card-secondary.uk-card-body .uk-checkbox:checked:focus,.uk-card-secondary.uk-card-body .uk-checkbox:indeterminate:focus,.uk-card-secondary.uk-card-body .uk-radio:checked:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-checkbox:checked:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-checkbox:indeterminate:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-radio:checked:focus,.uk-light .uk-checkbox:checked:focus,.uk-light .uk-checkbox:indeterminate:focus,.uk-light .uk-radio:checked:focus,.uk-offcanvas-bar .uk-checkbox:checked:focus,.uk-offcanvas-bar .uk-checkbox:indeterminate:focus,.uk-offcanvas-bar .uk-radio:checked:focus,.uk-overlay-primary .uk-checkbox:checked:focus,.uk-overlay-primary .uk-checkbox:indeterminate:focus,.uk-overlay-primary .uk-radio:checked:focus,.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:checked:focus,.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate:focus,.uk-section-primary:not(.uk-preserve-color) .uk-radio:checked:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:checked:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-radio:checked:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:checked:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-radio:checked:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:checked:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-radio:checked:focus{background-color:#e6e6e6}.uk-card-primary.uk-card-body .uk-radio:checked,.uk-card-primary>:not([class*=uk-card-media]) .uk-radio:checked,.uk-card-secondary.uk-card-body .uk-radio:checked,.uk-card-secondary>:not([class*=uk-card-media]) .uk-radio:checked,.uk-light .uk-radio:checked,.uk-offcanvas-bar .uk-radio:checked,.uk-overlay-primary .uk-radio:checked,.uk-section-primary:not(.uk-preserve-color) .uk-radio:checked,.uk-section-secondary:not(.uk-preserve-color) .uk-radio:checked,.uk-tile-primary:not(.uk-preserve-color) .uk-radio:checked,.uk-tile-secondary:not(.uk-preserve-color) .uk-radio:checked{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22%23666%22%20cx%3D%228%22%20cy%3D%228%22%20r%3D%222%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-card-primary.uk-card-body .uk-checkbox:checked,.uk-card-primary>:not([class*=uk-card-media]) .uk-checkbox:checked,.uk-card-secondary.uk-card-body .uk-checkbox:checked,.uk-card-secondary>:not([class*=uk-card-media]) .uk-checkbox:checked,.uk-light .uk-checkbox:checked,.uk-offcanvas-bar .uk-checkbox:checked,.uk-overlay-primary .uk-checkbox:checked,.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:checked,.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:checked,.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:checked,.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:checked{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2211%22%20viewBox%3D%220%200%2014%2011%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23666%22%20points%3D%2212%201%205%207.5%202%205%201%205.5%205%2010%2013%201.5%22%20%2F%3E%0A%3C%2Fsvg%3E%0A")}.uk-card-primary.uk-card-body .uk-checkbox:indeterminate,.uk-card-primary>:not([class*=uk-card-media]) .uk-checkbox:indeterminate,.uk-card-secondary.uk-card-body .uk-checkbox:indeterminate,.uk-card-secondary>:not([class*=uk-card-media]) .uk-checkbox:indeterminate,.uk-light .uk-checkbox:indeterminate,.uk-offcanvas-bar .uk-checkbox:indeterminate,.uk-overlay-primary .uk-checkbox:indeterminate,.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate,.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate,.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate,.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23666%22%20x%3D%223%22%20y%3D%228%22%20width%3D%2210%22%20height%3D%221%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-card-primary.uk-card-body .uk-form-label,.uk-card-primary>:not([class*=uk-card-media]) .uk-form-label,.uk-card-secondary.uk-card-body .uk-form-label,.uk-card-secondary>:not([class*=uk-card-media]) .uk-form-label,.uk-light .uk-form-label,.uk-offcanvas-bar .uk-form-label,.uk-overlay-primary .uk-form-label,.uk-section-primary:not(.uk-preserve-color) .uk-form-label,.uk-section-secondary:not(.uk-preserve-color) .uk-form-label,.uk-tile-primary:not(.uk-preserve-color) .uk-form-label,.uk-tile-secondary:not(.uk-preserve-color) .uk-form-label{color:#fff}.uk-card-primary.uk-card-body .uk-form-icon,.uk-card-primary>:not([class*=uk-card-media]) .uk-form-icon,.uk-card-secondary.uk-card-body .uk-form-icon,.uk-card-secondary>:not([class*=uk-card-media]) .uk-form-icon,.uk-light .uk-form-icon,.uk-offcanvas-bar .uk-form-icon,.uk-overlay-primary .uk-form-icon,.uk-section-primary:not(.uk-preserve-color) .uk-form-icon,.uk-section-secondary:not(.uk-preserve-color) .uk-form-icon,.uk-tile-primary:not(.uk-preserve-color) .uk-form-icon,.uk-tile-secondary:not(.uk-preserve-color) .uk-form-icon{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-form-icon:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-form-icon:hover,.uk-card-secondary.uk-card-body .uk-form-icon:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-form-icon:hover,.uk-light .uk-form-icon:hover,.uk-offcanvas-bar .uk-form-icon:hover,.uk-overlay-primary .uk-form-icon:hover,.uk-section-primary:not(.uk-preserve-color) .uk-form-icon:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-form-icon:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-form-icon:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-form-icon:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-button-default,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-default,.uk-card-secondary.uk-card-body .uk-button-default,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-default,.uk-light .uk-button-default,.uk-offcanvas-bar .uk-button-default,.uk-overlay-primary .uk-button-default,.uk-section-primary:not(.uk-preserve-color) .uk-button-default,.uk-section-secondary:not(.uk-preserve-color) .uk-button-default,.uk-tile-primary:not(.uk-preserve-color) .uk-button-default,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default{background-color:transparent;color:#fff;border-color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-button-default:focus,.uk-card-primary.uk-card-body .uk-button-default:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-default:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-default:hover,.uk-card-secondary.uk-card-body .uk-button-default:focus,.uk-card-secondary.uk-card-body .uk-button-default:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-default:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-default:hover,.uk-light .uk-button-default:focus,.uk-light .uk-button-default:hover,.uk-offcanvas-bar .uk-button-default:focus,.uk-offcanvas-bar .uk-button-default:hover,.uk-overlay-primary .uk-button-default:focus,.uk-overlay-primary .uk-button-default:hover,.uk-section-primary:not(.uk-preserve-color) .uk-button-default:focus,.uk-section-primary:not(.uk-preserve-color) .uk-button-default:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-button-default:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-button-default:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-button-default:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-button-default:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default:hover{background-color:transparent;color:#fff;border-color:#fff}.uk-card-primary.uk-card-body .uk-button-default.uk-active,.uk-card-primary.uk-card-body .uk-button-default:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-default.uk-active,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-default:active,.uk-card-secondary.uk-card-body .uk-button-default.uk-active,.uk-card-secondary.uk-card-body .uk-button-default:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-default.uk-active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-default:active,.uk-light .uk-button-default.uk-active,.uk-light .uk-button-default:active,.uk-offcanvas-bar .uk-button-default.uk-active,.uk-offcanvas-bar .uk-button-default:active,.uk-overlay-primary .uk-button-default.uk-active,.uk-overlay-primary .uk-button-default:active,.uk-section-primary:not(.uk-preserve-color) .uk-button-default.uk-active,.uk-section-primary:not(.uk-preserve-color) .uk-button-default:active,.uk-section-secondary:not(.uk-preserve-color) .uk-button-default.uk-active,.uk-section-secondary:not(.uk-preserve-color) .uk-button-default:active,.uk-tile-primary:not(.uk-preserve-color) .uk-button-default.uk-active,.uk-tile-primary:not(.uk-preserve-color) .uk-button-default:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default.uk-active,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default:active{background-color:transparent;color:#fff;border-color:#fff}.uk-card-primary.uk-card-body .uk-button-primary,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-primary,.uk-card-secondary.uk-card-body .uk-button-primary,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-primary,.uk-light .uk-button-primary,.uk-offcanvas-bar .uk-button-primary,.uk-overlay-primary .uk-button-primary,.uk-section-primary:not(.uk-preserve-color) .uk-button-primary,.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary,.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary{background-color:#fff;color:#666}.uk-card-primary.uk-card-body .uk-button-primary:focus,.uk-card-primary.uk-card-body .uk-button-primary:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-primary:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-primary:hover,.uk-card-secondary.uk-card-body .uk-button-primary:focus,.uk-card-secondary.uk-card-body .uk-button-primary:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-primary:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-primary:hover,.uk-light .uk-button-primary:focus,.uk-light .uk-button-primary:hover,.uk-offcanvas-bar .uk-button-primary:focus,.uk-offcanvas-bar .uk-button-primary:hover,.uk-overlay-primary .uk-button-primary:focus,.uk-overlay-primary .uk-button-primary:hover,.uk-section-primary:not(.uk-preserve-color) .uk-button-primary:focus,.uk-section-primary:not(.uk-preserve-color) .uk-button-primary:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary:hover{background-color:#f2f2f2;color:#666}.uk-card-primary.uk-card-body .uk-button-primary.uk-active,.uk-card-primary.uk-card-body .uk-button-primary:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-primary.uk-active,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-primary:active,.uk-card-secondary.uk-card-body .uk-button-primary.uk-active,.uk-card-secondary.uk-card-body .uk-button-primary:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-primary.uk-active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-primary:active,.uk-light .uk-button-primary.uk-active,.uk-light .uk-button-primary:active,.uk-offcanvas-bar .uk-button-primary.uk-active,.uk-offcanvas-bar .uk-button-primary:active,.uk-overlay-primary .uk-button-primary.uk-active,.uk-overlay-primary .uk-button-primary:active,.uk-section-primary:not(.uk-preserve-color) .uk-button-primary.uk-active,.uk-section-primary:not(.uk-preserve-color) .uk-button-primary:active,.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary.uk-active,.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary:active,.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary.uk-active,.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary.uk-active,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary:active{background-color:#e6e6e6;color:#666}.uk-card-primary.uk-card-body .uk-button-secondary,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-secondary,.uk-card-secondary.uk-card-body .uk-button-secondary,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-secondary,.uk-light .uk-button-secondary,.uk-offcanvas-bar .uk-button-secondary,.uk-overlay-primary .uk-button-secondary,.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary,.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary,.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary{background-color:#fff;color:#666}.uk-card-primary.uk-card-body .uk-button-secondary:focus,.uk-card-primary.uk-card-body .uk-button-secondary:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-secondary:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-secondary:hover,.uk-card-secondary.uk-card-body .uk-button-secondary:focus,.uk-card-secondary.uk-card-body .uk-button-secondary:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-secondary:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-secondary:hover,.uk-light .uk-button-secondary:focus,.uk-light .uk-button-secondary:hover,.uk-offcanvas-bar .uk-button-secondary:focus,.uk-offcanvas-bar .uk-button-secondary:hover,.uk-overlay-primary .uk-button-secondary:focus,.uk-overlay-primary .uk-button-secondary:hover,.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary:focus,.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary:hover{background-color:#f2f2f2;color:#666}.uk-card-primary.uk-card-body .uk-button-secondary.uk-active,.uk-card-primary.uk-card-body .uk-button-secondary:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-secondary.uk-active,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-secondary:active,.uk-card-secondary.uk-card-body .uk-button-secondary.uk-active,.uk-card-secondary.uk-card-body .uk-button-secondary:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-secondary.uk-active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-secondary:active,.uk-light .uk-button-secondary.uk-active,.uk-light .uk-button-secondary:active,.uk-offcanvas-bar .uk-button-secondary.uk-active,.uk-offcanvas-bar .uk-button-secondary:active,.uk-overlay-primary .uk-button-secondary.uk-active,.uk-overlay-primary .uk-button-secondary:active,.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary.uk-active,.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary:active,.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary.uk-active,.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary:active,.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary.uk-active,.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary.uk-active,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary:active{background-color:#e6e6e6;color:#666}.uk-card-primary.uk-card-body .uk-button-text,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-text,.uk-card-secondary.uk-card-body .uk-button-text,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-text,.uk-light .uk-button-text,.uk-offcanvas-bar .uk-button-text,.uk-overlay-primary .uk-button-text,.uk-section-primary:not(.uk-preserve-color) .uk-button-text,.uk-section-secondary:not(.uk-preserve-color) .uk-button-text,.uk-tile-primary:not(.uk-preserve-color) .uk-button-text,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text{color:#fff}.uk-card-primary.uk-card-body .uk-button-text::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-text::before,.uk-card-secondary.uk-card-body .uk-button-text::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-text::before,.uk-light .uk-button-text::before,.uk-offcanvas-bar .uk-button-text::before,.uk-overlay-primary .uk-button-text::before,.uk-section-primary:not(.uk-preserve-color) .uk-button-text::before,.uk-section-secondary:not(.uk-preserve-color) .uk-button-text::before,.uk-tile-primary:not(.uk-preserve-color) .uk-button-text::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text::before{border-bottom-color:#fff}.uk-card-primary.uk-card-body .uk-button-text:focus,.uk-card-primary.uk-card-body .uk-button-text:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-text:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-text:hover,.uk-card-secondary.uk-card-body .uk-button-text:focus,.uk-card-secondary.uk-card-body .uk-button-text:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-text:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-text:hover,.uk-light .uk-button-text:focus,.uk-light .uk-button-text:hover,.uk-offcanvas-bar .uk-button-text:focus,.uk-offcanvas-bar .uk-button-text:hover,.uk-overlay-primary .uk-button-text:focus,.uk-overlay-primary .uk-button-text:hover,.uk-section-primary:not(.uk-preserve-color) .uk-button-text:focus,.uk-section-primary:not(.uk-preserve-color) .uk-button-text:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-button-text:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-button-text:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-button-text:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-button-text:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text:hover{color:#fff}.uk-card-primary.uk-card-body .uk-button-text:disabled,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-text:disabled,.uk-card-secondary.uk-card-body .uk-button-text:disabled,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-text:disabled,.uk-light .uk-button-text:disabled,.uk-offcanvas-bar .uk-button-text:disabled,.uk-overlay-primary .uk-button-text:disabled,.uk-section-primary:not(.uk-preserve-color) .uk-button-text:disabled,.uk-section-secondary:not(.uk-preserve-color) .uk-button-text:disabled,.uk-tile-primary:not(.uk-preserve-color) .uk-button-text:disabled,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text:disabled{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-button-link,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-link,.uk-card-secondary.uk-card-body .uk-button-link,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-link,.uk-light .uk-button-link,.uk-offcanvas-bar .uk-button-link,.uk-overlay-primary .uk-button-link,.uk-section-primary:not(.uk-preserve-color) .uk-button-link,.uk-section-secondary:not(.uk-preserve-color) .uk-button-link,.uk-tile-primary:not(.uk-preserve-color) .uk-button-link,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-link{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-button-link:focus,.uk-card-primary.uk-card-body .uk-button-link:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-link:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-button-link:hover,.uk-card-secondary.uk-card-body .uk-button-link:focus,.uk-card-secondary.uk-card-body .uk-button-link:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-link:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-button-link:hover,.uk-light .uk-button-link:focus,.uk-light .uk-button-link:hover,.uk-offcanvas-bar .uk-button-link:focus,.uk-offcanvas-bar .uk-button-link:hover,.uk-overlay-primary .uk-button-link:focus,.uk-overlay-primary .uk-button-link:hover,.uk-section-primary:not(.uk-preserve-color) .uk-button-link:focus,.uk-section-primary:not(.uk-preserve-color) .uk-button-link:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-button-link:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-button-link:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-button-link:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-button-link:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-link:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-button-link:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-grid-divider>:not(.uk-first-column)::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-grid-divider>:not(.uk-first-column)::before,.uk-card-secondary.uk-card-body .uk-grid-divider>:not(.uk-first-column)::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-grid-divider>:not(.uk-first-column)::before,.uk-light .uk-grid-divider>:not(.uk-first-column)::before,.uk-offcanvas-bar .uk-grid-divider>:not(.uk-first-column)::before,.uk-overlay-primary .uk-grid-divider>:not(.uk-first-column)::before,.uk-section-primary:not(.uk-preserve-color) .uk-grid-divider>:not(.uk-first-column)::before,.uk-section-secondary:not(.uk-preserve-color) .uk-grid-divider>:not(.uk-first-column)::before,.uk-tile-primary:not(.uk-preserve-color) .uk-grid-divider>:not(.uk-first-column)::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-grid-divider>:not(.uk-first-column)::before{border-left-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-card-secondary.uk-card-body .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-light .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-offcanvas-bar .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-overlay-primary .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-section-primary:not(.uk-preserve-color) .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-section-secondary:not(.uk-preserve-color) .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-tile-primary:not(.uk-preserve-color) .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-grid-divider.uk-grid-stack>.uk-grid-margin::before{border-top-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-close,.uk-card-primary>:not([class*=uk-card-media]) .uk-close,.uk-card-secondary.uk-card-body .uk-close,.uk-card-secondary>:not([class*=uk-card-media]) .uk-close,.uk-light .uk-close,.uk-offcanvas-bar .uk-close,.uk-overlay-primary .uk-close,.uk-section-primary:not(.uk-preserve-color) .uk-close,.uk-section-secondary:not(.uk-preserve-color) .uk-close,.uk-tile-primary:not(.uk-preserve-color) .uk-close,.uk-tile-secondary:not(.uk-preserve-color) .uk-close{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-close:focus,.uk-card-primary.uk-card-body .uk-close:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-close:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-close:hover,.uk-card-secondary.uk-card-body .uk-close:focus,.uk-card-secondary.uk-card-body .uk-close:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-close:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-close:hover,.uk-light .uk-close:focus,.uk-light .uk-close:hover,.uk-offcanvas-bar .uk-close:focus,.uk-offcanvas-bar .uk-close:hover,.uk-overlay-primary .uk-close:focus,.uk-overlay-primary .uk-close:hover,.uk-section-primary:not(.uk-preserve-color) .uk-close:focus,.uk-section-primary:not(.uk-preserve-color) .uk-close:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-close:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-close:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-close:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-close:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-close:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-close:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-totop,.uk-card-primary>:not([class*=uk-card-media]) .uk-totop,.uk-card-secondary.uk-card-body .uk-totop,.uk-card-secondary>:not([class*=uk-card-media]) .uk-totop,.uk-light .uk-totop,.uk-offcanvas-bar .uk-totop,.uk-overlay-primary .uk-totop,.uk-section-primary:not(.uk-preserve-color) .uk-totop,.uk-section-secondary:not(.uk-preserve-color) .uk-totop,.uk-tile-primary:not(.uk-preserve-color) .uk-totop,.uk-tile-secondary:not(.uk-preserve-color) .uk-totop{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-totop:focus,.uk-card-primary.uk-card-body .uk-totop:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-totop:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-totop:hover,.uk-card-secondary.uk-card-body .uk-totop:focus,.uk-card-secondary.uk-card-body .uk-totop:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-totop:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-totop:hover,.uk-light .uk-totop:focus,.uk-light .uk-totop:hover,.uk-offcanvas-bar .uk-totop:focus,.uk-offcanvas-bar .uk-totop:hover,.uk-overlay-primary .uk-totop:focus,.uk-overlay-primary .uk-totop:hover,.uk-section-primary:not(.uk-preserve-color) .uk-totop:focus,.uk-section-primary:not(.uk-preserve-color) .uk-totop:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-totop:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-totop:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-totop:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-totop:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-totop:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-totop:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-totop:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-totop:active,.uk-card-secondary.uk-card-body .uk-totop:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-totop:active,.uk-light .uk-totop:active,.uk-offcanvas-bar .uk-totop:active,.uk-overlay-primary .uk-totop:active,.uk-section-primary:not(.uk-preserve-color) .uk-totop:active,.uk-section-secondary:not(.uk-preserve-color) .uk-totop:active,.uk-tile-primary:not(.uk-preserve-color) .uk-totop:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-totop:active{color:#fff}.uk-card-primary.uk-card-body .uk-marker,.uk-card-primary>:not([class*=uk-card-media]) .uk-marker,.uk-card-secondary.uk-card-body .uk-marker,.uk-card-secondary>:not([class*=uk-card-media]) .uk-marker,.uk-light .uk-marker,.uk-offcanvas-bar .uk-marker,.uk-overlay-primary .uk-marker,.uk-section-primary:not(.uk-preserve-color) .uk-marker,.uk-section-secondary:not(.uk-preserve-color) .uk-marker,.uk-tile-primary:not(.uk-preserve-color) .uk-marker,.uk-tile-secondary:not(.uk-preserve-color) .uk-marker{background:#f8f8f8;color:#666}.uk-card-primary.uk-card-body .uk-marker:focus,.uk-card-primary.uk-card-body .uk-marker:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-marker:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-marker:hover,.uk-card-secondary.uk-card-body .uk-marker:focus,.uk-card-secondary.uk-card-body .uk-marker:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-marker:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-marker:hover,.uk-light .uk-marker:focus,.uk-light .uk-marker:hover,.uk-offcanvas-bar .uk-marker:focus,.uk-offcanvas-bar .uk-marker:hover,.uk-overlay-primary .uk-marker:focus,.uk-overlay-primary .uk-marker:hover,.uk-section-primary:not(.uk-preserve-color) .uk-marker:focus,.uk-section-primary:not(.uk-preserve-color) .uk-marker:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-marker:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-marker:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-marker:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-marker:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-marker:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-marker:hover{color:#666}.uk-card-primary.uk-card-body .uk-badge,.uk-card-primary>:not([class*=uk-card-media]) .uk-badge,.uk-card-secondary.uk-card-body .uk-badge,.uk-card-secondary>:not([class*=uk-card-media]) .uk-badge,.uk-light .uk-badge,.uk-offcanvas-bar .uk-badge,.uk-overlay-primary .uk-badge,.uk-section-primary:not(.uk-preserve-color) .uk-badge,.uk-section-secondary:not(.uk-preserve-color) .uk-badge,.uk-tile-primary:not(.uk-preserve-color) .uk-badge,.uk-tile-secondary:not(.uk-preserve-color) .uk-badge{background-color:#fff;color:#666}.uk-card-primary.uk-card-body .uk-badge:focus,.uk-card-primary.uk-card-body .uk-badge:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-badge:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-badge:hover,.uk-card-secondary.uk-card-body .uk-badge:focus,.uk-card-secondary.uk-card-body .uk-badge:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-badge:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-badge:hover,.uk-light .uk-badge:focus,.uk-light .uk-badge:hover,.uk-offcanvas-bar .uk-badge:focus,.uk-offcanvas-bar .uk-badge:hover,.uk-overlay-primary .uk-badge:focus,.uk-overlay-primary .uk-badge:hover,.uk-section-primary:not(.uk-preserve-color) .uk-badge:focus,.uk-section-primary:not(.uk-preserve-color) .uk-badge:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-badge:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-badge:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-badge:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-badge:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-badge:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-badge:hover{color:#666}.uk-card-primary.uk-card-body .uk-label,.uk-card-primary>:not([class*=uk-card-media]) .uk-label,.uk-card-secondary.uk-card-body .uk-label,.uk-card-secondary>:not([class*=uk-card-media]) .uk-label,.uk-light .uk-label,.uk-offcanvas-bar .uk-label,.uk-overlay-primary .uk-label,.uk-section-primary:not(.uk-preserve-color) .uk-label,.uk-section-secondary:not(.uk-preserve-color) .uk-label,.uk-tile-primary:not(.uk-preserve-color) .uk-label,.uk-tile-secondary:not(.uk-preserve-color) .uk-label{background-color:#fff;color:#666}.uk-card-primary.uk-card-body .uk-article-meta,.uk-card-primary>:not([class*=uk-card-media]) .uk-article-meta,.uk-card-secondary.uk-card-body .uk-article-meta,.uk-card-secondary>:not([class*=uk-card-media]) .uk-article-meta,.uk-light .uk-article-meta,.uk-offcanvas-bar .uk-article-meta,.uk-overlay-primary .uk-article-meta,.uk-section-primary:not(.uk-preserve-color) .uk-article-meta,.uk-section-secondary:not(.uk-preserve-color) .uk-article-meta,.uk-tile-primary:not(.uk-preserve-color) .uk-article-meta,.uk-tile-secondary:not(.uk-preserve-color) .uk-article-meta{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-search-input,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-input,.uk-card-secondary.uk-card-body .uk-search-input,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-input,.uk-light .uk-search-input,.uk-offcanvas-bar .uk-search-input,.uk-overlay-primary .uk-search-input,.uk-section-primary:not(.uk-preserve-color) .uk-search-input,.uk-section-secondary:not(.uk-preserve-color) .uk-search-input,.uk-tile-primary:not(.uk-preserve-color) .uk-search-input,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-input{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-search-input:-ms-input-placeholder,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-input:-ms-input-placeholder,.uk-card-secondary.uk-card-body .uk-search-input:-ms-input-placeholder,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-input:-ms-input-placeholder,.uk-light .uk-search-input:-ms-input-placeholder,.uk-offcanvas-bar .uk-search-input:-ms-input-placeholder,.uk-overlay-primary .uk-search-input:-ms-input-placeholder,.uk-section-primary:not(.uk-preserve-color) .uk-search-input:-ms-input-placeholder,.uk-section-secondary:not(.uk-preserve-color) .uk-search-input:-ms-input-placeholder,.uk-tile-primary:not(.uk-preserve-color) .uk-search-input:-ms-input-placeholder,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-input:-ms-input-placeholder{color:rgba(255,255,255,.5)!important}.uk-card-primary.uk-card-body .uk-search-input::placeholder,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-input::placeholder,.uk-card-secondary.uk-card-body .uk-search-input::placeholder,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-input::placeholder,.uk-light .uk-search-input::placeholder,.uk-offcanvas-bar .uk-search-input::placeholder,.uk-overlay-primary .uk-search-input::placeholder,.uk-section-primary:not(.uk-preserve-color) .uk-search-input::placeholder,.uk-section-secondary:not(.uk-preserve-color) .uk-search-input::placeholder,.uk-tile-primary:not(.uk-preserve-color) .uk-search-input::placeholder,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-input::placeholder{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-search .uk-search-icon,.uk-card-primary>:not([class*=uk-card-media]) .uk-search .uk-search-icon,.uk-card-secondary.uk-card-body .uk-search .uk-search-icon,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search .uk-search-icon,.uk-light .uk-search .uk-search-icon,.uk-offcanvas-bar .uk-search .uk-search-icon,.uk-overlay-primary .uk-search .uk-search-icon,.uk-section-primary:not(.uk-preserve-color) .uk-search .uk-search-icon,.uk-section-secondary:not(.uk-preserve-color) .uk-search .uk-search-icon,.uk-tile-primary:not(.uk-preserve-color) .uk-search .uk-search-icon,.uk-tile-secondary:not(.uk-preserve-color) .uk-search .uk-search-icon{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-search .uk-search-icon:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-search .uk-search-icon:hover,.uk-card-secondary.uk-card-body .uk-search .uk-search-icon:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search .uk-search-icon:hover,.uk-light .uk-search .uk-search-icon:hover,.uk-offcanvas-bar .uk-search .uk-search-icon:hover,.uk-overlay-primary .uk-search .uk-search-icon:hover,.uk-section-primary:not(.uk-preserve-color) .uk-search .uk-search-icon:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-search .uk-search-icon:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-search .uk-search-icon:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-search .uk-search-icon:hover{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-search-default .uk-search-input,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-default .uk-search-input,.uk-card-secondary.uk-card-body .uk-search-default .uk-search-input,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-default .uk-search-input,.uk-light .uk-search-default .uk-search-input,.uk-offcanvas-bar .uk-search-default .uk-search-input,.uk-overlay-primary .uk-search-default .uk-search-input,.uk-section-primary:not(.uk-preserve-color) .uk-search-default .uk-search-input,.uk-section-secondary:not(.uk-preserve-color) .uk-search-default .uk-search-input,.uk-tile-primary:not(.uk-preserve-color) .uk-search-default .uk-search-input,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-default .uk-search-input{background-color:transparent;border-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-search-default .uk-search-input:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-default .uk-search-input:focus,.uk-card-secondary.uk-card-body .uk-search-default .uk-search-input:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-default .uk-search-input:focus,.uk-light .uk-search-default .uk-search-input:focus,.uk-offcanvas-bar .uk-search-default .uk-search-input:focus,.uk-overlay-primary .uk-search-default .uk-search-input:focus,.uk-section-primary:not(.uk-preserve-color) .uk-search-default .uk-search-input:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-search-default .uk-search-input:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-search-default .uk-search-input:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-default .uk-search-input:focus{background-color:transparent}.uk-card-primary.uk-card-body .uk-search-navbar .uk-search-input,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-navbar .uk-search-input,.uk-card-secondary.uk-card-body .uk-search-navbar .uk-search-input,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-navbar .uk-search-input,.uk-light .uk-search-navbar .uk-search-input,.uk-offcanvas-bar .uk-search-navbar .uk-search-input,.uk-overlay-primary .uk-search-navbar .uk-search-input,.uk-section-primary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input,.uk-section-secondary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input,.uk-tile-primary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input{background-color:transparent}.uk-card-primary.uk-card-body .uk-search-large .uk-search-input,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-large .uk-search-input,.uk-card-secondary.uk-card-body .uk-search-large .uk-search-input,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-large .uk-search-input,.uk-light .uk-search-large .uk-search-input,.uk-offcanvas-bar .uk-search-large .uk-search-input,.uk-overlay-primary .uk-search-large .uk-search-input,.uk-section-primary:not(.uk-preserve-color) .uk-search-large .uk-search-input,.uk-section-secondary:not(.uk-preserve-color) .uk-search-large .uk-search-input,.uk-tile-primary:not(.uk-preserve-color) .uk-search-large .uk-search-input,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-large .uk-search-input{background-color:transparent}.uk-card-primary.uk-card-body .uk-search-toggle,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-toggle,.uk-card-secondary.uk-card-body .uk-search-toggle,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-toggle,.uk-light .uk-search-toggle,.uk-offcanvas-bar .uk-search-toggle,.uk-overlay-primary .uk-search-toggle,.uk-section-primary:not(.uk-preserve-color) .uk-search-toggle,.uk-section-secondary:not(.uk-preserve-color) .uk-search-toggle,.uk-tile-primary:not(.uk-preserve-color) .uk-search-toggle,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-toggle{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-search-toggle:focus,.uk-card-primary.uk-card-body .uk-search-toggle:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-toggle:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-search-toggle:hover,.uk-card-secondary.uk-card-body .uk-search-toggle:focus,.uk-card-secondary.uk-card-body .uk-search-toggle:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-toggle:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-search-toggle:hover,.uk-light .uk-search-toggle:focus,.uk-light .uk-search-toggle:hover,.uk-offcanvas-bar .uk-search-toggle:focus,.uk-offcanvas-bar .uk-search-toggle:hover,.uk-overlay-primary .uk-search-toggle:focus,.uk-overlay-primary .uk-search-toggle:hover,.uk-section-primary:not(.uk-preserve-color) .uk-search-toggle:focus,.uk-section-primary:not(.uk-preserve-color) .uk-search-toggle:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-search-toggle:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-search-toggle:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-search-toggle:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-search-toggle:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-toggle:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-search-toggle:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-nav-parent-icon>.uk-parent>a::after,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-parent-icon>.uk-parent>a::after,.uk-card-secondary.uk-card-body .uk-nav-parent-icon>.uk-parent>a::after,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-parent-icon>.uk-parent>a::after,.uk-light .uk-nav-parent-icon>.uk-parent>a::after,.uk-offcanvas-bar .uk-nav-parent-icon>.uk-parent>a::after,.uk-overlay-primary .uk-nav-parent-icon>.uk-parent>a::after,.uk-section-primary:not(.uk-preserve-color) .uk-nav-parent-icon>.uk-parent>a::after,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-parent-icon>.uk-parent>a::after,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-parent-icon>.uk-parent>a::after,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-parent-icon>.uk-parent>a::after{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2214%22%20viewBox%3D%220%200%2014%2014%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolyline%20fill%3D%22none%22%20stroke%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20stroke-width%3D%221.1%22%20points%3D%2210%201%204%207%2010%2013%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-card-primary.uk-card-body .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-card-secondary.uk-card-body .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-light .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-offcanvas-bar .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-overlay-primary .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-section-primary:not(.uk-preserve-color) .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-parent-icon>.uk-parent.uk-open>a::after,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-parent-icon>.uk-parent.uk-open>a::after{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2214%22%20viewBox%3D%220%200%2014%2014%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolyline%20fill%3D%22none%22%20stroke%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20stroke-width%3D%221.1%22%20points%3D%221%204%207%2010%2013%204%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-card-primary.uk-card-body .uk-nav-default>li>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default>li>a,.uk-card-secondary.uk-card-body .uk-nav-default>li>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default>li>a,.uk-light .uk-nav-default>li>a,.uk-offcanvas-bar .uk-nav-default>li>a,.uk-overlay-primary .uk-nav-default>li>a,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default>li>a,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default>li>a,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default>li>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default>li>a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-nav-default>li>a:focus,.uk-card-primary.uk-card-body .uk-nav-default>li>a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default>li>a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default>li>a:hover,.uk-card-secondary.uk-card-body .uk-nav-default>li>a:focus,.uk-card-secondary.uk-card-body .uk-nav-default>li>a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default>li>a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default>li>a:hover,.uk-light .uk-nav-default>li>a:focus,.uk-light .uk-nav-default>li>a:hover,.uk-offcanvas-bar .uk-nav-default>li>a:focus,.uk-offcanvas-bar .uk-nav-default>li>a:hover,.uk-overlay-primary .uk-nav-default>li>a:focus,.uk-overlay-primary .uk-nav-default>li>a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default>li>a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default>li>a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default>li>a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default>li>a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default>li>a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default>li>a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default>li>a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default>li>a:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-nav-default>li.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default>li.uk-active>a,.uk-card-secondary.uk-card-body .uk-nav-default>li.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default>li.uk-active>a,.uk-light .uk-nav-default>li.uk-active>a,.uk-offcanvas-bar .uk-nav-default>li.uk-active>a,.uk-overlay-primary .uk-nav-default>li.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default>li.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default>li.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default>li.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default>li.uk-active>a{color:#fff}.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-header,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-header,.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-header,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-header,.uk-light .uk-nav-default .uk-nav-header,.uk-offcanvas-bar .uk-nav-default .uk-nav-header,.uk-overlay-primary .uk-nav-default .uk-nav-header,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-header,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-header,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-header,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-header{color:#fff}.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-divider,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-divider,.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-divider,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-divider,.uk-light .uk-nav-default .uk-nav-divider,.uk-offcanvas-bar .uk-nav-default .uk-nav-divider,.uk-overlay-primary .uk-nav-default .uk-nav-divider,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-divider,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-divider,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-divider,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-divider{border-top-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-sub a,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-sub a,.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-sub a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-sub a,.uk-light .uk-nav-default .uk-nav-sub a,.uk-offcanvas-bar .uk-nav-default .uk-nav-sub a,.uk-overlay-primary .uk-nav-default .uk-nav-sub a,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-sub a:focus,.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-sub a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-sub a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-sub a:hover,.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-sub a:focus,.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-sub a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-sub a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-sub a:hover,.uk-light .uk-nav-default .uk-nav-sub a:focus,.uk-light .uk-nav-default .uk-nav-sub a:hover,.uk-offcanvas-bar .uk-nav-default .uk-nav-sub a:focus,.uk-offcanvas-bar .uk-nav-default .uk-nav-sub a:hover,.uk-overlay-primary .uk-nav-default .uk-nav-sub a:focus,.uk-overlay-primary .uk-nav-default .uk-nav-sub a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-light .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-offcanvas-bar .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-overlay-primary .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub li.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub li.uk-active>a{color:#fff}.uk-card-primary.uk-card-body .uk-nav-primary>li>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary>li>a,.uk-card-secondary.uk-card-body .uk-nav-primary>li>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary>li>a,.uk-light .uk-nav-primary>li>a,.uk-offcanvas-bar .uk-nav-primary>li>a,.uk-overlay-primary .uk-nav-primary>li>a,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary>li>a,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary>li>a,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary>li>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary>li>a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-nav-primary>li>a:focus,.uk-card-primary.uk-card-body .uk-nav-primary>li>a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary>li>a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary>li>a:hover,.uk-card-secondary.uk-card-body .uk-nav-primary>li>a:focus,.uk-card-secondary.uk-card-body .uk-nav-primary>li>a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary>li>a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary>li>a:hover,.uk-light .uk-nav-primary>li>a:focus,.uk-light .uk-nav-primary>li>a:hover,.uk-offcanvas-bar .uk-nav-primary>li>a:focus,.uk-offcanvas-bar .uk-nav-primary>li>a:hover,.uk-overlay-primary .uk-nav-primary>li>a:focus,.uk-overlay-primary .uk-nav-primary>li>a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary>li>a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary>li>a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary>li>a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary>li>a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary>li>a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary>li>a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary>li>a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary>li>a:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-nav-primary>li.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary>li.uk-active>a,.uk-card-secondary.uk-card-body .uk-nav-primary>li.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary>li.uk-active>a,.uk-light .uk-nav-primary>li.uk-active>a,.uk-offcanvas-bar .uk-nav-primary>li.uk-active>a,.uk-overlay-primary .uk-nav-primary>li.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary>li.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary>li.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary>li.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary>li.uk-active>a{color:#fff}.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-header,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-header,.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-header,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-header,.uk-light .uk-nav-primary .uk-nav-header,.uk-offcanvas-bar .uk-nav-primary .uk-nav-header,.uk-overlay-primary .uk-nav-primary .uk-nav-header,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-header,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-header,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-header,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-header{color:#fff}.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-divider,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-divider,.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-divider,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-divider,.uk-light .uk-nav-primary .uk-nav-divider,.uk-offcanvas-bar .uk-nav-primary .uk-nav-divider,.uk-overlay-primary .uk-nav-primary .uk-nav-divider,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-divider,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-divider,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-divider,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-divider{border-top-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-sub a,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-sub a,.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-sub a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-sub a,.uk-light .uk-nav-primary .uk-nav-sub a,.uk-offcanvas-bar .uk-nav-primary .uk-nav-sub a,.uk-overlay-primary .uk-nav-primary .uk-nav-sub a,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-sub a:focus,.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-sub a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-sub a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-sub a:hover,.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-sub a:focus,.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-sub a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-sub a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-sub a:hover,.uk-light .uk-nav-primary .uk-nav-sub a:focus,.uk-light .uk-nav-primary .uk-nav-sub a:hover,.uk-offcanvas-bar .uk-nav-primary .uk-nav-sub a:focus,.uk-offcanvas-bar .uk-nav-primary .uk-nav-sub a:hover,.uk-overlay-primary .uk-nav-primary .uk-nav-sub a:focus,.uk-overlay-primary .uk-nav-primary .uk-nav-sub a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-light .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-offcanvas-bar .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-overlay-primary .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub li.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub li.uk-active>a{color:#fff}.uk-card-primary.uk-card-body .uk-navbar-nav>li>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-nav>li>a,.uk-card-secondary.uk-card-body .uk-navbar-nav>li>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-nav>li>a,.uk-light .uk-navbar-nav>li>a,.uk-offcanvas-bar .uk-navbar-nav>li>a,.uk-overlay-primary .uk-navbar-nav>li>a,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav>li>a,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav>li>a,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav>li>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav>li>a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-navbar-nav>li:hover>a,.uk-card-primary.uk-card-body .uk-navbar-nav>li>a.uk-open,.uk-card-primary.uk-card-body .uk-navbar-nav>li>a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-nav>li:hover>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-nav>li>a.uk-open,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-nav>li>a:focus,.uk-card-secondary.uk-card-body .uk-navbar-nav>li:hover>a,.uk-card-secondary.uk-card-body .uk-navbar-nav>li>a.uk-open,.uk-card-secondary.uk-card-body .uk-navbar-nav>li>a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-nav>li:hover>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-nav>li>a.uk-open,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-nav>li>a:focus,.uk-light .uk-navbar-nav>li:hover>a,.uk-light .uk-navbar-nav>li>a.uk-open,.uk-light .uk-navbar-nav>li>a:focus,.uk-offcanvas-bar .uk-navbar-nav>li:hover>a,.uk-offcanvas-bar .uk-navbar-nav>li>a.uk-open,.uk-offcanvas-bar .uk-navbar-nav>li>a:focus,.uk-overlay-primary .uk-navbar-nav>li:hover>a,.uk-overlay-primary .uk-navbar-nav>li>a.uk-open,.uk-overlay-primary .uk-navbar-nav>li>a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav>li:hover>a,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav>li>a.uk-open,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav>li>a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav>li:hover>a,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav>li>a.uk-open,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav>li>a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav>li:hover>a,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav>li>a.uk-open,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav>li>a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav>li:hover>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav>li>a.uk-open,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav>li>a:focus{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-navbar-nav>li>a:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-nav>li>a:active,.uk-card-secondary.uk-card-body .uk-navbar-nav>li>a:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-nav>li>a:active,.uk-light .uk-navbar-nav>li>a:active,.uk-offcanvas-bar .uk-navbar-nav>li>a:active,.uk-overlay-primary .uk-navbar-nav>li>a:active,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav>li>a:active,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav>li>a:active,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav>li>a:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav>li>a:active{color:#fff}.uk-card-primary.uk-card-body .uk-navbar-nav>li.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-nav>li.uk-active>a,.uk-card-secondary.uk-card-body .uk-navbar-nav>li.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-nav>li.uk-active>a,.uk-light .uk-navbar-nav>li.uk-active>a,.uk-offcanvas-bar .uk-navbar-nav>li.uk-active>a,.uk-overlay-primary .uk-navbar-nav>li.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav>li.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav>li.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav>li.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav>li.uk-active>a{color:#fff}.uk-card-primary.uk-card-body .uk-navbar-item,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-item,.uk-card-secondary.uk-card-body .uk-navbar-item,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-item,.uk-light .uk-navbar-item,.uk-offcanvas-bar .uk-navbar-item,.uk-overlay-primary .uk-navbar-item,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-item,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-item,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-item,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-item{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-navbar-toggle,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-toggle,.uk-card-secondary.uk-card-body .uk-navbar-toggle,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-toggle,.uk-light .uk-navbar-toggle,.uk-offcanvas-bar .uk-navbar-toggle,.uk-overlay-primary .uk-navbar-toggle,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-toggle,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-toggle,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-toggle,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-toggle{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-navbar-toggle.uk-open,.uk-card-primary.uk-card-body .uk-navbar-toggle:focus,.uk-card-primary.uk-card-body .uk-navbar-toggle:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-toggle.uk-open,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-toggle:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-navbar-toggle:hover,.uk-card-secondary.uk-card-body .uk-navbar-toggle.uk-open,.uk-card-secondary.uk-card-body .uk-navbar-toggle:focus,.uk-card-secondary.uk-card-body .uk-navbar-toggle:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-toggle.uk-open,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-toggle:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-navbar-toggle:hover,.uk-light .uk-navbar-toggle.uk-open,.uk-light .uk-navbar-toggle:focus,.uk-light .uk-navbar-toggle:hover,.uk-offcanvas-bar .uk-navbar-toggle.uk-open,.uk-offcanvas-bar .uk-navbar-toggle:focus,.uk-offcanvas-bar .uk-navbar-toggle:hover,.uk-overlay-primary .uk-navbar-toggle.uk-open,.uk-overlay-primary .uk-navbar-toggle:focus,.uk-overlay-primary .uk-navbar-toggle:hover,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-toggle.uk-open,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-toggle:focus,.uk-section-primary:not(.uk-preserve-color) .uk-navbar-toggle:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-toggle.uk-open,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-toggle:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-toggle:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-toggle.uk-open,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-toggle:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-toggle:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-toggle.uk-open,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-toggle:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-toggle:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-subnav>*>:first-child,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav>*>:first-child,.uk-card-secondary.uk-card-body .uk-subnav>*>:first-child,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav>*>:first-child,.uk-light .uk-subnav>*>:first-child,.uk-offcanvas-bar .uk-subnav>*>:first-child,.uk-overlay-primary .uk-subnav>*>:first-child,.uk-section-primary:not(.uk-preserve-color) .uk-subnav>*>:first-child,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav>*>:first-child,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav>*>:first-child,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav>*>:first-child{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-subnav>*>a:focus,.uk-card-primary.uk-card-body .uk-subnav>*>a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav>*>a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav>*>a:hover,.uk-card-secondary.uk-card-body .uk-subnav>*>a:focus,.uk-card-secondary.uk-card-body .uk-subnav>*>a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav>*>a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav>*>a:hover,.uk-light .uk-subnav>*>a:focus,.uk-light .uk-subnav>*>a:hover,.uk-offcanvas-bar .uk-subnav>*>a:focus,.uk-offcanvas-bar .uk-subnav>*>a:hover,.uk-overlay-primary .uk-subnav>*>a:focus,.uk-overlay-primary .uk-subnav>*>a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-subnav>*>a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-subnav>*>a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav>*>a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav>*>a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav>*>a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav>*>a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav>*>a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav>*>a:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-subnav>.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav>.uk-active>a,.uk-card-secondary.uk-card-body .uk-subnav>.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav>.uk-active>a,.uk-light .uk-subnav>.uk-active>a,.uk-offcanvas-bar .uk-subnav>.uk-active>a,.uk-overlay-primary .uk-subnav>.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-subnav>.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav>.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav>.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav>.uk-active>a{color:#fff}.uk-card-primary.uk-card-body .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-card-secondary.uk-card-body .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-light .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-offcanvas-bar .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-overlay-primary .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-section-primary:not(.uk-preserve-color) .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-divider>:nth-child(n+2):not(.uk-first-column)::before{border-left-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-subnav-pill>*>:first-child,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav-pill>*>:first-child,.uk-card-secondary.uk-card-body .uk-subnav-pill>*>:first-child,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav-pill>*>:first-child,.uk-light .uk-subnav-pill>*>:first-child,.uk-offcanvas-bar .uk-subnav-pill>*>:first-child,.uk-overlay-primary .uk-subnav-pill>*>:first-child,.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill>*>:first-child,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill>*>:first-child,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill>*>:first-child,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill>*>:first-child{background-color:transparent;color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-subnav-pill>*>a:focus,.uk-card-primary.uk-card-body .uk-subnav-pill>*>a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav-pill>*>a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav-pill>*>a:hover,.uk-card-secondary.uk-card-body .uk-subnav-pill>*>a:focus,.uk-card-secondary.uk-card-body .uk-subnav-pill>*>a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav-pill>*>a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav-pill>*>a:hover,.uk-light .uk-subnav-pill>*>a:focus,.uk-light .uk-subnav-pill>*>a:hover,.uk-offcanvas-bar .uk-subnav-pill>*>a:focus,.uk-offcanvas-bar .uk-subnav-pill>*>a:hover,.uk-overlay-primary .uk-subnav-pill>*>a:focus,.uk-overlay-primary .uk-subnav-pill>*>a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill>*>a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill>*>a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill>*>a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill>*>a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill>*>a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill>*>a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill>*>a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill>*>a:hover{background-color:rgba(255,255,255,.1);color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-subnav-pill>*>a:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav-pill>*>a:active,.uk-card-secondary.uk-card-body .uk-subnav-pill>*>a:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav-pill>*>a:active,.uk-light .uk-subnav-pill>*>a:active,.uk-offcanvas-bar .uk-subnav-pill>*>a:active,.uk-overlay-primary .uk-subnav-pill>*>a:active,.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill>*>a:active,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill>*>a:active,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill>*>a:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill>*>a:active{background-color:rgba(255,255,255,.1);color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-subnav-pill>.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav-pill>.uk-active>a,.uk-card-secondary.uk-card-body .uk-subnav-pill>.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav-pill>.uk-active>a,.uk-light .uk-subnav-pill>.uk-active>a,.uk-offcanvas-bar .uk-subnav-pill>.uk-active>a,.uk-overlay-primary .uk-subnav-pill>.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill>.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill>.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill>.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill>.uk-active>a{background-color:#fff;color:#666}.uk-card-primary.uk-card-body .uk-subnav>.uk-disabled>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-subnav>.uk-disabled>a,.uk-card-secondary.uk-card-body .uk-subnav>.uk-disabled>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-subnav>.uk-disabled>a,.uk-light .uk-subnav>.uk-disabled>a,.uk-offcanvas-bar .uk-subnav>.uk-disabled>a,.uk-overlay-primary .uk-subnav>.uk-disabled>a,.uk-section-primary:not(.uk-preserve-color) .uk-subnav>.uk-disabled>a,.uk-section-secondary:not(.uk-preserve-color) .uk-subnav>.uk-disabled>a,.uk-tile-primary:not(.uk-preserve-color) .uk-subnav>.uk-disabled>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav>.uk-disabled>a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-breadcrumb>*>*,.uk-card-primary>:not([class*=uk-card-media]) .uk-breadcrumb>*>*,.uk-card-secondary.uk-card-body .uk-breadcrumb>*>*,.uk-card-secondary>:not([class*=uk-card-media]) .uk-breadcrumb>*>*,.uk-light .uk-breadcrumb>*>*,.uk-offcanvas-bar .uk-breadcrumb>*>*,.uk-overlay-primary .uk-breadcrumb>*>*,.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb>*>*,.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb>*>*,.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb>*>*,.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb>*>*{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-breadcrumb>*>:focus,.uk-card-primary.uk-card-body .uk-breadcrumb>*>:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-breadcrumb>*>:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-breadcrumb>*>:hover,.uk-card-secondary.uk-card-body .uk-breadcrumb>*>:focus,.uk-card-secondary.uk-card-body .uk-breadcrumb>*>:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-breadcrumb>*>:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-breadcrumb>*>:hover,.uk-light .uk-breadcrumb>*>:focus,.uk-light .uk-breadcrumb>*>:hover,.uk-offcanvas-bar .uk-breadcrumb>*>:focus,.uk-offcanvas-bar .uk-breadcrumb>*>:hover,.uk-overlay-primary .uk-breadcrumb>*>:focus,.uk-overlay-primary .uk-breadcrumb>*>:hover,.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb>*>:focus,.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb>*>:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb>*>:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb>*>:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb>*>:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb>*>:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb>*>:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb>*>:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-breadcrumb>:last-child>*,.uk-card-primary>:not([class*=uk-card-media]) .uk-breadcrumb>:last-child>*,.uk-card-secondary.uk-card-body .uk-breadcrumb>:last-child>*,.uk-card-secondary>:not([class*=uk-card-media]) .uk-breadcrumb>:last-child>*,.uk-light .uk-breadcrumb>:last-child>*,.uk-offcanvas-bar .uk-breadcrumb>:last-child>*,.uk-overlay-primary .uk-breadcrumb>:last-child>*,.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb>:last-child>*,.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb>:last-child>*,.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb>:last-child>*,.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb>:last-child>*{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-card-secondary.uk-card-body .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-light .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-offcanvas-bar .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-overlay-primary .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb>:nth-child(n+2):not(.uk-first-column)::before{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-pagination>*>*,.uk-card-primary>:not([class*=uk-card-media]) .uk-pagination>*>*,.uk-card-secondary.uk-card-body .uk-pagination>*>*,.uk-card-secondary>:not([class*=uk-card-media]) .uk-pagination>*>*,.uk-light .uk-pagination>*>*,.uk-offcanvas-bar .uk-pagination>*>*,.uk-overlay-primary .uk-pagination>*>*,.uk-section-primary:not(.uk-preserve-color) .uk-pagination>*>*,.uk-section-secondary:not(.uk-preserve-color) .uk-pagination>*>*,.uk-tile-primary:not(.uk-preserve-color) .uk-pagination>*>*,.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination>*>*{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-pagination>*>:focus,.uk-card-primary.uk-card-body .uk-pagination>*>:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-pagination>*>:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-pagination>*>:hover,.uk-card-secondary.uk-card-body .uk-pagination>*>:focus,.uk-card-secondary.uk-card-body .uk-pagination>*>:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-pagination>*>:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-pagination>*>:hover,.uk-light .uk-pagination>*>:focus,.uk-light .uk-pagination>*>:hover,.uk-offcanvas-bar .uk-pagination>*>:focus,.uk-offcanvas-bar .uk-pagination>*>:hover,.uk-overlay-primary .uk-pagination>*>:focus,.uk-overlay-primary .uk-pagination>*>:hover,.uk-section-primary:not(.uk-preserve-color) .uk-pagination>*>:focus,.uk-section-primary:not(.uk-preserve-color) .uk-pagination>*>:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-pagination>*>:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-pagination>*>:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-pagination>*>:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-pagination>*>:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination>*>:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination>*>:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-pagination>.uk-active>*,.uk-card-primary>:not([class*=uk-card-media]) .uk-pagination>.uk-active>*,.uk-card-secondary.uk-card-body .uk-pagination>.uk-active>*,.uk-card-secondary>:not([class*=uk-card-media]) .uk-pagination>.uk-active>*,.uk-light .uk-pagination>.uk-active>*,.uk-offcanvas-bar .uk-pagination>.uk-active>*,.uk-overlay-primary .uk-pagination>.uk-active>*,.uk-section-primary:not(.uk-preserve-color) .uk-pagination>.uk-active>*,.uk-section-secondary:not(.uk-preserve-color) .uk-pagination>.uk-active>*,.uk-tile-primary:not(.uk-preserve-color) .uk-pagination>.uk-active>*,.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination>.uk-active>*{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-pagination>.uk-disabled>*,.uk-card-primary>:not([class*=uk-card-media]) .uk-pagination>.uk-disabled>*,.uk-card-secondary.uk-card-body .uk-pagination>.uk-disabled>*,.uk-card-secondary>:not([class*=uk-card-media]) .uk-pagination>.uk-disabled>*,.uk-light .uk-pagination>.uk-disabled>*,.uk-offcanvas-bar .uk-pagination>.uk-disabled>*,.uk-overlay-primary .uk-pagination>.uk-disabled>*,.uk-section-primary:not(.uk-preserve-color) .uk-pagination>.uk-disabled>*,.uk-section-secondary:not(.uk-preserve-color) .uk-pagination>.uk-disabled>*,.uk-tile-primary:not(.uk-preserve-color) .uk-pagination>.uk-disabled>*,.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination>.uk-disabled>*{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-tab::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-tab::before,.uk-card-secondary.uk-card-body .uk-tab::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-tab::before,.uk-light .uk-tab::before,.uk-offcanvas-bar .uk-tab::before,.uk-overlay-primary .uk-tab::before,.uk-section-primary:not(.uk-preserve-color) .uk-tab::before,.uk-section-secondary:not(.uk-preserve-color) .uk-tab::before,.uk-tile-primary:not(.uk-preserve-color) .uk-tab::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-tab::before{border-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-tab>*>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-tab>*>a,.uk-card-secondary.uk-card-body .uk-tab>*>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-tab>*>a,.uk-light .uk-tab>*>a,.uk-offcanvas-bar .uk-tab>*>a,.uk-overlay-primary .uk-tab>*>a,.uk-section-primary:not(.uk-preserve-color) .uk-tab>*>a,.uk-section-secondary:not(.uk-preserve-color) .uk-tab>*>a,.uk-tile-primary:not(.uk-preserve-color) .uk-tab>*>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-tab>*>a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-tab>*>a:focus,.uk-card-primary.uk-card-body .uk-tab>*>a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-tab>*>a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-tab>*>a:hover,.uk-card-secondary.uk-card-body .uk-tab>*>a:focus,.uk-card-secondary.uk-card-body .uk-tab>*>a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-tab>*>a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-tab>*>a:hover,.uk-light .uk-tab>*>a:focus,.uk-light .uk-tab>*>a:hover,.uk-offcanvas-bar .uk-tab>*>a:focus,.uk-offcanvas-bar .uk-tab>*>a:hover,.uk-overlay-primary .uk-tab>*>a:focus,.uk-overlay-primary .uk-tab>*>a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-tab>*>a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-tab>*>a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-tab>*>a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-tab>*>a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-tab>*>a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-tab>*>a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-tab>*>a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-tab>*>a:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-tab>.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-tab>.uk-active>a,.uk-card-secondary.uk-card-body .uk-tab>.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-tab>.uk-active>a,.uk-light .uk-tab>.uk-active>a,.uk-offcanvas-bar .uk-tab>.uk-active>a,.uk-overlay-primary .uk-tab>.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-tab>.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-tab>.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-tab>.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-tab>.uk-active>a{color:#fff;border-color:#fff}.uk-card-primary.uk-card-body .uk-tab>.uk-disabled>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-tab>.uk-disabled>a,.uk-card-secondary.uk-card-body .uk-tab>.uk-disabled>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-tab>.uk-disabled>a,.uk-light .uk-tab>.uk-disabled>a,.uk-offcanvas-bar .uk-tab>.uk-disabled>a,.uk-overlay-primary .uk-tab>.uk-disabled>a,.uk-section-primary:not(.uk-preserve-color) .uk-tab>.uk-disabled>a,.uk-section-secondary:not(.uk-preserve-color) .uk-tab>.uk-disabled>a,.uk-tile-primary:not(.uk-preserve-color) .uk-tab>.uk-disabled>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-tab>.uk-disabled>a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-slidenav,.uk-card-primary>:not([class*=uk-card-media]) .uk-slidenav,.uk-card-secondary.uk-card-body .uk-slidenav,.uk-card-secondary>:not([class*=uk-card-media]) .uk-slidenav,.uk-light .uk-slidenav,.uk-offcanvas-bar .uk-slidenav,.uk-overlay-primary .uk-slidenav,.uk-section-primary:not(.uk-preserve-color) .uk-slidenav,.uk-section-secondary:not(.uk-preserve-color) .uk-slidenav,.uk-tile-primary:not(.uk-preserve-color) .uk-slidenav,.uk-tile-secondary:not(.uk-preserve-color) .uk-slidenav{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-slidenav:focus,.uk-card-primary.uk-card-body .uk-slidenav:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-slidenav:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-slidenav:hover,.uk-card-secondary.uk-card-body .uk-slidenav:focus,.uk-card-secondary.uk-card-body .uk-slidenav:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-slidenav:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-slidenav:hover,.uk-light .uk-slidenav:focus,.uk-light .uk-slidenav:hover,.uk-offcanvas-bar .uk-slidenav:focus,.uk-offcanvas-bar .uk-slidenav:hover,.uk-overlay-primary .uk-slidenav:focus,.uk-overlay-primary .uk-slidenav:hover,.uk-section-primary:not(.uk-preserve-color) .uk-slidenav:focus,.uk-section-primary:not(.uk-preserve-color) .uk-slidenav:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-slidenav:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-slidenav:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-slidenav:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-slidenav:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-slidenav:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-slidenav:hover{color:rgba(255,255,255,.95)}.uk-card-primary.uk-card-body .uk-slidenav:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-slidenav:active,.uk-card-secondary.uk-card-body .uk-slidenav:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-slidenav:active,.uk-light .uk-slidenav:active,.uk-offcanvas-bar .uk-slidenav:active,.uk-overlay-primary .uk-slidenav:active,.uk-section-primary:not(.uk-preserve-color) .uk-slidenav:active,.uk-section-secondary:not(.uk-preserve-color) .uk-slidenav:active,.uk-tile-primary:not(.uk-preserve-color) .uk-slidenav:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-slidenav:active{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-dotnav>*>*,.uk-card-primary>:not([class*=uk-card-media]) .uk-dotnav>*>*,.uk-card-secondary.uk-card-body .uk-dotnav>*>*,.uk-card-secondary>:not([class*=uk-card-media]) .uk-dotnav>*>*,.uk-light .uk-dotnav>*>*,.uk-offcanvas-bar .uk-dotnav>*>*,.uk-overlay-primary .uk-dotnav>*>*,.uk-section-primary:not(.uk-preserve-color) .uk-dotnav>*>*,.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav>*>*,.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav>*>*,.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav>*>*{background-color:transparent;border-color:rgba(255,255,255,.9)}.uk-card-primary.uk-card-body .uk-dotnav>*>:focus,.uk-card-primary.uk-card-body .uk-dotnav>*>:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-dotnav>*>:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-dotnav>*>:hover,.uk-card-secondary.uk-card-body .uk-dotnav>*>:focus,.uk-card-secondary.uk-card-body .uk-dotnav>*>:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-dotnav>*>:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-dotnav>*>:hover,.uk-light .uk-dotnav>*>:focus,.uk-light .uk-dotnav>*>:hover,.uk-offcanvas-bar .uk-dotnav>*>:focus,.uk-offcanvas-bar .uk-dotnav>*>:hover,.uk-overlay-primary .uk-dotnav>*>:focus,.uk-overlay-primary .uk-dotnav>*>:hover,.uk-section-primary:not(.uk-preserve-color) .uk-dotnav>*>:focus,.uk-section-primary:not(.uk-preserve-color) .uk-dotnav>*>:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav>*>:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav>*>:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav>*>:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav>*>:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav>*>:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav>*>:hover{background-color:rgba(255,255,255,.9);border-color:transparent}.uk-card-primary.uk-card-body .uk-dotnav>*>:active,.uk-card-primary>:not([class*=uk-card-media]) .uk-dotnav>*>:active,.uk-card-secondary.uk-card-body .uk-dotnav>*>:active,.uk-card-secondary>:not([class*=uk-card-media]) .uk-dotnav>*>:active,.uk-light .uk-dotnav>*>:active,.uk-offcanvas-bar .uk-dotnav>*>:active,.uk-overlay-primary .uk-dotnav>*>:active,.uk-section-primary:not(.uk-preserve-color) .uk-dotnav>*>:active,.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav>*>:active,.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav>*>:active,.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav>*>:active{background-color:rgba(255,255,255,.5);border-color:transparent}.uk-card-primary.uk-card-body .uk-dotnav>.uk-active>*,.uk-card-primary>:not([class*=uk-card-media]) .uk-dotnav>.uk-active>*,.uk-card-secondary.uk-card-body .uk-dotnav>.uk-active>*,.uk-card-secondary>:not([class*=uk-card-media]) .uk-dotnav>.uk-active>*,.uk-light .uk-dotnav>.uk-active>*,.uk-offcanvas-bar .uk-dotnav>.uk-active>*,.uk-overlay-primary .uk-dotnav>.uk-active>*,.uk-section-primary:not(.uk-preserve-color) .uk-dotnav>.uk-active>*,.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav>.uk-active>*,.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav>.uk-active>*,.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav>.uk-active>*{background-color:rgba(255,255,255,.9);border-color:transparent}.uk-card-primary.uk-card-body .uk-accordion-title,.uk-card-primary>:not([class*=uk-card-media]) .uk-accordion-title,.uk-card-secondary.uk-card-body .uk-accordion-title,.uk-card-secondary>:not([class*=uk-card-media]) .uk-accordion-title,.uk-light .uk-accordion-title,.uk-offcanvas-bar .uk-accordion-title,.uk-overlay-primary .uk-accordion-title,.uk-section-primary:not(.uk-preserve-color) .uk-accordion-title,.uk-section-secondary:not(.uk-preserve-color) .uk-accordion-title,.uk-tile-primary:not(.uk-preserve-color) .uk-accordion-title,.uk-tile-secondary:not(.uk-preserve-color) .uk-accordion-title{color:#fff}.uk-card-primary.uk-card-body .uk-accordion-title:focus,.uk-card-primary.uk-card-body .uk-accordion-title:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-accordion-title:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-accordion-title:hover,.uk-card-secondary.uk-card-body .uk-accordion-title:focus,.uk-card-secondary.uk-card-body .uk-accordion-title:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-accordion-title:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-accordion-title:hover,.uk-light .uk-accordion-title:focus,.uk-light .uk-accordion-title:hover,.uk-offcanvas-bar .uk-accordion-title:focus,.uk-offcanvas-bar .uk-accordion-title:hover,.uk-overlay-primary .uk-accordion-title:focus,.uk-overlay-primary .uk-accordion-title:hover,.uk-section-primary:not(.uk-preserve-color) .uk-accordion-title:focus,.uk-section-primary:not(.uk-preserve-color) .uk-accordion-title:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-accordion-title:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-accordion-title:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-accordion-title:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-accordion-title:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-accordion-title:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-accordion-title:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-iconnav>*>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-iconnav>*>a,.uk-card-secondary.uk-card-body .uk-iconnav>*>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-iconnav>*>a,.uk-light .uk-iconnav>*>a,.uk-offcanvas-bar .uk-iconnav>*>a,.uk-overlay-primary .uk-iconnav>*>a,.uk-section-primary:not(.uk-preserve-color) .uk-iconnav>*>a,.uk-section-secondary:not(.uk-preserve-color) .uk-iconnav>*>a,.uk-tile-primary:not(.uk-preserve-color) .uk-iconnav>*>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-iconnav>*>a{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-iconnav>*>a:focus,.uk-card-primary.uk-card-body .uk-iconnav>*>a:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-iconnav>*>a:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-iconnav>*>a:hover,.uk-card-secondary.uk-card-body .uk-iconnav>*>a:focus,.uk-card-secondary.uk-card-body .uk-iconnav>*>a:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-iconnav>*>a:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-iconnav>*>a:hover,.uk-light .uk-iconnav>*>a:focus,.uk-light .uk-iconnav>*>a:hover,.uk-offcanvas-bar .uk-iconnav>*>a:focus,.uk-offcanvas-bar .uk-iconnav>*>a:hover,.uk-overlay-primary .uk-iconnav>*>a:focus,.uk-overlay-primary .uk-iconnav>*>a:hover,.uk-section-primary:not(.uk-preserve-color) .uk-iconnav>*>a:focus,.uk-section-primary:not(.uk-preserve-color) .uk-iconnav>*>a:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-iconnav>*>a:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-iconnav>*>a:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-iconnav>*>a:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-iconnav>*>a:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-iconnav>*>a:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-iconnav>*>a:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-iconnav>.uk-active>a,.uk-card-primary>:not([class*=uk-card-media]) .uk-iconnav>.uk-active>a,.uk-card-secondary.uk-card-body .uk-iconnav>.uk-active>a,.uk-card-secondary>:not([class*=uk-card-media]) .uk-iconnav>.uk-active>a,.uk-light .uk-iconnav>.uk-active>a,.uk-offcanvas-bar .uk-iconnav>.uk-active>a,.uk-overlay-primary .uk-iconnav>.uk-active>a,.uk-section-primary:not(.uk-preserve-color) .uk-iconnav>.uk-active>a,.uk-section-secondary:not(.uk-preserve-color) .uk-iconnav>.uk-active>a,.uk-tile-primary:not(.uk-preserve-color) .uk-iconnav>.uk-active>a,.uk-tile-secondary:not(.uk-preserve-color) .uk-iconnav>.uk-active>a{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-text-lead,.uk-card-primary>:not([class*=uk-card-media]) .uk-text-lead,.uk-card-secondary.uk-card-body .uk-text-lead,.uk-card-secondary>:not([class*=uk-card-media]) .uk-text-lead,.uk-light .uk-text-lead,.uk-offcanvas-bar .uk-text-lead,.uk-overlay-primary .uk-text-lead,.uk-section-primary:not(.uk-preserve-color) .uk-text-lead,.uk-section-secondary:not(.uk-preserve-color) .uk-text-lead,.uk-tile-primary:not(.uk-preserve-color) .uk-text-lead,.uk-tile-secondary:not(.uk-preserve-color) .uk-text-lead{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-text-meta,.uk-card-primary>:not([class*=uk-card-media]) .uk-text-meta,.uk-card-secondary.uk-card-body .uk-text-meta,.uk-card-secondary>:not([class*=uk-card-media]) .uk-text-meta,.uk-light .uk-text-meta,.uk-offcanvas-bar .uk-text-meta,.uk-overlay-primary .uk-text-meta,.uk-section-primary:not(.uk-preserve-color) .uk-text-meta,.uk-section-secondary:not(.uk-preserve-color) .uk-text-meta,.uk-tile-primary:not(.uk-preserve-color) .uk-text-meta,.uk-tile-secondary:not(.uk-preserve-color) .uk-text-meta{color:rgba(255,255,255,.5)}.uk-card-primary.uk-card-body .uk-text-muted,.uk-card-primary>:not([class*=uk-card-media]) .uk-text-muted,.uk-card-secondary.uk-card-body .uk-text-muted,.uk-card-secondary>:not([class*=uk-card-media]) .uk-text-muted,.uk-light .uk-text-muted,.uk-offcanvas-bar .uk-text-muted,.uk-overlay-primary .uk-text-muted,.uk-section-primary:not(.uk-preserve-color) .uk-text-muted,.uk-section-secondary:not(.uk-preserve-color) .uk-text-muted,.uk-tile-primary:not(.uk-preserve-color) .uk-text-muted,.uk-tile-secondary:not(.uk-preserve-color) .uk-text-muted{color:rgba(255,255,255,.5)!important}.uk-card-primary.uk-card-body .uk-text-emphasis,.uk-card-primary>:not([class*=uk-card-media]) .uk-text-emphasis,.uk-card-secondary.uk-card-body .uk-text-emphasis,.uk-card-secondary>:not([class*=uk-card-media]) .uk-text-emphasis,.uk-light .uk-text-emphasis,.uk-offcanvas-bar .uk-text-emphasis,.uk-overlay-primary .uk-text-emphasis,.uk-section-primary:not(.uk-preserve-color) .uk-text-emphasis,.uk-section-secondary:not(.uk-preserve-color) .uk-text-emphasis,.uk-tile-primary:not(.uk-preserve-color) .uk-text-emphasis,.uk-tile-secondary:not(.uk-preserve-color) .uk-text-emphasis{color:#fff!important}.uk-card-primary.uk-card-body .uk-text-primary,.uk-card-primary>:not([class*=uk-card-media]) .uk-text-primary,.uk-card-secondary.uk-card-body .uk-text-primary,.uk-card-secondary>:not([class*=uk-card-media]) .uk-text-primary,.uk-light .uk-text-primary,.uk-offcanvas-bar .uk-text-primary,.uk-overlay-primary .uk-text-primary,.uk-section-primary:not(.uk-preserve-color) .uk-text-primary,.uk-section-secondary:not(.uk-preserve-color) .uk-text-primary,.uk-tile-primary:not(.uk-preserve-color) .uk-text-primary,.uk-tile-secondary:not(.uk-preserve-color) .uk-text-primary{color:#fff!important}.uk-card-primary.uk-card-body .uk-text-secondary,.uk-card-primary>:not([class*=uk-card-media]) .uk-text-secondary,.uk-card-secondary.uk-card-body .uk-text-secondary,.uk-card-secondary>:not([class*=uk-card-media]) .uk-text-secondary,.uk-light .uk-text-secondary,.uk-offcanvas-bar .uk-text-secondary,.uk-overlay-primary .uk-text-secondary,.uk-section-primary:not(.uk-preserve-color) .uk-text-secondary,.uk-section-secondary:not(.uk-preserve-color) .uk-text-secondary,.uk-tile-primary:not(.uk-preserve-color) .uk-text-secondary,.uk-tile-secondary:not(.uk-preserve-color) .uk-text-secondary{color:#fff!important}.uk-card-primary.uk-card-body .uk-column-divider,.uk-card-primary>:not([class*=uk-card-media]) .uk-column-divider,.uk-card-secondary.uk-card-body .uk-column-divider,.uk-card-secondary>:not([class*=uk-card-media]) .uk-column-divider,.uk-light .uk-column-divider,.uk-offcanvas-bar .uk-column-divider,.uk-overlay-primary .uk-column-divider,.uk-section-primary:not(.uk-preserve-color) .uk-column-divider,.uk-section-secondary:not(.uk-preserve-color) .uk-column-divider,.uk-tile-primary:not(.uk-preserve-color) .uk-column-divider,.uk-tile-secondary:not(.uk-preserve-color) .uk-column-divider{column-rule-color:rgba(255,255,255,.2)}.uk-card-primary.uk-card-body .uk-logo,.uk-card-primary>:not([class*=uk-card-media]) .uk-logo,.uk-card-secondary.uk-card-body .uk-logo,.uk-card-secondary>:not([class*=uk-card-media]) .uk-logo,.uk-light .uk-logo,.uk-offcanvas-bar .uk-logo,.uk-overlay-primary .uk-logo,.uk-section-primary:not(.uk-preserve-color) .uk-logo,.uk-section-secondary:not(.uk-preserve-color) .uk-logo,.uk-tile-primary:not(.uk-preserve-color) .uk-logo,.uk-tile-secondary:not(.uk-preserve-color) .uk-logo{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-logo:focus,.uk-card-primary.uk-card-body .uk-logo:hover,.uk-card-primary>:not([class*=uk-card-media]) .uk-logo:focus,.uk-card-primary>:not([class*=uk-card-media]) .uk-logo:hover,.uk-card-secondary.uk-card-body .uk-logo:focus,.uk-card-secondary.uk-card-body .uk-logo:hover,.uk-card-secondary>:not([class*=uk-card-media]) .uk-logo:focus,.uk-card-secondary>:not([class*=uk-card-media]) .uk-logo:hover,.uk-light .uk-logo:focus,.uk-light .uk-logo:hover,.uk-offcanvas-bar .uk-logo:focus,.uk-offcanvas-bar .uk-logo:hover,.uk-overlay-primary .uk-logo:focus,.uk-overlay-primary .uk-logo:hover,.uk-section-primary:not(.uk-preserve-color) .uk-logo:focus,.uk-section-primary:not(.uk-preserve-color) .uk-logo:hover,.uk-section-secondary:not(.uk-preserve-color) .uk-logo:focus,.uk-section-secondary:not(.uk-preserve-color) .uk-logo:hover,.uk-tile-primary:not(.uk-preserve-color) .uk-logo:focus,.uk-tile-primary:not(.uk-preserve-color) .uk-logo:hover,.uk-tile-secondary:not(.uk-preserve-color) .uk-logo:focus,.uk-tile-secondary:not(.uk-preserve-color) .uk-logo:hover{color:rgba(255,255,255,.7)}.uk-card-primary.uk-card-body .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-card-primary>:not([class*=uk-card-media]) .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-card-secondary.uk-card-body .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-card-secondary>:not([class*=uk-card-media]) .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-light .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-offcanvas-bar .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-overlay-primary .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-section-primary:not(.uk-preserve-color) .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-section-secondary:not(.uk-preserve-color) .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-tile-primary:not(.uk-preserve-color) .uk-logo>:not(.uk-logo-inverse):not(:only-of-type),.uk-tile-secondary:not(.uk-preserve-color) .uk-logo>:not(.uk-logo-inverse):not(:only-of-type){display:none}.uk-card-primary.uk-card-body .uk-logo-inverse,.uk-card-primary>:not([class*=uk-card-media]) .uk-logo-inverse,.uk-card-secondary.uk-card-body .uk-logo-inverse,.uk-card-secondary>:not([class*=uk-card-media]) .uk-logo-inverse,.uk-light .uk-logo-inverse,.uk-offcanvas-bar .uk-logo-inverse,.uk-overlay-primary .uk-logo-inverse,.uk-section-primary:not(.uk-preserve-color) .uk-logo-inverse,.uk-section-secondary:not(.uk-preserve-color) .uk-logo-inverse,.uk-tile-primary:not(.uk-preserve-color) .uk-logo-inverse,.uk-tile-secondary:not(.uk-preserve-color) .uk-logo-inverse{display:inline}.uk-card-primary.uk-card-body .uk-accordion-title::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-accordion-title::before,.uk-card-secondary.uk-card-body .uk-accordion-title::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-accordion-title::before,.uk-light .uk-accordion-title::before,.uk-offcanvas-bar .uk-accordion-title::before,.uk-overlay-primary .uk-accordion-title::before,.uk-section-primary:not(.uk-preserve-color) .uk-accordion-title::before,.uk-section-secondary:not(.uk-preserve-color) .uk-accordion-title::before,.uk-tile-primary:not(.uk-preserve-color) .uk-accordion-title::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-accordion-title::before{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20width%3D%2213%22%20height%3D%221%22%20x%3D%220%22%20y%3D%226%22%20%2F%3E%0A%20%20%20%20%3Crect%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20width%3D%221%22%20height%3D%2213%22%20x%3D%226%22%20y%3D%220%22%20%2F%3E%0A%3C%2Fsvg%3E")}.uk-card-primary.uk-card-body .uk-open>.uk-accordion-title::before,.uk-card-primary>:not([class*=uk-card-media]) .uk-open>.uk-accordion-title::before,.uk-card-secondary.uk-card-body .uk-open>.uk-accordion-title::before,.uk-card-secondary>:not([class*=uk-card-media]) .uk-open>.uk-accordion-title::before,.uk-light .uk-open>.uk-accordion-title::before,.uk-offcanvas-bar .uk-open>.uk-accordion-title::before,.uk-overlay-primary .uk-open>.uk-accordion-title::before,.uk-section-primary:not(.uk-preserve-color) .uk-open>.uk-accordion-title::before,.uk-section-secondary:not(.uk-preserve-color) .uk-open>.uk-accordion-title::before,.uk-tile-primary:not(.uk-preserve-color) .uk-open>.uk-accordion-title::before,.uk-tile-secondary:not(.uk-preserve-color) .uk-open>.uk-accordion-title::before{background-image:url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20width%3D%2213%22%20height%3D%221%22%20x%3D%220%22%20y%3D%226%22%20%2F%3E%0A%3C%2Fsvg%3E")}@media print{*,::after,::before{background:0 0!important;color:#000!important;box-shadow:none!important;text-shadow:none!important}a,a:visited{text-decoration:underline}blockquote,pre{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}h2,h3,p{orphans:3;widows:3}h2,h3{page-break-after:avoid}}",
{"status":false}
],

[
"uikit.min.js_3.2.0",
"/*! UIkit 3.2.0 | http://www.getuikit.com | (c) 2014 - 2019 YOOtheme | MIT License */

!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define("uikit",e):(t=t||self).UIkit=e()}(this,function(){"use strict";var e=Object.prototype,n=e.hasOwnProperty;function c(t,e){return n.call(t,e)}var i={},r=/([a-z\d])([A-Z])/g;function d(t){return t in i||(i[t]=t.replace(r,"$1-$2").toLowerCase()),i[t]}var o=/-(\w)/g;function f(t){return t.replace(o,s)}function s(t,e){return e?e.toUpperCase():""}function p(t){return t.length?s(0,t.charAt(0))+t.slice(1):""}var t=String.prototype,a=t.startsWith||function(t){return 0===this.lastIndexOf(t,0)};function w(t,e){return a.call(t,e)}var h=t.endsWith||function(t){return this.substr(-t.length)===t};function u(t,e){return h.call(t,e)}function l(t,e){return~this.indexOf(t,e)}var m=Array.prototype,g=t.includes||l,v=m.includes||l;function b(t,e){return t&&(O(t)?g:v).call(t,e)}var y=m.findIndex||function(t){for(var e=arguments,n=0;n<this.length;n++)if(t.call(e[1],this[n],n,this))return n;return-1};function x(t,e){return y.call(t,e)}var k=Array.isArray;function $(t){return"function"==typeof t}function I(t){return null!==t&&"object"==typeof t}function S(t){return I(t)&&Object.getPrototypeOf(t)===e}function T(t){return I(t)&&t===t.window}function E(t){return I(t)&&9===t.nodeType}function C(t){return I(t)&&!!t.jquery}function A(t){return t instanceof Node||I(t)&&1<=t.nodeType}var _=e.toString;function N(t){return _.call(t).match(/^\[object (NodeList|HTMLCollection)\]$/)}function M(t){return"boolean"==typeof t}function O(t){return"string"==typeof t}function D(t){return"number"==typeof t}function z(t){return D(t)||O(t)&&!isNaN(t-parseFloat(t))}function B(t){return!(k(t)?t.length:I(t)&&Object.keys(t).length)}function P(t){return void 0===t}function H(t){return M(t)?t:"true"===t||"1"===t||""===t||"false"!==t&&"0"!==t&&t}function L(t){var e=Number(t);return!isNaN(e)&&e}function F(t){return parseFloat(t)||0}function j(t){return A(t)||T(t)||E(t)?t:N(t)||C(t)?t[0]:k(t)?j(t[0]):null}function W(t){return A(t)?[t]:N(t)?m.slice.call(t):k(t)?t.map(j).filter(Boolean):C(t)?t.toArray():[]}function V(t){return k(t)?t:O(t)?t.split(/,(?![^(]*\))/).map(function(t){return z(t)?L(t):H(t.trim())}):[t]}function R(t){return t?u(t,"ms")?F(t):1e3*F(t):0}function Y(t,n){return t===n||I(t)&&I(n)&&Object.keys(t).length===Object.keys(n).length&&K(t,function(t,e){return t===n[e]})}function q(t,e,n){return t.replace(new RegExp(e+"|"+n,"mg"),function(t){return t===e?n:e})}var U=Object.assign||function(t){for(var e=[],n=arguments.length-1;0<n--;)e[n]=arguments[n+1];t=Object(t);for(var i=0;i<e.length;i++){var r=e[i];if(null!==r)for(var o in r)c(r,o)&&(t[o]=r[o])}return t};function X(t){return t[t.length-1]}function K(t,e){for(var n in t)if(!1===e(t[n],n))return!1;return!0}function G(t,r){return t.sort(function(t,e){var n=t[r];void 0===n&&(n=0);var i=e[r];return void 0===i&&(i=0),i<n?1:n<i?-1:0})}function J(t,n){var i=new Set;return t.filter(function(t){var e=t[n];return!i.has(e)&&(i.add(e)||!0)})}function Z(t,e,n){return void 0===e&&(e=0),void 0===n&&(n=1),Math.min(Math.max(L(t)||0,e),n)}function Q(){}function tt(t,e){return t.left<e.right&&t.right>e.left&&t.top<e.bottom&&t.bottom>e.top}function et(t,e){return t.x<=e.right&&t.x>=e.left&&t.y<=e.bottom&&t.y>=e.top}var nt={ratio:function(t,e,n){var i,r="width"===e?"height":"width";return(i={})[r]=t[e]?Math.round(n*t[r]/t[e]):t[r],i[e]=n,i},contain:function(n,i){var r=this;return K(n=U({},n),function(t,e){return n=n[e]>i[e]?r.ratio(n,e,i[e]):n}),n},cover:function(n,i){var r=this;return K(n=this.contain(n,i),function(t,e){return n=n[e]<i[e]?r.ratio(n,e,i[e]):n}),n}};function it(t,e,n){if(I(e))for(var i in e)it(t,i,e[i]);else{if(P(n))return(t=j(t))&&t.getAttribute(e);W(t).forEach(function(t){$(n)&&(n=n.call(t,it(t,e))),null===n?ot(t,e):t.setAttribute(e,n)})}}function rt(t,e){return W(t).some(function(t){return t.hasAttribute(e)})}function ot(t,e){t=W(t),e.split(" ").forEach(function(e){return t.forEach(function(t){return t.hasAttribute(e)&&t.removeAttribute(e)})})}function st(t,e){for(var n=0,i=[e,"data-"+e];n<i.length;n++)if(rt(t,i[n]))return it(t,i[n])}var at=/msie|trident/i.test(window.navigator.userAgent),ht="rtl"===it(document.documentElement,"dir"),ct="ontouchstart"in window,ut=window.PointerEvent,lt=ct||window.DocumentTouch&&document instanceof DocumentTouch||navigator.maxTouchPoints,dt=ut?"pointerdown":ct?"touchstart":"mousedown",ft=ut?"pointermove":ct?"touchmove":"mousemove",pt=ut?"pointerup":ct?"touchend":"mouseup",mt=ut?"pointerenter":ct?"":"mouseenter",gt=ut?"pointerleave":ct?"":"mouseleave",vt=ut?"pointercancel":"touchcancel";function wt(t,e){return j(t)||xt(t,yt(t,e))}function bt(t,e){var n=W(t);return n.length&&n||kt(t,yt(t,e))}function yt(t,e){return void 0===e&&(e=document),Tt(t)||E(e)?e:e.ownerDocument}function xt(t,e){return j($t(t,e,"querySelector"))}function kt(t,e){return W($t(t,e,"querySelectorAll"))}function $t(t,s,e){if(void 0===s&&(s=document),!t||!O(t))return null;var a;Tt(t=t.replace(St,"$1 *"))&&(a=[],t=function(t){return t.match(Et).map(function(t){return t.replace(/,$/,"").trim()})}(t).map(function(t,e){var n=s;if("!"===t[0]){var i=t.substr(1).trim().split(" ");n=Mt(s.parentNode,i[0]),t=i.slice(1).join(" ").trim()}if("-"===t[0]){var r=t.substr(1).trim().split(" "),o=(n||s).previousElementSibling;n=_t(o,t.substr(1))?o:null,t=r.slice(1).join(" ")}return n?(n.id||(n.id="uk-"+Date.now()+e,a.push(function(){return ot(n,"id")})),"#"+zt(n.id)+" "+t):null}).filter(Boolean).join(","),s=document);try{return s[e](t)}catch(t){return null}finally{a&&a.forEach(function(t){return t()})}}var It=/(^|[^\\],)\s*[!>+~-]/,St=/([!>+~-])(?=\s+[!>+~-]|\s*$)/g;function Tt(t){return O(t)&&t.match(It)}var Et=/.*?[^\\](?:,|$)/g;var Ct=Element.prototype,At=Ct.matches||Ct.webkitMatchesSelector||Ct.msMatchesSelector;function _t(t,e){return W(t).some(function(t){return At.call(t,e)})}var Nt=Ct.closest||function(t){var e=this;do{if(_t(e,t))return e;e=e.parentNode}while(e&&1===e.nodeType)};function Mt(t,e){return w(e,">")&&(e=e.slice(1)),A(t)?Nt.call(t,e):W(t).map(function(t){return Mt(t,e)}).filter(Boolean)}function Ot(t,e){var n=[];for(t=j(t);(t=t.parentNode)&&1===t.nodeType;)_t(t,e)&&n.push(t);return n}var Dt=window.CSS&&CSS.escape||function(t){return t.replace(/([^\x7f-\uFFFF\w-])/g,function(t){return"\\"+t})};function zt(t){return O(t)?Dt.call(null,t):""}var Bt={area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,menuitem:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};function Pt(t){return W(t).some(function(t){return Bt[t.tagName.toLowerCase()]})}function Ht(t){return W(t).some(function(t){return t.offsetWidth||t.offsetHeight||t.getClientRects().length})}var Lt="input,select,textarea,button";function Ft(t){return W(t).some(function(t){return _t(t,Lt)})}function jt(t,e){return W(t).filter(function(t){return _t(t,e)})}function Wt(t,e){return O(e)?_t(t,e)||Mt(t,e):t===e||(E(e)?e.documentElement:j(e)).contains(j(t))}function Vt(){for(var t=[],e=arguments.length;e--;)t[e]=arguments[e];var n=Xt(t),i=n[0],r=n[1],o=n[2],s=n[3],a=n[4];return i=Zt(i),1<s.length&&(s=function(e){return function(t){return k(t.detail)?e.apply(void 0,[t].concat(t.detail)):e(t)}}(s)),o&&(s=function(t,i,r){var o=this;return function(n){t.forEach(function(t){var e=">"===i[0]?kt(i,t).reverse().filter(function(t){return Wt(n.target,t)})[0]:Mt(n.target,i);e&&(n.delegate=t,n.current=e,r.call(o,n))})}}(i,o,s)),a&&a.self&&(s=function(e){return function(t){if(t.target===t.currentTarget||t.target===t.current)return e.call(null,t)}}(s)),a=Kt(a),r.split(" ").forEach(function(e){return i.forEach(function(t){return t.addEventListener(e,s,a)})}),function(){return Rt(i,r,s,a)}}function Rt(t,e,n,i){void 0===i&&(i=!1),i=Kt(i),t=Zt(t),e.split(" ").forEach(function(e){return t.forEach(function(t){return t.removeEventListener(e,n,i)})})}function Yt(){for(var t=[],e=arguments.length;e--;)t[e]=arguments[e];var n=Xt(t),i=n[0],r=n[1],o=n[2],s=n[3],a=n[4],h=n[5],c=Vt(i,r,o,function(t){var e=!h||h(t);e&&(c(),s(t,e))},a);return c}function qt(t,n,i){return Zt(t).reduce(function(t,e){return t&&e.dispatchEvent(Ut(n,!0,!0,i))},!0)}function Ut(t,e,n,i){if(void 0===e&&(e=!0),void 0===n&&(n=!1),O(t)){var r=document.createEvent("CustomEvent");r.initCustomEvent(t,e,n,i),t=r}return t}function Xt(t){return $(t[2])&&t.splice(2,0,!1),t}function Kt(t){return t&&at&&!M(t)?!!t.capture:t}function Gt(t){return t&&"addEventListener"in t}function Jt(t){return Gt(t)?t:j(t)}function Zt(t){return k(t)?t.map(Jt).filter(Boolean):O(t)?kt(t):Gt(t)?[t]:W(t)}function Qt(t){return"touch"===t.pointerType||!!t.touches}function te(t,e){void 0===e&&(e="client");var n=t.touches,i=t.changedTouches,r=n&&n[0]||i&&i[0]||t;return{x:r[e+"X"],y:r[e+"Y"]}}function ee(){var n=this;this.promise=new ne(function(t,e){n.reject=e,n.resolve=t})}var ne="Promise"in window?window.Promise:oe,ie=2,re="setImmediate"in window?setImmediate:setTimeout;function oe(t){this.state=ie,this.value=void 0,this.deferred=[];var e=this;try{t(function(t){e.resolve(t)},function(t){e.reject(t)})}catch(t){e.reject(t)}}oe.reject=function(n){return new oe(function(t,e){e(n)})},oe.resolve=function(n){return new oe(function(t,e){t(n)})},oe.all=function(s){return new oe(function(n,t){var i=[],r=0;function e(e){return function(t){i[e]=t,(r+=1)===s.length&&n(i)}}0===s.length&&n(i);for(var o=0;o<s.length;o+=1)oe.resolve(s[o]).then(e(o),t)})},oe.race=function(i){return new oe(function(t,e){for(var n=0;n<i.length;n+=1)oe.resolve(i[n]).then(t,e)})};var se=oe.prototype;function ae(s,a){return new ne(function(t,e){var n=U({data:null,method:"GET",headers:{},xhr:new XMLHttpRequest,beforeSend:Q,responseType:""},a);n.beforeSend(n);var i=n.xhr;for(var r in n)if(r in i)try{i[r]=n[r]}catch(t){}for(var o in i.open(n.method.toUpperCase(),s),n.headers)i.setRequestHeader(o,n.headers[o]);Vt(i,"load",function(){0===i.status||200<=i.status&&i.status<300||304===i.status?t(i):e(U(Error(i.statusText),{xhr:i,status:i.status}))}),Vt(i,"error",function(){return e(U(Error("Network Error"),{xhr:i}))}),Vt(i,"timeout",function(){return e(U(Error("Network Timeout"),{xhr:i}))}),i.send(n.data)})}function he(i,r,o){return new ne(function(t,e){var n=new Image;n.onerror=e,n.onload=function(){return t(n)},o&&(n.sizes=o),r&&(n.srcset=r),n.src=i})}function ce(t){if("loading"===document.readyState)var e=Vt(document,"DOMContentLoaded",function(){e(),t()});else t()}function ue(t,e){return e?W(t).indexOf(j(e)):W((t=j(t))&&t.parentNode.children).indexOf(t)}function le(t,e,n,i){void 0===n&&(n=0),void 0===i&&(i=!1);var r=(e=W(e)).length;return t=z(t)?L(t):"next"===t?n+1:"previous"===t?n-1:ue(e,t),i?Z(t,0,r-1):(t%=r)<0?t+r:t}function de(t){return(t=Te(t)).innerHTML="",t}function fe(t,e){return t=Te(t),P(e)?t.innerHTML:pe(t.hasChildNodes()?de(t):t,e)}function pe(e,t){return e=Te(e),ve(t,function(t){return e.appendChild(t)})}function me(e,t){return e=Te(e),ve(t,function(t){return e.parentNode.insertBefore(t,e)})}function ge(e,t){return e=Te(e),ve(t,function(t){return e.nextSibling?me(e.nextSibling,t):pe(e.parentNode,t)})}function ve(t,e){return(t=O(t)?Ie(t):t)?"length"in t?W(t).map(e):e(t):null}function we(t){W(t).map(function(t){return t.parentNode&&t.parentNode.removeChild(t)})}function be(t,e){for(e=j(me(t,e));e.firstChild;)e=e.firstChild;return pe(e,t),e}function ye(t,e){return W(W(t).map(function(t){return t.hasChildNodes?be(W(t.childNodes),e):pe(t,e)}))}function xe(t){W(t).map(function(t){return t.parentNode}).filter(function(t,e,n){return n.indexOf(t)===e}).forEach(function(t){me(t,t.childNodes),we(t)})}se.resolve=function(t){var e=this;if(e.state===ie){if(t===e)throw new TypeError("Promise settled with itself.");var n=!1;try{var i=t&&t.then;if(null!==t&&I(t)&&$(i))return void i.call(t,function(t){n||e.resolve(t),n=!0},function(t){n||e.reject(t),n=!0})}catch(t){return void(n||e.reject(t))}e.state=0,e.value=t,e.notify()}},se.reject=function(t){var e=this;if(e.state===ie){if(t===e)throw new TypeError("Promise settled with itself.");e.state=1,e.value=t,e.notify()}},se.notify=function(){var o=this;re(function(){if(o.state!==ie)for(;o.deferred.length;){var t=o.deferred.shift(),e=t[0],n=t[1],i=t[2],r=t[3];try{0===o.state?$(e)?i(e.call(void 0,o.value)):i(o.value):1===o.state&&($(n)?i(n.call(void 0,o.value)):r(o.value))}catch(t){r(t)}}})},se.then=function(n,i){var r=this;return new oe(function(t,e){r.deferred.push([n,i,t,e]),r.notify()})},se.catch=function(t){return this.then(void 0,t)};var ke=/^\s*<(\w+|!)[^>]*>/,$e=/^<(\w+)\s*\/?>(?:<\/\1>)?$/;function Ie(t){var e=$e.exec(t);if(e)return document.createElement(e[1]);var n=document.createElement("div");return ke.test(t)?n.insertAdjacentHTML("beforeend",t.trim()):n.textContent=t,1<n.childNodes.length?W(n.childNodes):n.firstChild}function Se(t,e){if(t&&1===t.nodeType)for(e(t),t=t.firstElementChild;t;)Se(t,e),t=t.nextElementSibling}function Te(t,e){return O(t)?Ce(t)?j(Ie(t)):xt(t,e):j(t)}function Ee(t,e){return O(t)?Ce(t)?W(Ie(t)):kt(t,e):W(t)}function Ce(t){return"<"===t[0]||t.match(/^\s*</)}function Ae(t){for(var e=[],n=arguments.length-1;0<n--;)e[n]=arguments[n+1];ze(t,e,"add")}function _e(t){for(var e=[],n=arguments.length-1;0<n--;)e[n]=arguments[n+1];ze(t,e,"remove")}function Ne(t,e){it(t,"class",function(t){return(t||"").replace(new RegExp("\\b"+e+"\\b","g"),"")})}function Me(t){for(var e=[],n=arguments.length-1;0<n--;)e[n]=arguments[n+1];e[0]&&_e(t,e[0]),e[1]&&Ae(t,e[1])}function Oe(t,e){return e&&W(t).some(function(t){return t.classList.contains(e.split(" ")[0])})}function De(t){for(var i=[],e=arguments.length-1;0<e--;)i[e]=arguments[e+1];if(i.length){var r=O(X(i=Be(i)))?[]:i.pop();i=i.filter(Boolean),W(t).forEach(function(t){for(var e=t.classList,n=0;n<i.length;n++)Pe.Force?e.toggle.apply(e,[i[n]].concat(r)):e[(P(r)?!e.contains(i[n]):r)?"add":"remove"](i[n])})}}function ze(t,n,i){(n=Be(n).filter(Boolean)).length&&W(t).forEach(function(t){var e=t.classList;Pe.Multiple?e[i].apply(e,n):n.forEach(function(t){return e[i](t)})})}function Be(t){return t.reduce(function(t,e){return t.concat.call(t,O(e)&&b(e," ")?e.trim().split(" "):e)},[])}var Pe={get Multiple(){return this.get("_multiple")},get Force(){return this.get("_force")},get:function(t){if(!c(this,t)){var e=document.createElement("_").classList;e.add("a","b"),e.toggle("c",!1),this._multiple=e.contains("b"),this._force=!e.contains("c")}return this[t]}},He={"animation-iteration-count":!0,"column-count":!0,"fill-opacity":!0,"flex-grow":!0,"flex-shrink":!0,"font-weight":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,widows:!0,"z-index":!0,zoom:!0};function Le(t,e,r){return W(t).map(function(n){if(O(e)){if(e=Ye(e),P(r))return je(n,e);r||D(r)?n.style[e]=z(r)&&!He[e]?r+"px":r:n.style.removeProperty(e)}else{if(k(e)){var i=Fe(n);return e.reduce(function(t,e){return t[e]=i[Ye(e)],t},{})}I(e)&&K(e,function(t,e){return Le(n,e,t)})}return n})[0]}function Fe(t,e){return(t=j(t)).ownerDocument.defaultView.getComputedStyle(t,e)}function je(t,e,n){return Fe(t,n)[e]}var We={};function Ve(t){var e=document.documentElement;if(!at)return Fe(e).getPropertyValue("--uk-"+t);if(!(t in We)){var n=pe(e,document.createElement("div"));Ae(n,"uk-"+t),We[t]=je(n,"content",":before").replace(/^["'](.*)["']$/,"$1"),we(n)}return We[t]}var Re={};function Ye(t){var e=Re[t];return e=e||(Re[t]=function(t){t=d(t);var e=document.documentElement.style;if(t in e)return t;var n,i=qe.length;for(;i--;)if((n="-"+qe[i]+"-"+t)in e)return n}(t)||t)}var qe=["webkit","moz","ms"];function Ue(t,s,a,h){return void 0===a&&(a=400),void 0===h&&(h="linear"),ne.all(W(t).map(function(o){return new ne(function(n,i){for(var t in s){var e=Le(o,t);""===e&&Le(o,t,e)}var r=setTimeout(function(){return qt(o,"transitionend")},a);Yt(o,"transitionend transitioncanceled",function(t){var e=t.type;clearTimeout(r),_e(o,"uk-transition"),Le(o,{"transition-property":"","transition-duration":"","transition-timing-function":""}),"transitioncanceled"===e?i():n()},{self:!0}),Ae(o,"uk-transition"),Le(o,U({"transition-property":Object.keys(s).map(Ye).join(","),"transition-duration":a+"ms","transition-timing-function":h},s))})}))}var Xe={start:Ue,stop:function(t){return qt(t,"transitionend"),ne.resolve()},cancel:function(t){qt(t,"transitioncanceled")},inProgress:function(t){return Oe(t,"uk-transition")}},Ke="uk-animation-",Ge="uk-cancel-animation";function Je(t,e,n,a,h){var c=arguments;return void 0===n&&(n=200),ne.all(W(t).map(function(s){return new ne(function(i,r){if(Oe(s,Ge))requestAnimationFrame(function(){return ne.resolve().then(function(){return Je.apply(void 0,c).then(i,r)})});else{var t=e+" "+Ke+(h?"leave":"enter");w(e,Ke)&&(a&&(t+=" uk-transform-origin-"+a),h&&(t+=" "+Ke+"reverse")),o(),Yt(s,"animationend animationcancel",function(t){var e=t.type,n=!1;"animationcancel"===e?(r(),o()):(i(),ne.resolve().then(function(){n=!0,o()})),requestAnimationFrame(function(){n||(Ae(s,Ge),requestAnimationFrame(function(){return _e(s,Ge)}))})},{self:!0}),Le(s,"animationDuration",n+"ms"),Ae(s,t)}function o(){Le(s,"animationDuration",""),Ne(s,Ke+"\\S*")}})}))}var Ze=new RegExp(Ke+"(enter|leave)"),Qe={in:function(t,e,n,i){return Je(t,e,n,i,!1)},out:function(t,e,n,i){return Je(t,e,n,i,!0)},inProgress:function(t){return Ze.test(it(t,"class"))},cancel:function(t){qt(t,"animationcancel")}},tn={width:["x","left","right"],height:["y","top","bottom"]};function en(t,e,u,l,d,n,i,r){u=ln(u),l=ln(l);var f={element:u,target:l};if(!t||!e)return f;var p=rn(t),m=rn(e),g=m;if(un(g,u,p,-1),un(g,l,m,1),d=dn(d,p.width,p.height),n=dn(n,m.width,m.height),d.x+=n.x,d.y+=n.y,g.left+=d.x,g.top+=d.y,i){var o=[rn(yn(t))];r&&o.unshift(rn(r)),K(tn,function(t,s){var a=t[0],h=t[1],c=t[2];!0!==i&&!b(i,a)||o.some(function(i){var t=u[a]===h?-p[s]:u[a]===c?p[s]:0,e=l[a]===h?m[s]:l[a]===c?-m[s]:0;if(g[h]<i[h]||g[h]+p[s]>i[c]){var n=p[s]/2,r="center"===l[a]?-m[s]/2:0;return"center"===u[a]&&(o(n,r)||o(-n,-r))||o(t,e)}function o(e,t){var n=g[h]+e+t-2*d[a];if(n>=i[h]&&n+p[s]<=i[c])return g[h]=n,["element","target"].forEach(function(t){f[t][a]=e?f[t][a]===tn[s][1]?tn[s][2]:tn[s][1]:f[t][a]}),!0}})})}return nn(t,g),f}function nn(n,i){if(n=j(n),!i)return rn(n);var r=nn(n),o=Le(n,"position");["left","top"].forEach(function(t){if(t in i){var e=Le(n,t);Le(n,t,i[t]-r[t]+F("absolute"===o&&"auto"===e?on(n)[t]:e))}})}function rn(t){if(!(t=j(t)))return{};var e,n,i=yn(t),r=i.pageYOffset,o=i.pageXOffset;if(T(t)){var s=t.innerHeight,a=t.innerWidth;return{top:r,left:o,height:s,width:a,bottom:r+s,right:o+a}}Ht(t)||"none"!==Le(t,"display")||(e=it(t,"style"),n=it(t,"hidden"),it(t,{style:(e||"")+";display:block !important;",hidden:null}));var h=t.getBoundingClientRect();return P(e)||it(t,{style:e,hidden:n}),{height:h.height,width:h.width,top:h.top+r,left:h.left+o,bottom:h.bottom+r,right:h.right+o}}function on(i){var r=(i=j(i)).offsetParent||function(t){return xn(t).documentElement}(i),o=nn(r),t=["top","left"].reduce(function(t,e){var n=p(e);return t[e]-=o[e]+F(Le(i,"margin"+n))+F(Le(r,"border"+n+"Width")),t},nn(i));return{top:t.top,left:t.left}}var sn=hn("height"),an=hn("width");function hn(i){var r=p(i);return function(t,e){if(t=j(t),P(e)){if(T(t))return t["inner"+r];if(E(t)){var n=t.documentElement;return Math.max(n["offset"+r],n["scroll"+r])}return(e="auto"===(e=Le(t,i))?t["offset"+r]:F(e)||0)-cn(i,t)}Le(t,i,e||0===e?+e+cn(i,t)+"px":"")}}function cn(t,n,e){return void 0===e&&(e="border-box"),Le(n,"boxSizing")===e?tn[t].slice(1).map(p).reduce(function(t,e){return t+F(Le(n,"padding"+e))+F(Le(n,"border"+e+"Width"))},0):0}function un(o,s,a,h){K(tn,function(t,e){var n=t[0],i=t[1],r=t[2];s[n]===r?o[i]+=a[e]*h:"center"===s[n]&&(o[i]+=a[e]*h/2)})}function ln(t){var e=/left|center|right/,n=/top|center|bottom/;return 1===(t=(t||"").split(" ")).length&&(t=e.test(t[0])?t.concat(["center"]):n.test(t[0])?["center"].concat(t):["center","center"]),{x:e.test(t[0])?t[0]:"center",y:n.test(t[1])?t[1]:"center"}}function dn(t,e,n){var i=(t||"").split(" "),r=i[0],o=i[1];return{x:r?F(r)*(u(r,"%")?e/100:1):0,y:o?F(o)*(u(o,"%")?n/100:1):0}}function fn(t){switch(t){case"left":return"right";case"right":return"left";case"top":return"bottom";case"bottom":return"top";default:return t}}function pn(t,e,n){if(void 0===e&&(e=0),void 0===n&&(n=0),!Ht(t))return!1;var i=yn(t=j(t)),r=t.getBoundingClientRect(),o={top:-e,left:-n,bottom:e+sn(i),right:n+an(i)};return tt(r,o)||et({x:r.left,y:r.top},o)}function mn(t,e){if(void 0===e&&(e=0),!Ht(t))return 0;var n=yn(t=j(t)),i=xn(t),r=t.offsetHeight+e,o=vn(t)[0],s=sn(n),a=s+Math.min(0,o-s),h=Math.max(0,s-(sn(i)+e-(o+r)));return Z((a+n.pageYOffset-o)/((a+(r-(h<s?h:0)))/100)/100)}function gn(t,e){if(T(t=j(t))||E(t)){var n=yn(t);(0,n.scrollTo)(n.pageXOffset,e)}else t.scrollTop=e}function vn(t){var e=[0,0];do{if(e[0]+=t.offsetTop,e[1]+=t.offsetLeft,"fixed"===Le(t,"position")){var n=yn(t);return e[0]+=n.pageYOffset,e[1]+=n.pageXOffset,e}}while(t=t.offsetParent);return e}function wn(t,e,n){return void 0===e&&(e="width"),void 0===n&&(n=window),z(t)?+t:u(t,"vh")?bn(sn(yn(n)),t):u(t,"vw")?bn(an(yn(n)),t):u(t,"%")?bn(rn(n)[e],t):F(t)}function bn(t,e){return t*F(e)/100}function yn(t){return T(t)?t:xn(t).defaultView}function xn(t){return j(t).ownerDocument}var kn={reads:[],writes:[],read:function(t){return this.reads.push(t),In(),t},write:function(t){return this.writes.push(t),In(),t},clear:function(t){return Tn(this.reads,t)||Tn(this.writes,t)},flush:$n};function $n(){Sn(kn.reads),Sn(kn.writes.splice(0,kn.writes.length)),kn.scheduled=!1,(kn.reads.length||kn.writes.length)&&In(!0)}function In(t){void 0===t&&(t=!1),kn.scheduled||(kn.scheduled=!0,t?ne.resolve().then($n):requestAnimationFrame($n))}function Sn(t){for(var e;e=t.shift();)e()}function Tn(t,e){var n=t.indexOf(e);return!!~n&&!!t.splice(n,1)}function En(){}function Cn(t,e){return(e.y-t.y)/(e.x-t.x)}En.prototype={positions:[],position:null,init:function(){var i=this;this.positions=[],this.position=null;var r=!1;this.unbind=Vt(document,"mousemove",function(n){r||(setTimeout(function(){var t=Date.now(),e=i.positions.length;e&&100<t-i.positions[e-1].time&&i.positions.splice(0,e),i.positions.push({time:t,x:n.pageX,y:n.pageY}),5<i.positions.length&&i.positions.shift(),r=!1},5),r=!0)})},cancel:function(){this.unbind&&this.unbind()},movesTo:function(t){if(this.positions.length<2)return!1;var e=nn(t),n=X(this.positions),i=this.positions[0];if(e.left<=n.x&&n.x<=e.right&&e.top<=n.y&&n.y<=e.bottom)return!1;var r=[[{x:e.left,y:e.top},{x:e.right,y:e.bottom}],[{x:e.right,y:e.top},{x:e.left,y:e.bottom}]];return e.right<=n.x||(e.left>=n.x?(r[0].reverse(),r[1].reverse()):e.bottom<=n.y?r[0].reverse():e.top>=n.y&&r[1].reverse()),!!r.reduce(function(t,e){return t+(Cn(i,e[0])<Cn(n,e[0])&&Cn(i,e[1])>Cn(n,e[1]))},0)}};var An={};function _n(t,e,n){return An.computed($(t)?t.call(n,n):t,$(e)?e.call(n,n):e)}function Nn(t,e){return t=t&&!k(t)?[t]:t,e?t?t.concat(e):k(e)?e:[e]:t}function Mn(e,n,i){var r={};if($(n)&&(n=n.options),n.extends&&(e=Mn(e,n.extends,i)),n.mixins)for(var t=0,o=n.mixins.length;t<o;t++)e=Mn(e,n.mixins[t],i);for(var s in e)h(s);for(var a in n)c(e,a)||h(a);function h(t){r[t]=(An[t]||function(t,e){return P(e)?t:e})(e[t],n[t],i)}return r}function On(t,e){var n;void 0===e&&(e=[]);try{return t?w(t,"{")?JSON.parse(t):e.length&&!b(t,":")?((n={})[e[0]]=t,n):t.split(";").reduce(function(t,e){var n=e.split(/:(.*)/),i=n[0],r=n[1];return i&&!P(r)&&(t[i.trim()]=r.trim()),t},{}):{}}catch(t){return{}}}An.events=An.created=An.beforeConnect=An.connected=An.beforeDisconnect=An.disconnected=An.destroy=Nn,An.args=function(t,e){return!1!==e&&Nn(e||t)},An.update=function(t,e){return G(Nn(t,$(e)?{read:e}:e),"order")},An.props=function(t,e){return k(e)&&(e=e.reduce(function(t,e){return t[e]=String,t},{})),An.methods(t,e)},An.computed=An.methods=function(t,e){return e?t?U({},t,e):e:t},An.data=function(e,n,t){return t?_n(e,n,t):n?e?function(t){return _n(e,n,t)}:n:e};function Dn(t){this.id=++zn,this.el=j(t)}var zn=0;function Bn(t,e){try{t.contentWindow.postMessage(JSON.stringify(U({event:"command"},e)),"*")}catch(t){}}Dn.prototype.isVideo=function(){return this.isYoutube()||this.isVimeo()||this.isHTML5()},Dn.prototype.isHTML5=function(){return"VIDEO"===this.el.tagName},Dn.prototype.isIFrame=function(){return"IFRAME"===this.el.tagName},Dn.prototype.isYoutube=function(){return this.isIFrame()&&!!this.el.src.match(/\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/)},Dn.prototype.isVimeo=function(){return this.isIFrame()&&!!this.el.src.match(/vimeo\.com\/video\/.*/)},Dn.prototype.enableApi=function(){var e=this;if(this.ready)return this.ready;var n,i=this.isYoutube(),r=this.isVimeo();return i||r?this.ready=new ne(function(t){Yt(e.el,"load",function(){if(i){var t=function(){return Bn(e.el,{event:"listening",id:e.id})};n=setInterval(t,100),t()}}),function(i){return new ne(function(n){Yt(window,"message",function(t,e){return n(e)},!1,function(t){var e=t.data;if(e&&O(e)){try{e=JSON.parse(e)}catch(t){return}return e&&i(e)}})})}(function(t){return i&&t.id===e.id&&"onReady"===t.event||r&&Number(t.player_id)===e.id}).then(function(){t(),n&&clearInterval(n)}),it(e.el,"src",e.el.src+(b(e.el.src,"?")?"&":"?")+(i?"enablejsapi=1":"api=1&player_id="+e.id))}):ne.resolve()},Dn.prototype.play=function(){var t=this;if(this.isVideo())if(this.isIFrame())this.enableApi().then(function(){return Bn(t.el,{func:"playVideo",method:"play"})});else if(this.isHTML5())try{var e=this.el.play();e&&e.catch(Q)}catch(t){}},Dn.prototype.pause=function(){var t=this;this.isVideo()&&(this.isIFrame()?this.enableApi().then(function(){return Bn(t.el,{func:"pauseVideo",method:"pause"})}):this.isHTML5()&&this.el.pause())},Dn.prototype.mute=function(){var t=this;this.isVideo()&&(this.isIFrame()?this.enableApi().then(function(){return Bn(t.el,{func:"mute",method:"setVolume",value:0})}):this.isHTML5()&&(this.el.muted=!0,it(this.el,"muted","")))};var Pn="IntersectionObserver"in window?window.IntersectionObserver:function(){function t(e,t){var n=this;void 0===t&&(t={});var i=t.rootMargin;void 0===i&&(i="0 0"),this.targets=[];var r,o=(i||"0 0").split(" ").map(F),s=o[0],a=o[1];this.offsetTop=s,this.offsetLeft=a,this.apply=function(){r=r||requestAnimationFrame(function(){return setTimeout(function(){var t=n.takeRecords();t.length&&e(t,n),r=!1})})},this.off=Vt(window,"scroll resize load",this.apply,{passive:!0,capture:!0})}return t.prototype.takeRecords=function(){var n=this;return this.targets.filter(function(t){var e=pn(t.target,n.offsetTop,n.offsetLeft);if(null===t.isIntersecting||e^t.isIntersecting)return t.isIntersecting=e,!0})},t.prototype.observe=function(t){this.targets.push({target:t,isIntersecting:null}),this.apply()},t.prototype.disconnect=function(){this.targets=[],this.off()},t}();function Hn(t){return!(!w(t,"uk-")&&!w(t,"data-uk-"))&&f(t.replace("data-uk-","").replace("uk-",""))}function Ln(t){this._init(t)}var Fn,jn,Wn,Vn,Rn,Yn,qn,Un,Xn;function Kn(t,e){if(t)for(var n in t)t[n]._connected&&t[n]._callUpdate(e)}function Gn(t,e){var n={},i=t.args;void 0===i&&(i=[]);var r=t.props;void 0===r&&(r={});var o=t.el;if(!r)return n;for(var s in r){var a=d(s),h=st(o,a);if(!P(h)){if(h=r[s]===Boolean&&""===h||ti(r[s],h),"target"===a&&(!h||w(h,"_")))continue;n[s]=h}}var c=On(st(o,e),i);for(var u in c){var l=f(u);void 0!==r[l]&&(n[l]=ti(r[l],c[u]))}return n}function Jn(i,r,o){Object.defineProperty(i,r,{enumerable:!0,get:function(){var t=i._computeds,e=i.$props,n=i.$el;return c(t,r)||(t[r]=(o.get||o).call(i,e,n)),t[r]},set:function(t){var e=i._computeds;e[r]=o.set?o.set.call(i,t):t,P(e[r])&&delete e[r]}})}function Zn(e,n,i){S(n)||(n={name:i,handler:n});var t=n.name,r=n.el,o=n.handler,s=n.capture,a=n.passive,h=n.delegate,c=n.filter,u=n.self;r=$(r)?r.call(e):r||e.$el,k(r)?r.forEach(function(t){return Zn(e,U({},n,{el:t}),i)}):!r||c&&!c.call(e)||e._events.push(Vt(r,t,h?O(h)?h:h.call(e):null,O(o)?e[o]:o.bind(e),{passive:a,capture:s,self:u}))}function Qn(t,e){return t.every(function(t){return!t||!c(t,e)})}function ti(t,e){return t===Boolean?H(e):t===Number?L(e):"list"===t?V(e):t?t(e):e}Ln.util=Object.freeze({ajax:ae,getImage:he,transition:Ue,Transition:Xe,animate:Je,Animation:Qe,attr:it,hasAttr:rt,removeAttr:ot,data:st,addClass:Ae,removeClass:_e,removeClasses:Ne,replaceClass:Me,hasClass:Oe,toggleClass:De,positionAt:en,offset:nn,position:on,height:sn,width:an,boxModelAdjust:cn,flipPosition:fn,isInView:pn,scrolledOver:mn,scrollTop:gn,offsetPosition:vn,toPx:wn,ready:ce,index:ue,getIndex:le,empty:de,html:fe,prepend:function(e,t){return(e=Te(e)).hasChildNodes()?ve(t,function(t){return e.insertBefore(t,e.firstChild)}):pe(e,t)},append:pe,before:me,after:ge,remove:we,wrapAll:be,wrapInner:ye,unwrap:xe,fragment:Ie,apply:Se,$:Te,$$:Ee,isIE:at,isRtl:ht,hasTouch:lt,pointerDown:dt,pointerMove:ft,pointerUp:pt,pointerEnter:mt,pointerLeave:gt,pointerCancel:vt,on:Vt,off:Rt,once:Yt,trigger:qt,createEvent:Ut,toEventTargets:Zt,isTouch:Qt,getEventPos:te,fastdom:kn,isVoidElement:Pt,isVisible:Ht,selInput:Lt,isInput:Ft,filter:jt,within:Wt,hasOwn:c,hyphenate:d,camelize:f,ucfirst:p,startsWith:w,endsWith:u,includes:b,findIndex:x,isArray:k,isFunction:$,isObject:I,isPlainObject:S,isWindow:T,isDocument:E,isJQuery:C,isNode:A,isNodeCollection:N,isBoolean:M,isString:O,isNumber:D,isNumeric:z,isEmpty:B,isUndefined:P,toBoolean:H,toNumber:L,toFloat:F,toNode:j,toNodes:W,toList:V,toMs:R,isEqual:Y,swap:q,assign:U,last:X,each:K,sortBy:G,uniqueBy:J,clamp:Z,noop:Q,intersectRect:tt,pointInRect:et,Dimensions:nt,MouseTracker:En,mergeOptions:Mn,parseOptions:On,Player:Dn,Promise:ne,Deferred:ee,IntersectionObserver:Pn,query:wt,queryAll:bt,find:xt,findAll:kt,matches:_t,closest:Mt,parents:Ot,escape:zt,css:Le,getStyles:Fe,getStyle:je,getCssVar:Ve,propName:Ye}),Ln.data="__uikit__",Ln.prefix="uk-",Ln.options={},Wn=(Fn=Ln).data,Fn.use=function(t){if(!t.installed)return t.call(null,this),t.installed=!0,this},Fn.mixin=function(t,e){(e=(O(e)?Fn.component(e):e)||this).options=Mn(e.options,t)},Fn.extend=function(t){function e(t){this._init(t)}return t=t||{},((e.prototype=Object.create(this.prototype)).constructor=e).options=Mn(this.options,t),e.super=this,e.extend=this.extend,e},Fn.update=function(t,e){(function t(e,n){e&&e!==document.body&&e.parentNode&&(t(e.parentNode,n),n(e.parentNode))})(t=t?j(t):document.body,function(t){return Kn(t[Wn],e)}),Se(t,function(t){return Kn(t[Wn],e)})},Object.defineProperty(Fn,"container",{get:function(){return jn||document.body},set:function(t){jn=Te(t)}}),(Vn=Ln).prototype._callHook=function(t){var e=this,n=this.$options[t];n&&n.forEach(function(t){return t.call(e)})},Vn.prototype._callConnected=function(){this._connected||(this._data={},this._computeds={},this._initProps(),this._callHook("beforeConnect"),this._connected=!0,this._initEvents(),this._initObserver(),this._callHook("connected"),this._callUpdate())},Vn.prototype._callDisconnected=function(){this._connected&&(this._callHook("beforeDisconnect"),this._observer&&(this._observer.disconnect(),this._observer=null),this._unbindEvents(),this._callHook("disconnected"),this._connected=!1)},Vn.prototype._callUpdate=function(t){var o=this;void 0===t&&(t="update");var s=t.type||t;b(["update","resize"],s)&&this._callWatches();var e=this.$options.update,n=this._frames,a=n.reads,h=n.writes;e&&e.forEach(function(t,e){var n=t.read,i=t.write,r=t.events;"update"!==s&&!b(r,s)||(n&&!b(kn.reads,a[e])&&(a[e]=kn.read(function(){var t=o._connected&&n.call(o,o._data,s);!1===t&&i?kn.clear(h[e]):S(t)&&U(o._data,t)})),i&&!b(kn.writes,h[e])&&(h[e]=kn.write(function(){return o._connected&&i.call(o,o._data,s)})))})},Yn=0,(Rn=Ln).prototype._init=function(t){(t=t||{}).data=function(t,e){var n=t.data,i=(t.el,e.args),r=e.props;if(void 0===r&&(r={}),n=k(n)?B(i)?void 0:n.slice(0,i.length).reduce(function(t,e,n){return S(e)?U(t,e):t[i[n]]=e,t},{}):n)for(var o in n)P(n[o])?delete n[o]:n[o]=r[o]?ti(r[o],n[o]):n[o];return n}(t,this.constructor.options),this.$options=Mn(this.constructor.options,t,this),this.$el=null,this.$props={},this._frames={reads:{},writes:{}},this._events=[],this._uid=Yn++,this._initData(),this._initMethods(),this._initComputeds(),this._callHook("created"),t.el&&this.$mount(t.el)},Rn.prototype._initData=function(){var t=this.$options.data;for(var e in void 0===t&&(t={}),t)this.$props[e]=this[e]=t[e]},Rn.prototype._initMethods=function(){var t=this.$options.methods;if(t)for(var e in t)this[e]=t[e].bind(this)},Rn.prototype._initComputeds=function(){var t=this.$options.computed;if(this._computeds={},t)for(var e in t)Jn(this,e,t[e])},Rn.prototype._callWatches=function(){var t=this.$options.computed,e=this._computeds;for(var n in e){var i=e[n];delete e[n],t[n].watch&&!Y(i,this[n])&&t[n].watch.call(this,this[n],i)}},Rn.prototype._initProps=function(t){var e;for(e in t=t||Gn(this.$options,this.$name))P(t[e])||(this.$props[e]=t[e]);var n=[this.$options.computed,this.$options.methods];for(e in this.$props)e in t&&Qn(n,e)&&(this[e]=this.$props[e])},Rn.prototype._initEvents=function(){var n=this,t=this.$options.events;t&&t.forEach(function(t){if(c(t,"handler"))Zn(n,t);else for(var e in t)Zn(n,t[e],e)})},Rn.prototype._unbindEvents=function(){this._events.forEach(function(t){return t()}),this._events=[]},Rn.prototype._initObserver=function(){var n=this,t=this.$options,i=t.attrs,e=t.props,r=t.el;if(!this._observer&&e&&!1!==i){i=k(i)?i:Object.keys(e),this._observer=new MutationObserver(function(){var e=Gn(n.$options,n.$name);i.some(function(t){return!P(e[t])&&e[t]!==n.$props[t]})&&n.$reset()});var o=i.map(function(t){return d(t)}).concat(this.$name);this._observer.observe(r,{attributes:!0,attributeFilter:o.concat(o.map(function(t){return"data-"+t}))})}},Un=(qn=Ln).data,Xn={},qn.component=function(s,t){if(!t)return S(Xn[s])&&(Xn[s]=qn.extend(Xn[s])),Xn[s];qn[s]=function(t,n){for(var e=arguments.length,i=Array(e);e--;)i[e]=arguments[e];var r=qn.component(s);return S(t)?new r({data:t}):r.options.functional?new r({data:[].concat(i)}):t&&t.nodeType?o(t):Ee(t).map(o)[0];function o(t){var e=qn.getComponent(t,s);if(e){if(!n)return e;e.$destroy()}return new r({el:t,data:n})}};var e=S(t)?U({},t):t.options;if(e.name=s,e.install&&e.install(qn,e,s),qn._initialized&&!e.functional){var n=d(s);kn.read(function(){return qn[s]("[uk-"+n+"],[data-uk-"+n+"]")})}return Xn[s]=S(t)?e:t},qn.getComponents=function(t){return t&&t[Un]||{}},qn.getComponent=function(t,e){return qn.getComponents(t)[e]},qn.connect=function(t){if(t[Un])for(var e in t[Un])t[Un][e]._callConnected();for(var n=0;n<t.attributes.length;n++){var i=Hn(t.attributes[n].name);i&&i in Xn&&qn[i](t)}},qn.disconnect=function(t){for(var e in t[Un])t[Un][e]._callDisconnected()},function(i){var r=i.data;i.prototype.$mount=function(t){var e=this.$options.name;t[r]||(t[r]={}),t[r][e]||((t[r][e]=this).$el=this.$options.el=this.$options.el||t,Wt(t,document)&&this._callConnected())},i.prototype.$emit=function(t){this._callUpdate(t)},i.prototype.$reset=function(){this._callDisconnected(),this._callConnected()},i.prototype.$destroy=function(t){void 0===t&&(t=!1);var e=this.$options,n=e.el,i=e.name;n&&this._callDisconnected(),this._callHook("destroy"),n&&n[r]&&(delete n[r][i],B(n[r])||delete n[r],t&&we(this.$el))},i.prototype.$create=function(t,e,n){return i[t](e,n)},i.prototype.$update=i.update,i.prototype.$getComponent=i.getComponent;var e={};Object.defineProperties(i.prototype,{$container:Object.getOwnPropertyDescriptor(i,"container"),$name:{get:function(){var t=this.$options.name;return e[t]||(e[t]=i.prefix+d(t)),e[t]}}})}(Ln);var ei={connected:function(){Oe(this.$el,this.$name)||Ae(this.$el,this.$name)}},ni={props:{cls:Boolean,animation:"list",duration:Number,origin:String,transition:String,queued:Boolean},data:{cls:!1,animation:[!1],duration:200,origin:!1,transition:"linear",queued:!1,initProps:{overflow:"",height:"",paddingTop:"",paddingBottom:"",marginTop:"",marginBottom:""},hideProps:{overflow:"hidden",height:0,paddingTop:0,paddingBottom:0,marginTop:0,marginBottom:0}},computed:{hasAnimation:function(t){return!!t.animation[0]},hasTransition:function(t){var e=t.animation;return this.hasAnimation&&!0===e[0]}},methods:{toggleElement:function(c,u,l){var d=this;return new ne(function(t){c=W(c);function e(t){return ne.all(t.map(function(t){return d._toggleElement(t,u,l)}))}var n,i=c.filter(function(t){return d.isToggled(t)}),r=c.filter(function(t){return!b(i,t)});if(d.queued&&P(l)&&P(u)&&d.hasAnimation&&!(c.length<2)){var o=document.body,s=o.scrollTop,a=i[0],h=Qe.inProgress(a)&&Oe(a,"uk-animation-leave")||Xe.inProgress(a)&&"0px"===a.style.height;n=e(i),h||(n=n.then(function(){var t=e(r);return o.scrollTop=s,t}))}else n=e(r.concat(i));n.then(t,Q)})},toggleNow:function(e,n){var i=this;return new ne(function(t){return ne.all(W(e).map(function(t){return i._toggleElement(t,n,!1)})).then(t,Q)})},isToggled:function(t){var e=W(t||this.$el);return this.cls?Oe(e,this.cls.split(" ")[0]):!rt(e,"hidden")},updateAria:function(t){!1===this.cls&&it(t,"aria-hidden",!this.isToggled(t))},_toggleElement:function(t,e,n){var i=this;if(e=M(e)?e:Qe.inProgress(t)?Oe(t,"uk-animation-leave"):Xe.inProgress(t)?"0px"===t.style.height:!this.isToggled(t),!qt(t,"before"+(e?"show":"hide"),[this]))return ne.reject();var r=($(n)?n:!1!==n&&this.hasAnimation?this.hasTransition?function(t){var s=t.isToggled,a=t.duration,h=t.initProps,c=t.hideProps,u=t.transition,l=t._toggle;return function(t,e){var n=Xe.inProgress(t),i=t.hasChildNodes?F(Le(t.firstElementChild,"marginTop"))+F(Le(t.lastElementChild,"marginBottom")):0,r=Ht(t)?sn(t)+(n?0:i):0;Xe.cancel(t),s(t)||l(t,!0),sn(t,""),kn.flush();var o=sn(t)+(n?0:i);return sn(t,r),(e?Xe.start(t,U({},h,{overflow:"hidden",height:o}),Math.round(a*(1-r/o)),u):Xe.start(t,c,Math.round(a*(r/o)),u).then(function(){return l(t,!1)})).then(function(){return Le(t,h)})}}(this):function(t){var n=t.animation,i=t.duration,r=t.origin,o=t._toggle;return function(t,e){return Qe.cancel(t),e?(o(t,!0),Qe.in(t,n[0],i,r)):Qe.out(t,n[1]||n[0],i,r).then(function(){return o(t,!1)})}}(this):this._toggle)(t,e);qt(t,e?"show":"hide",[this]);function o(){qt(t,e?"shown":"hidden",[i]),i.$update(t)}return r?r.then(o):ne.resolve(o())},_toggle:function(t,e){var n;t&&(e=Boolean(e),this.cls?(n=b(this.cls," ")||e!==Oe(t,this.cls))&&De(t,this.cls,b(this.cls," ")?void 0:e):(n=e===rt(t,"hidden"))&&it(t,"hidden",e?null:""),Ee("[autofocus]",t).some(function(t){return Ht(t)?t.focus()||!0:t.blur()}),this.updateAria(t),n&&this.$update(t))}}};var ii={mixins:[ei,ni],props:{targets:String,active:null,collapsible:Boolean,multiple:Boolean,toggle:String,content:String,transition:String},data:{targets:"> *",active:!1,animation:[!0],collapsible:!0,multiple:!1,clsOpen:"uk-open",toggle:"> .uk-accordion-title",content:"> .uk-accordion-content",transition:"ease"},computed:{items:function(t,e){return Ee(t.targets,e)}},events:[{name:"click",delegate:function(){return this.targets+" "+this.$props.toggle},handler:function(t){t.preventDefault(),this.toggle(ue(Ee(this.targets+" "+this.$props.toggle,this.$el),t.current))}}],connected:function(){if(!1!==this.active){var t=this.items[Number(this.active)];t&&!Oe(t,this.clsOpen)&&this.toggle(t,!1)}},update:function(){var e=this;this.items.forEach(function(t){return e._toggle(Te(e.content,t),Oe(t,e.clsOpen))});var t=!this.collapsible&&!Oe(this.items,this.clsOpen)&&this.items[0];t&&this.toggle(t,!1)},methods:{toggle:function(r,o){var s=this,t=le(r,this.items),a=jt(this.items,"."+this.clsOpen);(r=this.items[t])&&[r].concat(!this.multiple&&!b(a,r)&&a||[]).forEach(function(t){var e=t===r,n=e&&!Oe(t,s.clsOpen);if(n||!e||s.collapsible||!(a.length<2)){De(t,s.clsOpen,n);var i=t._wrapper?t._wrapper.firstElementChild:Te(s.content,t);t._wrapper||(t._wrapper=be(i,"<div>"),it(t._wrapper,"hidden",n?"":null)),s._toggle(i,!0),s.toggleElement(t._wrapper,n,o).then(function(){Oe(t,s.clsOpen)===n&&(n||s._toggle(i,!1),t._wrapper=null,xe(i))})}})}}},ri={mixins:[ei,ni],args:"animation",props:{close:String},data:{animation:[!0],selClose:".uk-alert-close",duration:150,hideProps:U({opacity:0},ni.data.hideProps)},events:[{name:"click",delegate:function(){return this.selClose},handler:function(t){t.preventDefault(),this.close()}}],methods:{close:function(){var t=this;this.toggleElement(this.$el).then(function(){return t.$destroy(!0)})}}};function oi(r){ce(function(){var n;r.update(),Vt(window,"load resize",function(){return r.update(null,"resize")}),Vt(document,"loadedmetadata load",function(t){var e=t.target;return r.update(e,"resize")},!0),Vt(window,"scroll",function(t){if(!n){n=!0,kn.write(function(){return n=!1});var e=t.target;r.update(1!==e.nodeType?document.body:e,t.type)}},{passive:!0,capture:!0});var e,i=0;Vt(document,"animationstart",function(t){var e=t.target;(Le(e,"animationName")||"").match(/^uk-.*(left|right)/)&&(i++,Le(document.body,"overflowX","hidden"),setTimeout(function(){--i||Le(document.body,"overflowX","")},R(Le(e,"animationDuration"))+100))},!0),Vt(document,dt,function(t){if(e&&e(),Qt(t)){var r=te(t),o="tagName"in t.target?t.target:t.target.parentNode;e=Yt(document,pt+" "+vt,function(t){var e=te(t),n=e.x,i=e.y;(o&&n&&100<Math.abs(r.x-n)||i&&100<Math.abs(r.y-i))&&setTimeout(function(){qt(o,"swipe"),qt(o,"swipe"+function(t,e,n,i){return Math.abs(t-n)>=Math.abs(e-i)?0<t-n?"Left":"Right":0<e-i?"Up":"Down"}(r.x,r.y,n,i))})}),"touchstart"===dt&&(Le(document.body,"cursor","pointer"),Yt(document,pt+" "+vt,function(){return setTimeout(function(){return Le(document.body,"cursor","")},50)}))}},{passive:!0})})}var si,ai={args:"autoplay",props:{automute:Boolean,autoplay:Boolean},data:{automute:!1,autoplay:!0},computed:{inView:function(t){return"inview"===t.autoplay}},connected:function(){this.inView&&!rt(this.$el,"preload")&&(this.$el.preload="none"),this.player=new Dn(this.$el),this.automute&&this.player.mute()},update:{read:function(){return!!this.player&&{visible:Ht(this.$el)&&"hidden"!==Le(this.$el,"visibility"),inView:this.inView&&pn(this.$el)}},write:function(t){var e=t.visible,n=t.inView;!e||this.inView&&!n?this.player.pause():(!0===this.autoplay||this.inView&&n)&&this.player.play()},events:["resize","scroll"]}},hi={mixins:[ei,ai],props:{width:Number,height:Number},data:{automute:!0},update:{read:function(){var t=this.$el,e=t.parentNode,n=e.offsetHeight,i=e.offsetWidth,r=nt.cover({width:this.width||t.naturalWidth||t.videoWidth||t.clientWidth,height:this.height||t.naturalHeight||t.videoHeight||t.clientHeight},{width:i+(i%2?1:0),height:n+(n%2?1:0)});return!(!r.width||!r.height)&&r},write:function(t){var e=t.height,n=t.width;Le(this.$el,{height:e,width:n})},events:["resize"]}},ci={props:{pos:String,offset:null,flip:Boolean,clsPos:String},data:{pos:"bottom-"+(ht?"right":"left"),flip:!0,offset:!1,clsPos:""},computed:{pos:function(t){var e=t.pos;return(e+(b(e,"-")?"":"-center")).split("-")},dir:function(){return this.pos[0]},align:function(){return this.pos[1]}},methods:{positionAt:function(t,e,n){var i;Ne(t,this.clsPos+"-(top|bottom|left|right)(-[a-z]+)?"),Le(t,{top:"",left:""});var r=this.offset,o=this.getAxis();z(r)||(r=(i=Te(r))?nn(i)["x"===o?"left":"top"]-nn(e)["x"===o?"right":"bottom"]:0);var s=en(t,e,"x"===o?fn(this.dir)+" "+this.align:this.align+" "+fn(this.dir),"x"===o?this.dir+" "+this.align:this.align+" "+this.dir,"x"===o?""+("left"===this.dir?-r:r):" "+("top"===this.dir?-r:r),null,this.flip,n).target,a=s.x,h=s.y;this.dir="x"===o?a:h,this.align="x"===o?h:a,De(t,this.clsPos+"-"+this.dir+"-"+this.align,!1===this.offset)},getAxis:function(){return"top"===this.dir||"bottom"===this.dir?"y":"x"}}},ui={mixins:[ci,ni],args:"pos",props:{mode:"list",toggle:Boolean,boundary:Boolean,boundaryAlign:Boolean,delayShow:Number,delayHide:Number,clsDrop:String},data:{mode:["click","hover"],toggle:"- *",boundary:window,boundaryAlign:!1,delayShow:0,delayHide:800,clsDrop:!1,hoverIdle:200,animation:["uk-animation-fade"],cls:"uk-open"},computed:{boundary:function(t,e){return wt(t.boundary,e)},clsDrop:function(t){return t.clsDrop||"uk-"+this.$options.name},clsPos:function(){return this.clsDrop}},created:function(){this.tracker=new En},connected:function(){Ae(this.$el,this.clsDrop);var t=this.$props.toggle;this.toggle=t&&this.$create("toggle",wt(t,this.$el),{target:this.$el,mode:this.mode}),this.toggle||qt(this.$el,"updatearia")},events:[{name:"click",delegate:function(){return"."+this.clsDrop+"-close"},handler:function(t){t.preventDefault(),this.hide(!1)}},{name:"click",delegate:function(){return'a[href^="#"]'},handler:function(t){var e=t.defaultPrevented,n=t.current.hash;e||!n||Wt(n,this.$el)||this.hide(!1)}},{name:"beforescroll",handler:function(){this.hide(!1)}},{name:"toggle",self:!0,handler:function(t,e){t.preventDefault(),this.isToggled()?this.hide(!1):this.show(e,!1)}},{name:mt,filter:function(){return b(this.mode,"hover")},handler:function(t){Qt(t)||(si&&si!==this&&si.toggle&&b(si.toggle.mode,"hover")&&!Wt(t.target,si.toggle.$el)&&!et({x:t.pageX,y:t.pageY},nn(si.$el))&&si.hide(!1),t.preventDefault(),this.show(this.toggle))}},{name:"toggleshow",handler:function(t,e){e&&!b(e.target,this.$el)||(t.preventDefault(),this.show(e||this.toggle))}},{name:"togglehide "+gt,handler:function(t,e){Qt(t)||e&&!b(e.target,this.$el)||(t.preventDefault(),this.toggle&&b(this.toggle.mode,"hover")&&this.hide())}},{name:"beforeshow",self:!0,handler:function(){this.clearTimers(),Qe.cancel(this.$el),this.position()}},{name:"show",self:!0,handler:function(){var i=this;this.tracker.init(),qt(this.$el,"updatearia");var t=li(document,"click",function(t){var e=t.defaultPrevented,n=t.target;e||Wt(n,i.$el)||i.toggle&&Wt(n,i.toggle.$el)||i.hide(!1)});Yt(this.$el,"hide",t,{self:!0})}},{name:"beforehide",self:!0,handler:function(){this.clearTimers()}},{name:"hide",handler:function(t){var e=t.target;this.$el===e?(si=this.isActive()?null:si,qt(this.$el,"updatearia"),this.tracker.cancel()):si=null===si&&Wt(e,this.$el)&&this.isToggled()?this:si}},{name:"updatearia",self:!0,handler:function(t,e){t.preventDefault(),this.updateAria(this.$el),(e||this.toggle)&&(it((e||this.toggle).$el,"aria-expanded",this.isToggled()),De(this.toggle.$el,this.cls,this.isToggled()))}}],update:{write:function(){this.isToggled()&&!Qe.inProgress(this.$el)&&this.position()},events:["resize"]},methods:{show:function(e,n){var i=this;void 0===n&&(n=!0);function r(){return!i.isToggled()&&i.toggleElement(i.$el,!0)}function t(){if(i.toggle=e||i.toggle,i.clearTimers(),!i.isActive())if(n&&si&&si!==i&&si.isDelaying)i.showTimer=setTimeout(i.show,10);else{if(i.isParentOf(si)){if(!si.hideTimer)return;si.hide(!1)}else if(i.isChildOf(si))si.clearTimers();else if(si&&!i.isChildOf(si)&&!i.isParentOf(si))for(var t;si&&si!==t&&!i.isChildOf(si);)(t=si).hide(!1);n&&i.delayShow?i.showTimer=setTimeout(r,i.delayShow):r(),si=i}}e&&this.toggle&&e.$el!==this.toggle.$el?(Yt(this.$el,"hide",t),this.hide(!1)):t()},hide:function(t){var e=this;void 0===t&&(t=!0);function n(){return e.toggleNow(e.$el,!1)}this.clearTimers(),this.isDelaying=this.tracker.movesTo(this.$el),t&&this.isDelaying?this.hideTimer=setTimeout(this.hide,this.hoverIdle):t&&this.delayHide?this.hideTimer=setTimeout(n,this.delayHide):n()},clearTimers:function(){clearTimeout(this.showTimer),clearTimeout(this.hideTimer),this.showTimer=null,this.hideTimer=null,this.isDelaying=!1},isActive:function(){return si===this},isChildOf:function(t){return t&&t!==this&&Wt(this.$el,t.$el)},isParentOf:function(t){return t&&t!==this&&Wt(t.$el,this.$el)},position:function(){Ne(this.$el,this.clsDrop+"-(stack|boundary)"),Le(this.$el,{top:"",left:"",display:"block"}),De(this.$el,this.clsDrop+"-boundary",this.boundaryAlign);var t=nn(this.boundary),e=this.boundaryAlign?t:nn(this.toggle.$el);if("justify"===this.align){var n="y"===this.getAxis()?"width":"height";Le(this.$el,n,e[n])}else this.$el.offsetWidth>Math.max(t.right-e.left,e.right-t.left)&&Ae(this.$el,this.clsDrop+"-stack");this.positionAt(this.$el,this.boundaryAlign?this.boundary:this.toggle.$el,this.boundary),Le(this.$el,"display","")}}};function li(t,e,n){var i=Yt(t,e,function(){return i=Vt(t,e,n)},!0);return function(){return i()}}var di={extends:ui},fi={mixins:[ei],args:"target",props:{target:Boolean},data:{target:!1},computed:{input:function(t,e){return Te(Lt,e)},state:function(){return this.input.nextElementSibling},target:function(t,e){var n=t.target;return n&&(!0===n&&this.input.parentNode===e&&this.input.nextElementSibling||wt(n,e))}},update:function(){var t=this.target,e=this.input;if(t){var n,i=Ft(t)?"value":"textContent",r=t[i],o=e.files&&e.files[0]?e.files[0].name:_t(e,"select")&&(n=Ee("option",e).filter(function(t){return t.selected})[0])?n.textContent:e.value;r!==o&&(t[i]=o)}},events:[{name:"change",handler:function(){this.$emit()}},{name:"reset",el:function(){return Mt(this.$el,"form")},handler:function(){this.$emit()}}]},pi={update:{read:function(t){var e=pn(this.$el);if(!e||t.isInView===e)return!1;t.isInView=e},write:function(){this.$el.src=this.$el.src},events:["scroll","resize"]}},mi={props:{margin:String,firstColumn:Boolean},data:{margin:"uk-margin-small-top",firstColumn:"uk-first-column"},update:{read:function(t){var e=this.$el.children;if(!e.length||!Ht(this.$el))return t.rows=[[]];t.rows=gi(e),t.stacks=!t.rows.some(function(t){return 1<t.length})},write:function(t){var i=this;t.rows.forEach(function(t,n){return t.forEach(function(t,e){De(t,i.margin,0!==n),De(t,i.firstColumn,0===e)})})},events:["resize"]}};function gi(t){for(var e=[[]],n=0;n<t.length;n++){var i=t[n],r=vi(i);if(r.height)for(var o=e.length-1;0<=o;o--){var s=e[o];if(!s[0]){s.push(i);break}var a=void 0;if(a=s[0].offsetParent===i.offsetParent?vi(s[0]):(r=vi(i,!0),vi(s[0],!0)),r.top>=a.bottom-1&&r.top!==a.top){e.push([i]);break}if(r.bottom>a.top){if(r.left<a.left&&!ht){s.unshift(i);break}s.push(i);break}if(0===o){e.unshift([i]);break}}}return e}function vi(t,e){var n;void 0===e&&(e=!1);var i=t.offsetTop,r=t.offsetLeft,o=t.offsetHeight;return e&&(i=(n=vn(t))[0],r=n[1]),{top:i,left:r,height:o,bottom:i+o}}var wi={extends:mi,mixins:[ei],name:"grid",props:{masonry:Boolean,parallax:Number},data:{margin:"uk-grid-margin",clsStack:"uk-grid-stack",masonry:!1,parallax:0},computed:{length:function(t,e){return e.children.length},parallax:function(t){var e=t.parallax;return e&&this.length?Math.abs(e):""}},connected:function(){this.masonry&&Ae(this.$el,"uk-flex-top uk-flex-wrap-top")},update:[{read:function(t){var r=t.rows;(this.masonry||this.parallax)&&(r=r.map(function(t){return G(t,"offsetLeft")}),ht&&r.map(function(t){return t.reverse()}));var e=r.some(function(t){return t.some(Xe.inProgress)}),n=!1,i="";if(this.masonry&&this.length){var o=0;n=r.reduce(function(n,t,i){return n[i]=t.map(function(t,e){return 0===i?0:F(n[i-1][e])+(o-F(r[i-1][e]&&r[i-1][e].offsetHeight))}),o=t.reduce(function(t,e){return Math.max(t,e.offsetHeight)},0),n},[]),i=function(t){return Math.max.apply(Math,t.reduce(function(n,t){return t.forEach(function(t,e){return n[e]=(n[e]||0)+t.offsetHeight}),n},[]))}(r)+function(t,e){var n=W(t.children),i=n.filter(function(t){return Oe(t,e)})[0];return F(i?Le(i,"marginTop"):Le(n[0],"paddingLeft"))}(this.$el,this.margin)*(r.length-1)}return{padding:this.parallax&&function(t,e,n){for(var i=0,r=0,o=0,s=e.length-1;0<=s;s--)for(var a=i;a<e[s].length;a++){var h=e[s][a],c=h.offsetTop+sn(h)+(n&&-n[s][a]);r=Math.max(r,c),o=Math.max(o,c+(a%2?t:t/8)),i++}return o-r}(this.parallax,r,n),rows:r,translates:n,height:!e&&i}},write:function(t){var e=t.stacks,n=t.height,i=t.padding;De(this.$el,this.clsStack,e),Le(this.$el,"paddingBottom",i),!1!==n&&Le(this.$el,"height",n)},events:["resize"]},{read:function(t){var e=t.height;return{scrolled:!!this.parallax&&mn(this.$el,e?e-sn(this.$el):0)*this.parallax}},write:function(t){var e=t.rows,i=t.scrolled,r=t.translates;!1===i&&!r||e.forEach(function(t,n){return t.forEach(function(t,e){return Le(t,"transform",i||r?"translateY("+((r&&-r[n][e])+(i?e%2?i:i/8:0))+"px)":"")})})},events:["scroll","resize"]}]};var bi=at?{props:{selMinHeight:String},data:{selMinHeight:!1,forceHeight:!1},computed:{elements:function(t,e){var n=t.selMinHeight;return n?Ee(n,e):[e]}},update:[{read:function(){Le(this.elements,"height","")},order:-5,events:["resize"]},{write:function(){var n=this;this.elements.forEach(function(t){var e=F(Le(t,"minHeight"));e&&(n.forceHeight||Math.round(e+cn("height",t,"content-box"))>=t.offsetHeight)&&Le(t,"height",e)})},order:5,events:["resize"]}]}:{},yi={mixins:[bi],args:"target",props:{target:String,row:Boolean},data:{target:"> *",row:!0,forceHeight:!0},computed:{elements:function(t,e){return Ee(t.target,e)}},update:{read:function(){return{rows:(this.row?gi(this.elements):[this.elements]).map(xi)}},write:function(t){t.rows.forEach(function(t){var n=t.heights;return t.elements.forEach(function(t,e){return Le(t,"minHeight",n[e])})})},events:["resize"]}};function xi(t){var e;if(t.length<2)return{heights:[""],elements:t};var n=ki(t),i=n.heights,r=n.max,o=t.some(function(t){return t.style.minHeight}),s=t.some(function(t,e){return!t.style.minHeight&&i[e]<r});return o&&s&&(Le(t,"minHeight",""),e=ki(t),i=e.heights,r=e.max),{heights:i=t.map(function(t,e){return i[e]===r&&F(t.style.minHeight).toFixed(2)!==r.toFixed(2)?"":r}),elements:t}}function ki(t){var e=t.map(function(t){return nn(t).height-cn("height",t,"content-box")});return{heights:e,max:Math.max.apply(null,e)}}var $i={mixins:[bi],props:{expand:Boolean,offsetTop:Boolean,offsetBottom:Boolean,minHeight:Number},data:{expand:!1,offsetTop:!1,offsetBottom:!1,minHeight:0},update:{read:function(t){var e=t.minHeight;if(!Ht(this.$el))return!1;var n="",i=cn("height",this.$el,"content-box");if(this.expand){if(this.$el.dataset.heightExpand="",Te("[data-height-expand]")!==this.$el)return!1;n=sn(window)-(Ii(document.documentElement)-Ii(this.$el))-i||""}else{if(n="calc(100vh",this.offsetTop){var r=nn(this.$el).top;n+=0<r&&r<sn(window)/2?" - "+r+"px":""}!0===this.offsetBottom?n+=" - "+Ii(this.$el.nextElementSibling)+"px":z(this.offsetBottom)?n+=" - "+this.offsetBottom+"vh":this.offsetBottom&&u(this.offsetBottom,"px")?n+=" - "+F(this.offsetBottom)+"px":O(this.offsetBottom)&&(n+=" - "+Ii(wt(this.offsetBottom,this.$el))+"px"),n+=(i?" - "+i+"px":"")+")"}return{minHeight:n,prev:e}},write:function(t){var e=t.minHeight,n=t.prev;Le(this.$el,{minHeight:e}),e!==n&&this.$update(this.$el,"resize"),this.minHeight&&F(Le(this.$el,"minHeight"))<this.minHeight&&Le(this.$el,"minHeight",this.minHeight)},events:["resize"]}};function Ii(t){return t&&nn(t).height||0}var Si={args:"src",props:{id:Boolean,icon:String,src:String,style:String,width:Number,height:Number,ratio:Number,class:String,strokeAnimation:Boolean,focusable:Boolean,attributes:"list"},data:{ratio:1,include:["style","class","focusable"],class:"",strokeAnimation:!1},beforeConnect:function(){var t,e=this;if(this.class+=" uk-svg",!this.icon&&b(this.src,"#")){var n=this.src.split("#");1<n.length&&(t=n,this.src=t[0],this.icon=t[1])}this.svg=this.getSvg().then(function(t){return e.applyAttributes(t),e.svgEl=function(t,e){{if(Pt(e)||"CANVAS"===e.tagName){it(e,"hidden",!0);var n=e.nextElementSibling;return _i(t,n)?n:ge(e,t)}var i=e.lastElementChild;return _i(t,i)?i:pe(e,t)}}(t,e.$el)},Q)},disconnected:function(){var e=this;Pt(this.$el)&&it(this.$el,"hidden",null),this.svg&&this.svg.then(function(t){return(!e._connected||t!==e.svgEl)&&we(t)},Q),this.svg=this.svgEl=null},update:{read:function(){return!!(this.strokeAnimation&&this.svgEl&&Ht(this.svgEl))},write:function(){!function(t){var e=Ai(t);e&&t.style.setProperty("--uk-animation-stroke",e)}(this.svgEl)},type:["resize"]},methods:{getSvg:function(){var e=this;return function(n){if(Ti[n])return Ti[n];return Ti[n]=new ne(function(e,t){n?w(n,"data:")?e(decodeURIComponent(n.split(",")[1])):ae(n).then(function(t){return e(t.response)},function(){return t("SVG not found.")}):t()})}(this.src).then(function(t){return function(t,e){e&&b(t,"<symbol")&&(t=function(t,e){if(!Ci[t]){var n;for(Ci[t]={};n=Ei.exec(t);)Ci[t][n[3]]='<svg xmlns="http://www.w3.org/2000/svg"'+n[1]+"svg>";Ei.lastIndex=0}return Ci[t][e]}(t,e)||t);return(t=Te(t.substr(t.indexOf("<svg"))))&&t.hasChildNodes()&&t}(t,e.icon)||ne.reject("SVG not found.")})},applyAttributes:function(n){var i=this;for(var t in this.$options.props)this[t]&&b(this.include,t)&&it(n,t,this[t]);for(var e in this.attributes){var r=this.attributes[e].split(":",2),o=r[0],s=r[1];it(n,o,s)}this.id||ot(n,"id");var a=["width","height"],h=[this.width,this.height];h.some(function(t){return t})||(h=a.map(function(t){return it(n,t)}));var c=it(n,"viewBox");c&&!h.some(function(t){return t})&&(h=c.split(" ").slice(2)),h.forEach(function(t,e){(t=(0|t)*i.ratio)&&it(n,a[e],t),t&&!h[1^e]&&ot(n,a[1^e])}),it(n,"data-svg",this.icon||this.src)}}},Ti={};var Ei=/<symbol(.*?id=(['"])(.*?)\2[^]*?<\/)symbol>/g,Ci={};function Ai(t){return Math.ceil(Math.max.apply(Math,Ee("[stroke]",t).map(function(t){return t.getTotalLength&&t.getTotalLength()||0}).concat([0])))}function _i(t,e){return it(t,"data-svg")===it(e,"data-svg")}var Ni={},Mi={spinner:'<svg width="30" height="30" viewBox="0 0 30 30" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" cx="15" cy="15" r="14"/></svg>',totop:'<svg width="18" height="10" viewBox="0 0 18 10" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.2" points="1 9 9 1 17 9 "/></svg>',marker:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="9" y="4" width="1" height="11"/><rect x="4" y="9" width="11" height="1"/></svg>',"close-icon":'<svg width="14" height="14" viewBox="0 0 14 14" xmlns="http://www.w3.org/2000/svg"><line fill="none" stroke="#000" stroke-width="1.1" x1="1" y1="1" x2="13" y2="13"/><line fill="none" stroke="#000" stroke-width="1.1" x1="13" y1="1" x2="1" y2="13"/></svg>',"close-large":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><line fill="none" stroke="#000" stroke-width="1.4" x1="1" y1="1" x2="19" y2="19"/><line fill="none" stroke="#000" stroke-width="1.4" x1="19" y1="1" x2="1" y2="19"/></svg>',"navbar-toggle-icon":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect y="9" width="20" height="2"/><rect y="3" width="20" height="2"/><rect y="15" width="20" height="2"/></svg>',"overlay-icon":'<svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg"><rect x="19" y="0" width="1" height="40"/><rect x="0" y="19" width="40" height="1"/></svg>',"pagination-next":'<svg width="7" height="12" viewBox="0 0 7 12" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.2" points="1 1 6 6 1 11"/></svg>',"pagination-previous":'<svg width="7" height="12" viewBox="0 0 7 12" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.2" points="6 1 1 6 6 11"/></svg>',"search-icon":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="9" cy="9" r="7"/><path fill="none" stroke="#000" stroke-width="1.1" d="M14,14 L18,18 L14,14 Z"/></svg>',"search-large":'<svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.8" cx="17.5" cy="17.5" r="16.5"/><line fill="none" stroke="#000" stroke-width="1.8" x1="38" y1="39" x2="29" y2="30"/></svg>',"search-navbar":'<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="10.5" cy="10.5" r="9.5"/><line fill="none" stroke="#000" stroke-width="1.1" x1="23" y1="23" x2="17" y2="17"/></svg>',"slidenav-next":'<svg width="14px" height="24px" viewBox="0 0 14 24" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.4" points="1.225,23 12.775,12 1.225,1 "/></svg>',"slidenav-next-large":'<svg width="25px" height="40px" viewBox="0 0 25 40" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="2" points="4.002,38.547 22.527,20.024 4,1.5 "/></svg>',"slidenav-previous":'<svg width="14px" height="24px" viewBox="0 0 14 24" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.4" points="12.775,1 1.225,12 12.775,23 "/></svg>',"slidenav-previous-large":'<svg width="25px" height="40px" viewBox="0 0 25 40" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="2" points="20.527,1.5 2,20.024 20.525,38.547 "/></svg>'},Oi={install:function(r){r.icon.add=function(t,e){var n,i=O(t)?((n={})[t]=e,n):t;K(i,function(t,e){Mi[e]=t,delete Ni[e]}),r._initialized&&Se(document.body,function(t){return K(r.getComponents(t),function(t){t.$options.isIcon&&t.icon in i&&t.$reset()})})}},extends:Si,args:"icon",props:["icon"],data:{include:["focusable"]},isIcon:!0,beforeConnect:function(){Ae(this.$el,"uk-icon")},methods:{getSvg:function(){var t=function(t){if(!Mi[t])return null;Ni[t]||(Ni[t]=Te(Mi[t].trim()));return Ni[t].cloneNode(!0)}(function(t){return ht?q(q(t,"left","right"),"previous","next"):t}(this.icon));return t?ne.resolve(t):ne.reject("Icon not found.")}}},Di={args:!1,extends:Oi,data:function(t){return{icon:d(t.constructor.options.name)}},beforeConnect:function(){Ae(this.$el,this.$name)}},zi={extends:Di,beforeConnect:function(){Ae(this.$el,"uk-slidenav")},computed:{icon:function(t,e){var n=t.icon;return Oe(e,"uk-slidenav-large")?n+"-large":n}}},Bi={extends:Di,computed:{icon:function(t,e){var n=t.icon;return Oe(e,"uk-search-icon")&&Ot(e,".uk-search-large").length?"search-large":Ot(e,".uk-search-navbar").length?"search-navbar":n}}},Pi={extends:Di,computed:{icon:function(){return"close-"+(Oe(this.$el,"uk-close-large")?"large":"icon")}}},Hi={extends:Di,connected:function(){var e=this;this.svg.then(function(t){return 1!==e.ratio&&Le(Te("circle",t),"strokeWidth",1/e.ratio)},Q)}};var Li={args:"dataSrc",props:{dataSrc:String,dataSrcset:Boolean,sizes:String,width:Number,height:Number,offsetTop:String,offsetLeft:String,target:String},data:{dataSrc:"",dataSrcset:!1,sizes:!1,width:!1,height:!1,offsetTop:"50vh",offsetLeft:0,target:!1},computed:{cacheKey:function(t){var e=t.dataSrc;return this.$name+"."+e},width:function(t){var e=t.width,n=t.dataWidth;return e||n},height:function(t){var e=t.height,n=t.dataHeight;return e||n},sizes:function(t){var e=t.sizes,n=t.dataSizes;return e||n},isImg:function(t,e){return qi(e)},target:{get:function(t){var e=t.target;return[this.$el].concat(bt(e,this.$el))},watch:function(){this.observe()}},offsetTop:function(t){return wn(t.offsetTop,"height")},offsetLeft:function(t){return wn(t.offsetLeft,"width")}},connected:function(){Xi[this.cacheKey]?Fi(this.$el,Xi[this.cacheKey]||this.dataSrc,this.dataSrcset,this.sizes):this.isImg&&this.width&&this.height&&Fi(this.$el,function(t,e,n){var i;n&&(i=nt.ratio({width:t,height:e},"width",wn(Wi(n))),t=i.width,e=i.height);return'data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="'+t+'" height="'+e+'"></svg>'}(this.width,this.height,this.sizes)),this.observer=new Pn(this.load,{rootMargin:this.offsetTop+"px "+this.offsetLeft+"px"}),requestAnimationFrame(this.observe)},disconnected:function(){this.observer.disconnect()},update:{read:function(t){var e=this,n=t.image;if(n||"complete"!==document.readyState||this.load(this.observer.takeRecords()),this.isImg)return!1;n&&n.then(function(t){return t&&""!==t.currentSrc&&Fi(e.$el,Ui(t))})},write:function(t){if(this.dataSrcset&&1!==window.devicePixelRatio){var e=Le(this.$el,"backgroundSize");!e.match(/^(auto\s?)+$/)&&F(e)!==t.bgSize||(t.bgSize=function(t,e){var n=wn(Wi(e)),i=(t.match(Yi)||[]).map(F).sort(function(t,e){return t-e});return i.filter(function(t){return n<=t})[0]||i.pop()||""}(this.dataSrcset,this.sizes),Le(this.$el,"backgroundSize",t.bgSize+"px"))}},events:["resize"]},methods:{load:function(t){var e=this;t.some(function(t){return P(t.isIntersecting)||t.isIntersecting})&&(this._data.image=he(this.dataSrc,this.dataSrcset,this.sizes).then(function(t){return Fi(e.$el,Ui(t),t.srcset,t.sizes),Xi[e.cacheKey]=Ui(t),t},Q),this.observer.disconnect())},observe:function(){var e=this;!this._data.image&&this._connected&&this.target.forEach(function(t){return e.observer.observe(t)})}}};function Fi(t,e,n,i){if(qi(t))i&&(t.sizes=i),n&&(t.srcset=n),e&&(t.src=e);else if(e){!b(t.style.backgroundImage,e)&&(Le(t,"backgroundImage","url("+zt(e)+")"),qt(t,Ut("load",!1)))}}var ji=/\s*(.*?)\s*(\w+|calc\(.*?\))\s*(?:,|$)/g;function Wi(t){var e,n;for(ji.lastIndex=0;e=ji.exec(t);)if(!e[1]||window.matchMedia(e[1]).matches){e=w(n=e[2],"calc")?n.substring(5,n.length-1).replace(Vi,function(t){return wn(t)}).replace(/ /g,"").match(Ri).reduce(function(t,e){return t+ +e},0):n;break}return e||"100vw"}var Vi=/\d+(?:\w+|%)/g,Ri=/[+-]?(\d+)/g;var Yi=/\s+\d+w\s*(?:,|$)/g;function qi(t){return"IMG"===t.tagName}function Ui(t){return t.currentSrc||t.src}var Xi,Ki="__test__";try{(Xi=window.sessionStorage||{})[Ki]=1,delete Xi[Ki]}catch(t){Xi={}}var Gi={props:{media:Boolean},data:{media:!1},computed:{matchMedia:function(){var t=function(t){if(O(t)){if("@"===t[0])t=F(Ve("breakpoint-"+t.substr(1)));else if(isNaN(t))return t}return!(!t||isNaN(t))&&"(min-width: "+t+"px)"}(this.media);return!t||window.matchMedia(t).matches}}};var Ji={mixins:[ei,Gi],props:{fill:String},data:{fill:"",clsWrapper:"uk-leader-fill",clsHide:"uk-leader-hide",attrFill:"data-fill"},computed:{fill:function(t){return t.fill||Ve("leader-fill-content")}},connected:function(){var t;t=ye(this.$el,'<span class="'+this.clsWrapper+'">'),this.wrapper=t[0]},disconnected:function(){xe(this.wrapper.childNodes)},update:{read:function(t){var e=t.changed,n=t.width,i=n;return{width:n=Math.floor(this.$el.offsetWidth/2),fill:this.fill,changed:e||i!==n,hide:!this.matchMedia}},write:function(t){De(this.wrapper,this.clsHide,t.hide),t.changed&&(t.changed=!1,it(this.wrapper,this.attrFill,new Array(t.width).join(t.fill)))},events:["resize"]}},Zi={props:{container:Boolean},data:{container:!0},computed:{container:function(t){var e=t.container;return!0===e&&this.$container||e&&Te(e)}}},Qi=[],tr={mixins:[ei,Zi,ni],props:{selPanel:String,selClose:String,escClose:Boolean,bgClose:Boolean,stack:Boolean},data:{cls:"uk-open",escClose:!0,bgClose:!0,overlay:!0,stack:!1},computed:{panel:function(t,e){return Te(t.selPanel,e)},transitionElement:function(){return this.panel},bgClose:function(t){return t.bgClose&&this.panel}},beforeDisconnect:function(){this.isToggled()&&this.toggleNow(this.$el,!1)},events:[{name:"click",delegate:function(){return this.selClose},handler:function(t){t.preventDefault(),this.hide()}},{name:"toggle",self:!0,handler:function(t){t.defaultPrevented||(t.preventDefault(),this.toggle())}},{name:"beforeshow",self:!0,handler:function(t){if(b(Qi,this))return!1;!this.stack&&Qi.length?(ne.all(Qi.map(function(t){return t.hide()})).then(this.show),t.preventDefault()):Qi.push(this)}},{name:"show",self:!0,handler:function(){var r=this;an(window)-an(document)&&this.overlay&&Le(document.body,"overflowY","scroll"),Ae(document.documentElement,this.clsPage),this.bgClose&&Yt(this.$el,"hide",li(document,"click",function(t){var e=t.defaultPrevented,n=t.target,i=X(Qi);e||i!==r||i.overlay&&!Wt(n,i.$el)||Wt(n,i.panel)||i.hide()}),{self:!0}),this.escClose&&Yt(this.$el,"hide",Vt(document,"keydown",function(t){var e=X(Qi);27===t.keyCode&&e===r&&(t.preventDefault(),e.hide())}),{self:!0})}},{name:"hidden",self:!0,handler:function(){var e=this;Qi.splice(Qi.indexOf(this),1),Qi.length||Le(document.body,"overflowY",""),Qi.some(function(t){return t.clsPage===e.clsPage})||_e(document.documentElement,this.clsPage)}}],methods:{toggle:function(){return this.isToggled()?this.hide():this.show()},show:function(){var e=this;return this.container&&this.$el.parentNode!==this.container?(pe(this.container,this.$el),new ne(function(t){return requestAnimationFrame(function(){return e.show().then(t)})})):this.toggleElement(this.$el,!0,er(this))},hide:function(){return this.toggleElement(this.$el,!1,er(this))}}};function er(t){var s=t.transitionElement,a=t._toggle;return function(r,o){return new ne(function(n,i){return Yt(r,"show hide",function(){r._reject&&r._reject(),r._reject=i,a(r,o);var t=Yt(s,"transitionstart",function(){Yt(s,"transitionend transitioncancel",n,{self:!0}),clearTimeout(e)},{self:!0}),e=setTimeout(function(){t(),n()},R(Le(s,"transitionDuration")))})})}}var nr={install:function(a){a.modal.dialog=function(t,e){var n=a.modal(' <div class="uk-modal"> <div class="uk-modal-dialog">'+t+"</div> </div> ",e);return n.show(),Vt(n.$el,"hidden",function(){return ne.resolve(function(){return n.$destroy(!0)})},{self:!0}),n},a.modal.alert=function(e,n){return n=U({bgClose:!1,escClose:!1,labels:a.modal.labels},n),new ne(function(t){return Vt(a.modal.dialog(' <div class="uk-modal-body">'+(O(e)?e:fe(e))+'</div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-primary uk-modal-close" autofocus>'+n.labels.ok+"</button> </div> ",n).$el,"hide",t)})},a.modal.confirm=function(r,o){return o=U({bgClose:!1,escClose:!0,labels:a.modal.labels},o),new ne(function(e,t){var n=a.modal.dialog(' <form> <div class="uk-modal-body">'+(O(r)?r:fe(r))+'</div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-default uk-modal-close" type="button">'+o.labels.cancel+'</button> <button class="uk-button uk-button-primary" autofocus>'+o.labels.ok+"</button> </div> </form> ",o),i=!1;Vt(n.$el,"submit","form",function(t){t.preventDefault(),e(),i=!0,n.hide()}),Vt(n.$el,"hide",function(){i||t()})})},a.modal.prompt=function(t,o,s){return s=U({bgClose:!1,escClose:!0,labels:a.modal.labels},s),new ne(function(e){var n=a.modal.dialog(' <form class="uk-form-stacked"> <div class="uk-modal-body"> <label>'+(O(t)?t:fe(t))+'</label> <input class="uk-input" autofocus> </div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-default uk-modal-close" type="button">'+s.labels.cancel+'</button> <button class="uk-button uk-button-primary">'+s.labels.ok+"</button> </div> </form> ",s),i=Te("input",n.$el);i.value=o;var r=!1;Vt(n.$el,"submit","form",function(t){t.preventDefault(),e(i.value),r=!0,n.hide()}),Vt(n.$el,"hide",function(){r||e(null)})})},a.modal.labels={ok:"Ok",cancel:"Cancel"}},mixins:[tr],data:{clsPage:"uk-modal-page",selPanel:".uk-modal-dialog",selClose:".uk-modal-close, .uk-modal-close-default, .uk-modal-close-outside, .uk-modal-close-full"},events:[{name:"show",self:!0,handler:function(){Oe(this.panel,"uk-margin-auto-vertical")?Ae(this.$el,"uk-flex"):Le(this.$el,"display","block"),sn(this.$el)}},{name:"hidden",self:!0,handler:function(){Le(this.$el,"display",""),_e(this.$el,"uk-flex")}}]};var ir={extends:ii,data:{targets:"> .uk-parent",toggle:"> a",content:"> ul"}},rr={mixins:[ei,bi],props:{dropdown:String,mode:"list",align:String,offset:Number,boundary:Boolean,boundaryAlign:Boolean,clsDrop:String,delayShow:Number,delayHide:Number,dropbar:Boolean,dropbarMode:String,dropbarAnchor:Boolean,duration:Number},data:{dropdown:".uk-navbar-nav > li",align:ht?"right":"left",clsDrop:"uk-navbar-dropdown",mode:void 0,offset:void 0,delayShow:void 0,delayHide:void 0,boundaryAlign:void 0,flip:"x",boundary:!0,dropbar:!1,dropbarMode:"slide",dropbarAnchor:!1,duration:200,forceHeight:!0,selMinHeight:".uk-navbar-nav > li > a, .uk-navbar-item, .uk-navbar-toggle"},computed:{boundary:function(t,e){var n=t.boundary,i=t.boundaryAlign;return!0===n||i?e:n},dropbarAnchor:function(t,e){return wt(t.dropbarAnchor,e)},pos:function(t){return"bottom-"+t.align},dropdowns:function(t,e){return Ee(t.dropdown+" ."+t.clsDrop,e)}},beforeConnect:function(){var t=this.$props.dropbar;this.dropbar=t&&(wt(t,this.$el)||Te("+ .uk-navbar-dropbar",this.$el)||Te("<div></div>")),this.dropbar&&(Ae(this.dropbar,"uk-navbar-dropbar"),"slide"===this.dropbarMode&&Ae(this.dropbar,"uk-navbar-dropbar-slide"))},disconnected:function(){this.dropbar&&we(this.dropbar)},update:function(){var e=this;this.$create("drop",this.dropdowns.filter(function(t){return!e.getDropdown(t)}),U({},this.$props,{boundary:this.boundary,pos:this.pos,offset:this.dropbar||this.offset}))},events:[{name:"mouseover",delegate:function(){return this.dropdown},handler:function(t){var e=t.current,n=this.getActive();n&&n.toggle&&!Wt(n.toggle.$el,e)&&!n.tracker.movesTo(n.$el)&&n.hide(!1)}},{name:"mouseleave",el:function(){return this.dropbar},handler:function(){var t=this.getActive();t&&!this.dropdowns.some(function(t){return _t(t,":hover")})&&t.hide()}},{name:"beforeshow",capture:!0,filter:function(){return this.dropbar},handler:function(){this.dropbar.parentNode||ge(this.dropbarAnchor||this.$el,this.dropbar)}},{name:"show",capture:!0,filter:function(){return this.dropbar},handler:function(t,e){var n=e.$el,i=e.dir;this.clsDrop&&Ae(n,this.clsDrop+"-dropbar"),"bottom"===i&&this.transitionTo(n.offsetHeight+F(Le(n,"marginTop"))+F(Le(n,"marginBottom")),n)}},{name:"beforehide",filter:function(){return this.dropbar},handler:function(t,e){var n=e.$el,i=this.getActive();_t(this.dropbar,":hover")&&i&&i.$el===n&&t.preventDefault()}},{name:"hide",filter:function(){return this.dropbar},handler:function(t,e){var n=e.$el,i=this.getActive();(!i||i&&i.$el===n)&&this.transitionTo(0)}}],methods:{getActive:function(){var t=this.dropdowns.map(this.getDropdown).filter(function(t){return t&&t.isActive()})[0];return t&&b(t.mode,"hover")&&Wt(t.toggle.$el,this.$el)&&t},transitionTo:function(t,e){var n=this,i=this.dropbar,r=Ht(i)?sn(i):0;return Le(e=r<t&&e,"clip","rect(0,"+e.offsetWidth+"px,"+r+"px,0)"),sn(i,r),Xe.cancel([e,i]),ne.all([Xe.start(i,{height:t},this.duration),Xe.start(e,{clip:"rect(0,"+e.offsetWidth+"px,"+t+"px,0)"},this.duration)]).catch(Q).then(function(){Le(e,{clip:""}),n.$update(i)})},getDropdown:function(t){return this.$getComponent(t,"drop")||this.$getComponent(t,"dropdown")}}},or={mixins:[tr],args:"mode",props:{mode:String,flip:Boolean,overlay:Boolean},data:{mode:"slide",flip:!1,overlay:!1,clsPage:"uk-offcanvas-page",clsContainer:"uk-offcanvas-container",selPanel:".uk-offcanvas-bar",clsFlip:"uk-offcanvas-flip",clsContainerAnimation:"uk-offcanvas-container-animation",clsSidebarAnimation:"uk-offcanvas-bar-animation",clsMode:"uk-offcanvas",clsOverlay:"uk-offcanvas-overlay",selClose:".uk-offcanvas-close",container:!1},computed:{clsFlip:function(t){var e=t.flip,n=t.clsFlip;return e?n:""},clsOverlay:function(t){var e=t.overlay,n=t.clsOverlay;return e?n:""},clsMode:function(t){var e=t.mode;return t.clsMode+"-"+e},clsSidebarAnimation:function(t){var e=t.mode,n=t.clsSidebarAnimation;return"none"===e||"reveal"===e?"":n},clsContainerAnimation:function(t){var e=t.mode,n=t.clsContainerAnimation;return"push"!==e&&"reveal"!==e?"":n},transitionElement:function(t){return"reveal"===t.mode?this.panel.parentNode:this.panel}},events:[{name:"click",delegate:function(){return'a[href^="#"]'},handler:function(t){var e=t.current.hash;!t.defaultPrevented&&e&&Te(e,document.body)&&this.hide()}},{name:"touchstart",passive:!0,el:function(){return this.panel},handler:function(t){var e=t.targetTouches;1===e.length&&(this.clientY=e[0].clientY)}},{name:"touchmove",self:!0,passive:!1,filter:function(){return this.overlay},handler:function(t){t.cancelable&&t.preventDefault()}},{name:"touchmove",passive:!1,el:function(){return this.panel},handler:function(t){if(1===t.targetTouches.length){var e=event.targetTouches[0].clientY-this.clientY,n=this.panel,i=n.scrollTop,r=n.scrollHeight,o=n.clientHeight;(r<=o||0===i&&0<e||r-i<=o&&e<0)&&t.cancelable&&t.preventDefault()}}},{name:"show",self:!0,handler:function(){"reveal"!==this.mode||Oe(this.panel.parentNode,this.clsMode)||(be(this.panel,"<div>"),Ae(this.panel.parentNode,this.clsMode)),Le(document.documentElement,"overflowY",this.overlay?"hidden":""),Ae(document.body,this.clsContainer,this.clsFlip),Le(document.body,"touch-action","pan-y pinch-zoom"),Le(this.$el,"display","block"),Ae(this.$el,this.clsOverlay),Ae(this.panel,this.clsSidebarAnimation,"reveal"!==this.mode?this.clsMode:""),sn(document.body),Ae(document.body,this.clsContainerAnimation),this.clsContainerAnimation&&(sr().content+=",user-scalable=0")}},{name:"hide",self:!0,handler:function(){_e(document.body,this.clsContainerAnimation),Le(document.body,"touch-action","")}},{name:"hidden",self:!0,handler:function(){this.clsContainerAnimation&&function(){var t=sr();t.content=t.content.replace(/,user-scalable=0$/,"")}(),"reveal"===this.mode&&xe(this.panel),_e(this.panel,this.clsSidebarAnimation,this.clsMode),_e(this.$el,this.clsOverlay),Le(this.$el,"display",""),_e(document.body,this.clsContainer,this.clsFlip),Le(document.documentElement,"overflowY","")}},{name:"swipeLeft swipeRight",handler:function(t){this.isToggled()&&u(t.type,"Left")^this.flip&&this.hide()}}]};function sr(){return Te('meta[name="viewport"]',document.head)||pe(document.head,'<meta name="viewport">')}var ar={mixins:[ei],props:{selContainer:String,selContent:String},data:{selContainer:".uk-modal",selContent:".uk-modal-dialog"},computed:{container:function(t,e){return Mt(e,t.selContainer)},content:function(t,e){return Mt(e,t.selContent)}},connected:function(){Le(this.$el,"minHeight",150)},update:{read:function(){return!(!this.content||!this.container)&&{current:F(Le(this.$el,"maxHeight")),max:Math.max(150,sn(this.container)-(nn(this.content).height-sn(this.$el)))}},write:function(t){var e=t.current,n=t.max;Le(this.$el,"maxHeight",n),Math.round(e)!==Math.round(n)&&qt(this.$el,"resize")},events:["resize"]}},hr={props:["width","height"],connected:function(){Ae(this.$el,"uk-responsive-width")},update:{read:function(){return!!(Ht(this.$el)&&this.width&&this.height)&&{width:an(this.$el.parentNode),height:this.height}},write:function(t){sn(this.$el,nt.contain({height:this.height,width:this.width},t).height)},events:["resize"]}},cr={props:{duration:Number,offset:Number},data:{duration:1e3,offset:0},methods:{scrollTo:function(e){var n=this;e=e&&Te(e)||document.body;var t=sn(document),i=sn(window),r=nn(e).top-this.offset;if(t<r+i&&(r=t-i),qt(this.$el,"beforescroll",[this,e])){var o=Date.now(),s=window.pageYOffset,a=function(){var t=s+(r-s)*function(t){return.5*(1-Math.cos(Math.PI*t))}(Z((Date.now()-o)/n.duration));gn(window,t),t!==r?requestAnimationFrame(a):qt(n.$el,"scrolled",[n,e])};a()}}},events:{click:function(t){t.defaultPrevented||(t.preventDefault(),this.scrollTo(zt(decodeURIComponent(this.$el.hash)).substr(1)))}}};var ur={args:"cls",props:{cls:String,target:String,hidden:Boolean,offsetTop:Number,offsetLeft:Number,repeat:Boolean,delay:Number},data:function(){return{cls:!1,target:!1,hidden:!0,offsetTop:0,offsetLeft:0,repeat:!1,delay:0,inViewClass:"uk-scrollspy-inview"}},computed:{elements:function(t,e){var n=t.target;return n?Ee(n,e):[e]}},update:[{write:function(){this.hidden&&Le(jt(this.elements,":not(."+this.inViewClass+")"),"visibility","hidden")}},{read:function(t){var n=this;t.update&&this.elements.forEach(function(t){var e=t._ukScrollspyState;(e=e||{cls:st(t,"uk-scrollspy-class")||n.cls}).show=pn(t,n.offsetTop,n.offsetLeft),t._ukScrollspyState=e})},write:function(r){var o=this;if(!r.update)return this.$emit(),r.update=!0;this.elements.forEach(function(t){var n=t._ukScrollspyState,e=n.cls;if(!n.show||n.inview||n.queued){if(!n.show&&(n.inview||n.queued)&&o.repeat){if(n.abort&&n.abort(),!n.inview)return;Le(t,"visibility",o.hidden?"hidden":""),_e(t,o.inViewClass),De(t,e),qt(t,"outview"),o.$update(t),n.inview=!1}}else{var i=function(){Le(t,"visibility",""),Ae(t,o.inViewClass),De(t,e),qt(t,"inview"),o.$update(t),n.inview=!0,n.abort&&n.abort()};o.delay?(n.queued=!0,r.promise=(r.promise||ne.resolve()).then(function(){return!n.inview&&new ne(function(t){var e=setTimeout(function(){i(),t()},r.promise||1===o.elements.length?o.delay:0);n.abort=function(){clearTimeout(e),t(),n.queued=!1}})})):i()}})},events:["scroll","resize"]}]},lr={props:{cls:String,closest:String,scroll:Boolean,overflow:Boolean,offset:Number},data:{cls:"uk-active",closest:!1,scroll:!1,overflow:!0,offset:0},computed:{links:function(t,e){return Ee('a[href^="#"]',e).filter(function(t){return t.hash})},elements:function(t){var e=t.closest;return Mt(this.links,e||"*")},targets:function(){return Ee(this.links.map(function(t){return zt(t.hash).substr(1)}).join(","))}},update:[{read:function(){this.scroll&&this.$create("scroll",this.links,{offset:this.offset||0})}},{read:function(o){var s=this,a=window.pageYOffset+this.offset+1,h=sn(document)-sn(window)+this.offset;o.active=!1,this.targets.every(function(t,e){var n=nn(t).top,i=e+1===s.targets.length;if(!s.overflow&&(0===e&&a<n||i&&n+t.offsetTop<a))return!1;if(!i&&nn(s.targets[e+1]).top<=a)return!0;if(h<=a)for(var r=s.targets.length-1;e<r;r--)if(pn(s.targets[r])){t=s.targets[r];break}return!(o.active=Te(jt(s.links,'[href="#'+t.id+'"]')))})},write:function(t){var e=t.active;this.links.forEach(function(t){return t.blur()}),_e(this.elements,this.cls),e&&qt(this.$el,"active",[e,Ae(this.closest?Mt(e,this.closest):e,this.cls)])},events:["scroll","resize"]}]},dr={mixins:[ei,Gi],props:{top:null,bottom:Boolean,offset:String,animation:String,clsActive:String,clsInactive:String,clsFixed:String,clsBelow:String,selTarget:String,widthElement:Boolean,showOnUp:Boolean,targetOffset:Number},data:{top:0,bottom:!1,offset:0,animation:"",clsActive:"uk-active",clsInactive:"",clsFixed:"uk-sticky-fixed",clsBelow:"uk-sticky-below",selTarget:"",widthElement:!1,showOnUp:!1,targetOffset:!1},computed:{offset:function(t){return wn(t.offset)},selTarget:function(t,e){var n=t.selTarget;return n&&Te(n,e)||e},widthElement:function(t,e){return wt(t.widthElement,e)||this.placeholder},isActive:{get:function(){return Oe(this.selTarget,this.clsActive)},set:function(t){t&&!this.isActive?(Me(this.selTarget,this.clsInactive,this.clsActive),qt(this.$el,"active")):t||Oe(this.selTarget,this.clsInactive)||(Me(this.selTarget,this.clsActive,this.clsInactive),qt(this.$el,"inactive"))}}},connected:function(){this.placeholder=Te("+ .uk-sticky-placeholder",this.$el)||Te('<div class="uk-sticky-placeholder"></div>'),this.isFixed=!1,this.isActive=!1},disconnected:function(){this.isFixed&&(this.hide(),_e(this.selTarget,this.clsInactive)),we(this.placeholder),this.placeholder=null,this.widthElement=null},events:[{name:"load hashchange popstate",el:window,handler:function(){var i=this;if(!1!==this.targetOffset&&location.hash&&0<window.pageYOffset){var r=Te(location.hash);r&&kn.read(function(){var t=nn(r).top,e=nn(i.$el).top,n=i.$el.offsetHeight;i.isFixed&&t<=e+n&&e<=t+r.offsetHeight&&gn(window,t-n-(z(i.targetOffset)?i.targetOffset:0)-i.offset)})}}}],update:[{read:function(t,e){var n=t.height;this.isActive&&"update"!==e&&(this.hide(),n=this.$el.offsetHeight,this.show()),n=this.isActive?n:this.$el.offsetHeight,this.topOffset=nn(this.isFixed?this.placeholder:this.$el).top,this.bottomOffset=this.topOffset+n;var i=fr("bottom",this);return this.top=Math.max(F(fr("top",this)),this.topOffset)-this.offset,this.bottom=i&&i-n,this.inactive=!this.matchMedia,{lastScroll:!1,height:n,margins:Le(this.$el,["marginTop","marginBottom","marginLeft","marginRight"])}},write:function(t){var e=t.height,n=t.margins,i=this.placeholder;Le(i,U({height:e},n)),Wt(i,document)||(ge(this.$el,i),it(i,"hidden","")),this.isActive=this.isActive},events:["resize"]},{read:function(t){var e=t.scroll;return void 0===e&&(e=0),this.width=(Ht(this.widthElement)?this.widthElement:this.$el).offsetWidth,this.scroll=window.pageYOffset,{dir:e<=this.scroll?"down":"up",scroll:this.scroll,visible:Ht(this.$el),top:vn(this.placeholder)[0]}},write:function(t,e){var n=this,i=t.initTimestamp;void 0===i&&(i=0);var r=t.dir,o=t.lastDir,s=t.lastScroll,a=t.scroll,h=t.top,c=t.visible,u=performance.now();if(!((t.lastScroll=a)<0||a===s||!c||this.disabled||this.showOnUp&&"scroll"!==e||((300<u-i||r!==o)&&(t.initScroll=a,t.initTimestamp=u),t.lastDir=r,this.showOnUp&&Math.abs(t.initScroll-a)<=30&&Math.abs(s-a)<=10)))if(this.inactive||a<this.top||this.showOnUp&&(a<=this.top||"down"===r||"up"===r&&!this.isFixed&&a<=this.bottomOffset)){if(!this.isFixed)return void(Qe.inProgress(this.$el)&&a<h&&(Qe.cancel(this.$el),this.hide()));this.isFixed=!1,this.animation&&a>this.topOffset?(Qe.cancel(this.$el),Qe.out(this.$el,this.animation).then(function(){return n.hide()},Q)):this.hide()}else this.isFixed?this.update():this.animation?(Qe.cancel(this.$el),this.show(),Qe.in(this.$el,this.animation).catch(Q)):this.show()},events:["resize","scroll"]}],methods:{show:function(){this.isFixed=!0,this.update(),it(this.placeholder,"hidden",null)},hide:function(){this.isActive=!1,_e(this.$el,this.clsFixed,this.clsBelow),Le(this.$el,{position:"",top:"",width:""}),it(this.placeholder,"hidden","")},update:function(){var t=0!==this.top||this.scroll>this.top,e=Math.max(0,this.offset);this.bottom&&this.scroll>this.bottom-this.offset&&(e=this.bottom-this.scroll),Le(this.$el,{position:"fixed",top:e+"px",width:this.width}),this.isActive=t,De(this.$el,this.clsBelow,this.scroll>this.bottomOffset),Ae(this.$el,this.clsFixed)}}};function fr(t,e){var n=e.$props,i=e.$el,r=e[t+"Offset"],o=n[t];if(o)return z(o)&&O(o)&&o.match(/^-?\d/)?r+wn(o):nn(!0===o?i.parentNode:wt(o,i)).bottom}var pr,mr={mixins:[ni],args:"connect",props:{connect:String,toggle:String,active:Number,swiping:Boolean},data:{connect:"~.uk-switcher",toggle:"> * > :first-child",active:0,swiping:!0,cls:"uk-active",clsContainer:"uk-switcher",attrItem:"uk-switcher-item",queued:!0},computed:{connects:function(t,e){return bt(t.connect,e)},toggles:function(t,e){return Ee(t.toggle,e)}},events:[{name:"click",delegate:function(){return this.toggle+":not(.uk-disabled)"},handler:function(e){e.preventDefault(),this.show(W(this.$el.children).filter(function(t){return Wt(e.current,t)})[0])}},{name:"click",el:function(){return this.connects},delegate:function(){return"["+this.attrItem+"],[data-"+this.attrItem+"]"},handler:function(t){t.preventDefault(),this.show(st(t.current,this.attrItem))}},{name:"swipeRight swipeLeft",filter:function(){return this.swiping},el:function(){return this.connects},handler:function(t){var e=t.type;this.show(u(e,"Left")?"next":"previous")}}],update:function(){var e=this;this.connects.forEach(function(t){return e.updateAria(t.children)});var t=this.$el.children;this.show(jt(t,"."+this.cls)[0]||t[this.active]||t[0]),this.swiping&&Le(this.connects,"touch-action","pan-y pinch-zoom")},methods:{index:function(){return!B(this.connects)&&ue(jt(this.connects[0].children,"."+this.cls)[0])},show:function(t){for(var e,n,i=this,r=this.$el.children,o=r.length,s=this.index(),a=0<=s,h="previous"===t?-1:1,c=le(t,r,s),u=0;u<o;u++,c=(c+h+o)%o)if(!_t(this.toggles[c],".uk-disabled *, .uk-disabled, [disabled]")){e=this.toggles[c],n=r[c];break}!n||0<=s&&Oe(n,this.cls)||s===c||(_e(r,this.cls),Ae(n,this.cls),it(this.toggles,"aria-expanded",!1),it(e,"aria-expanded",!0),this.connects.forEach(function(t){a?i.toggleElement([t.children[s],t.children[c]]):i.toggleNow(t.children[c])}))}}},gr={mixins:[ei],extends:mr,props:{media:Boolean},data:{media:960,attrItem:"uk-tab-item"},connected:function(){var t=Oe(this.$el,"uk-tab-left")?"uk-tab-left":!!Oe(this.$el,"uk-tab-right")&&"uk-tab-right";t&&this.$create("toggle",this.$el,{cls:t,mode:"media",media:this.media})}},vr={mixins:[Gi,ni],args:"target",props:{href:String,target:null,mode:"list"},data:{href:!1,target:!1,mode:"click",queued:!0},computed:{target:function(t,e){var n=t.href,i=t.target;return(i=bt(i||n,e)).length&&i||[e]}},connected:function(){qt(this.target,"updatearia",[this])},events:[{name:mt+" "+gt,filter:function(){return b(this.mode,"hover")},handler:function(t){Qt(t)||this.toggle("toggle"+(t.type===mt?"show":"hide"))}},{name:"click",filter:function(){return b(this.mode,"click")||lt&&b(this.mode,"hover")},handler:function(t){var e;(Mt(t.target,'a[href="#"], a[href=""]')||(e=Mt(t.target,"a[href]"))&&(this.cls||!Ht(this.target)||e.hash&&_t(this.target,e.hash)))&&t.preventDefault(),this.toggle()}}],update:{read:function(){return!(!b(this.mode,"media")||!this.media)&&{match:this.matchMedia}},write:function(t){var e=t.match,n=this.isToggled(this.target);(e?!n:n)&&this.toggle()},events:["resize"]},methods:{toggle:function(t){qt(this.target,t||"toggle",[this])&&this.toggleElement(this.target)}}};Ln.version="3.2.0",(pr=Ln).component("accordion",ii),pr.component("alert",ri),pr.component("cover",hi),pr.component("drop",ui),pr.component("dropdown",di),pr.component("formCustom",fi),pr.component("gif",pi),pr.component("grid",wi),pr.component("heightMatch",yi),pr.component("heightViewport",$i),pr.component("icon",Oi),pr.component("img",Li),pr.component("leader",Ji),pr.component("margin",mi),pr.component("modal",nr),pr.component("nav",ir),pr.component("navbar",rr),pr.component("offcanvas",or),pr.component("overflowAuto",ar),pr.component("responsive",hr),pr.component("scroll",cr),pr.component("scrollspy",ur),pr.component("scrollspyNav",lr),pr.component("sticky",dr),pr.component("svg",Si),pr.component("switcher",mr),pr.component("tab",gr),pr.component("toggle",vr),pr.component("video",ai),pr.component("close",Pi),pr.component("marker",Di),pr.component("navbarToggleIcon",Di),pr.component("overlayIcon",Di),pr.component("paginationNext",Di),pr.component("paginationPrevious",Di),pr.component("searchIcon",Bi),pr.component("slidenavNext",zi),pr.component("slidenavPrevious",zi),pr.component("spinner",Hi),pr.component("totop",Di),pr.use(oi);var wr={mixins:[ei],props:{date:String,clsWrapper:String},data:{date:"",clsWrapper:".uk-countdown-%unit%"},computed:{date:function(t){var e=t.date;return Date.parse(e)},days:function(t,e){return Te(t.clsWrapper.replace("%unit%","days"),e)},hours:function(t,e){return Te(t.clsWrapper.replace("%unit%","hours"),e)},minutes:function(t,e){return Te(t.clsWrapper.replace("%unit%","minutes"),e)},seconds:function(t,e){return Te(t.clsWrapper.replace("%unit%","seconds"),e)},units:function(){var e=this;return["days","hours","minutes","seconds"].filter(function(t){return e[t]})}},connected:function(){this.start()},disconnected:function(){var e=this;this.stop(),this.units.forEach(function(t){return de(e[t])})},events:[{name:"visibilitychange",el:document,handler:function(){document.hidden?this.stop():this.start()}}],update:{write:function(){var i=this,r=function(t){var e=t-Date.now();return{total:e,seconds:e/1e3%60,minutes:e/1e3/60%60,hours:e/1e3/60/60%24,days:e/1e3/60/60/24}}(this.date);r.total<=0&&(this.stop(),r.days=r.hours=r.minutes=r.seconds=0),this.units.forEach(function(t){var e=String(Math.floor(r[t]));e=e.length<2?"0"+e:e;var n=i[t];n.textContent!==e&&((e=e.split("")).length!==n.children.length&&fe(n,e.map(function(){return"<span></span>"}).join("")),e.forEach(function(t,e){return n.children[e].textContent=t}))})}},methods:{start:function(){var t=this;this.stop(),this.date&&this.units.length&&(this.$emit(),this.timer=setInterval(function(){return t.$emit()},1e3))},stop:function(){this.timer&&(clearInterval(this.timer),this.timer=null)}}};var br,yr="uk-animation-target",xr={props:{animation:Number},data:{animation:150},computed:{target:function(){return this.$el}},methods:{animate:function(t){var i=this;!function(){if(br)return;(br=pe(document.head,"<style>").sheet).insertRule("."+yr+" > * {\n            margin-top: 0 !important;\n            transform: none !important;\n        }",0)}();var r=W(this.target.children),o=r.map(function(t){return kr(t,!0)}),e=sn(this.target),n=window.pageYOffset;t(),Xe.cancel(this.target),r.forEach(Xe.cancel),$r(this.target),this.$update(this.target),kn.flush();var s=sn(this.target),a=(r=r.concat(W(this.target.children).filter(function(t){return!b(r,t)}))).map(function(t,e){return!!(t.parentNode&&e in o)&&(o[e]?Ht(t)?Ir(t):{opacity:0}:{opacity:Ht(t)?1:0})});return o=a.map(function(t,e){var n=r[e].parentNode===i.target&&(o[e]||kr(r[e]));if(n)if(t){if(!("opacity"in t)){n.opacity%1?t.opacity=1:delete n.opacity}}else delete n.opacity;return n}),Ae(this.target,yr),r.forEach(function(t,e){return o[e]&&Le(t,o[e])}),Le(this.target,"height",e),gn(window,n),ne.all(r.map(function(t,e){return o[e]&&a[e]?Xe.start(t,a[e],i.animation,"ease"):ne.resolve()}).concat(Xe.start(this.target,{height:s},this.animation,"ease"))).then(function(){r.forEach(function(t,e){return Le(t,{display:0===a[e].opacity?"none":"",zIndex:""})}),$r(i.target),i.$update(i.target),kn.flush()},Q)}}};function kr(t,e){var n=Le(t,"zIndex");return!!Ht(t)&&U({display:"",opacity:e?Le(t,"opacity"):"0",pointerEvents:"none",position:"absolute",zIndex:"auto"===n?ue(t):n},Ir(t))}function $r(t){Le(t.children,{height:"",left:"",opacity:"",pointerEvents:"",position:"",top:"",width:""}),_e(t,yr),Le(t,"height","")}function Ir(t){var e=t.getBoundingClientRect(),n=e.height,i=e.width,r=on(t),o=r.top,s=r.left;return{top:o+=F(Le(t,"marginTop")),left:s,height:n,width:i}}var Sr={mixins:[xr],args:"target",props:{target:Boolean,selActive:Boolean},data:{target:null,selActive:!1,attrItem:"uk-filter-control",cls:"uk-active",animation:250},computed:{toggles:{get:function(t,e){t.attrItem;return Ee("["+this.attrItem+"],[data-"+this.attrItem+"]",e)},watch:function(){this.updateState()}},target:function(t,e){return Te(t.target,e)},children:{get:function(){return W(this.target&&this.target.children)},watch:function(t,e){!function(t,e){return t.length===e.length&&t.every(function(t){return~e.indexOf(t)})}(t,e)&&this.updateState()}}},events:[{name:"click",delegate:function(){return"["+this.attrItem+"],[data-"+this.attrItem+"]"},handler:function(t){t.preventDefault(),this.apply(t.current)}}],connected:function(){var e=this;if(this.updateState(),!1!==this.selActive){var n=Ee(this.selActive,this.$el);this.toggles.forEach(function(t){return De(t,e.cls,b(n,t))})}},methods:{apply:function(t){this.setState(Er(t,this.attrItem,this.getState()))},getState:function(){var n=this;return this.toggles.filter(function(t){return Oe(t,n.cls)}).reduce(function(t,e){return Er(e,n.attrItem,t)},{filter:{"":""},sort:[]})},setState:function(o,t){var s=this;void 0===t&&(t=!0),o=U({filter:{"":""},sort:[]},o),qt(this.$el,"beforeFilter",[this,o]);var a=this.children;this.toggles.forEach(function(t){return De(t,s.cls,!!function(t,e,n){var i=n.filter;void 0===i&&(i={"":""});var r=n.sort,o=r[0],s=r[1],a=Tr(t,e),h=a.filter;void 0===h&&(h="");var c=a.group;void 0===c&&(c="");var u=a.sort,l=a.order;void 0===l&&(l="asc");return P(u)?c in i&&h===i[c]||!h&&c&&!(c in i)&&!i[""]:o===u&&s===l}(t,s.attrItem,o))});function e(){var e=function(t){var e=t.filter,n="";return K(e,function(t){return n+=t||""}),n}(o);a.forEach(function(t){return Le(t,"display",e&&!_t(t,e)?"none":"")});var t=o.sort,n=t[0],i=t[1];if(n){var r=function(t,n,i){return U([],t).sort(function(t,e){return st(t,n).localeCompare(st(e,n),void 0,{numeric:!0})*("asc"===i||-1)})}(a,n,i);Y(r,a)||r.forEach(function(t){return pe(s.target,t)})}}t?this.animate(e).then(function(){return qt(s.$el,"afterFilter",[s])}):(e(),qt(this.$el,"afterFilter",[this]))},updateState:function(){var t=this;kn.write(function(){return t.setState(t.getState(),!1)})}}};function Tr(t,e){return On(st(t,e),["filter"])}function Er(t,e,n){var i=Tr(t,e),r=i.filter,o=i.group,s=i.sort,a=i.order;return void 0===a&&(a="asc"),(r||P(s))&&(o?r?(delete n.filter[""],n.filter[o]=r):(delete n.filter[o],(B(n.filter)||""in n.filter)&&(n.filter={"":r||""})):n.filter={"":r||""}),P(s)||(n.sort=[s,a]),n}var Cr={slide:{show:function(t){return[{transform:_r(-100*t)},{transform:_r()}]},percent:function(t){return Ar(t)},translate:function(t,e){return[{transform:_r(-100*e*t)},{transform:_r(100*e*(1-t))}]}}};function Ar(t){return Math.abs(Le(t,"transform").split(",")[4]/t.offsetWidth)||0}function _r(t,e){return void 0===t&&(t=0),void 0===e&&(e="%"),t+=t?e:"",at?"translateX("+t+")":"translate3d("+t+", 0, 0)"}function Nr(t){return"scale3d("+t+", "+t+", 1)"}var Mr=U({},Cr,{fade:{show:function(){return[{opacity:0},{opacity:1}]},percent:function(t){return 1-Le(t,"opacity")},translate:function(t){return[{opacity:1-t},{opacity:t}]}},scale:{show:function(){return[{opacity:0,transform:Nr(.8)},{opacity:1,transform:Nr(1)}]},percent:function(t){return 1-Le(t,"opacity")},translate:function(t){return[{opacity:1-t,transform:Nr(1-.2*t)},{opacity:t,transform:Nr(.8+.2*t)}]}}});function Or(t,e,n){qt(t,Ut(e,!1,!1,n))}var Dr={mixins:[{props:{autoplay:Boolean,autoplayInterval:Number,pauseOnHover:Boolean},data:{autoplay:!1,autoplayInterval:7e3,pauseOnHover:!0},connected:function(){this.autoplay&&this.startAutoplay()},disconnected:function(){this.stopAutoplay()},update:function(){it(this.slides,"tabindex","-1")},events:[{name:"visibilitychange",el:document,filter:function(){return this.autoplay},handler:function(){document.hidden?this.stopAutoplay():this.startAutoplay()}}],methods:{startAutoplay:function(){var t=this;this.stopAutoplay(),this.interval=setInterval(function(){return(!t.draggable||!Te(":focus",t.$el))&&(!t.pauseOnHover||!_t(t.$el,":hover"))&&!t.stack.length&&t.show("next")},this.autoplayInterval)},stopAutoplay:function(){this.interval&&clearInterval(this.interval)}}},{props:{draggable:Boolean},data:{draggable:!0,threshold:10},created:function(){var i=this;["start","move","end"].forEach(function(t){var n=i[t];i[t]=function(t){var e=te(t).x*(ht?-1:1);i.prevPos=e!==i.pos?i.pos:i.prevPos,i.pos=e,n(t)}})},events:[{name:dt,delegate:function(){return this.selSlides},handler:function(t){!this.draggable||!Qt(t)&&function(t){return!t.children.length&&t.childNodes.length}(t.target)||0<t.button||this.length<2||this.start(t)}},{name:"touchmove",passive:!1,handler:"move",delegate:function(){return this.selSlides}},{name:"dragstart",handler:function(t){t.preventDefault()}}],methods:{start:function(){var t=this;this.drag=this.pos,this._transitioner?(this.percent=this._transitioner.percent(),this.drag+=this._transitioner.getDistance()*this.percent*this.dir,this._transitioner.cancel(),this._transitioner.translate(this.percent),this.dragging=!0,this.stack=[]):this.prevIndex=this.index;var e="touchmove"!=ft?Vt(document,ft,this.move,{passive:!1}):Q;this.unbindMove=function(){e(),t.unbindMove=null},Vt(window,"scroll",this.unbindMove),Vt(document,pt,this.end,!0),Le(this.list,"userSelect","none")},move:function(t){var e=this;if(this.unbindMove){var n=this.pos-this.drag;if(!(0==n||this.prevPos===this.pos||!this.dragging&&Math.abs(n)<this.threshold)){Le(this.list,"pointerEvents","none"),t.cancelable&&t.preventDefault(),this.dragging=!0,this.dir=n<0?1:-1;for(var i=this.slides,r=this.prevIndex,o=Math.abs(n),s=this.getIndex(r+this.dir,r),a=this._getDistance(r,s)||i[r].offsetWidth;s!==r&&a<o;)this.drag-=a*this.dir,r=s,o-=a,s=this.getIndex(r+this.dir,r),a=this._getDistance(r,s)||i[r].offsetWidth;this.percent=o/a;var h,c=i[r],u=i[s],l=this.index!==s,d=r===s;[this.index,this.prevIndex].filter(function(t){return!b([s,r],t)}).forEach(function(t){qt(i[t],"itemhidden",[e]),d&&(h=!0,e.prevIndex=r)}),(this.index===r&&this.prevIndex!==r||h)&&qt(i[this.index],"itemshown",[this]),l&&(this.prevIndex=r,this.index=s,d||qt(c,"beforeitemhide",[this]),qt(u,"beforeitemshow",[this])),this._transitioner=this._translate(Math.abs(this.percent),c,!d&&u),l&&(d||qt(c,"itemhide",[this]),qt(u,"itemshow",[this]))}}},end:function(){if(Rt(window,"scroll",this.unbindMove),this.unbindMove&&this.unbindMove(),Rt(document,pt,this.end,!0),this.dragging)if(this.dragging=null,this.index===this.prevIndex)this.percent=1-this.percent,this.dir*=-1,this._show(!1,this.index,!0),this._transitioner=null;else{var t=(ht?this.dir*(ht?1:-1):this.dir)<0==this.prevPos>this.pos;this.index=t?this.index:this.prevIndex,t&&(this.percent=1-this.percent),this.show(0<this.dir&&!t||this.dir<0&&t?"next":"previous",!0)}Le(this.list,{userSelect:"",pointerEvents:""}),this.drag=this.percent=null}}},{data:{selNav:!1},computed:{nav:function(t,e){return Te(t.selNav,e)},selNavItem:function(t){var e=t.attrItem;return"["+e+"],[data-"+e+"]"},navItems:function(t,e){return Ee(this.selNavItem,e)}},update:{write:function(){var n=this;this.nav&&this.length!==this.nav.children.length&&fe(this.nav,this.slides.map(function(t,e){return"<li "+n.attrItem+'="'+e+'"><a href="#"></a></li>'}).join("")),De(Ee(this.selNavItem,this.$el).concat(this.nav),"uk-hidden",!this.maxIndex),this.updateNav()},events:["resize"]},events:[{name:"click",delegate:function(){return this.selNavItem},handler:function(t){t.preventDefault(),this.show(st(t.current,this.attrItem))}},{name:"itemshow",handler:"updateNav"}],methods:{updateNav:function(){var n=this,i=this.getValidIndex();this.navItems.forEach(function(t){var e=st(t,n.attrItem);De(t,n.clsActive,L(e)===i),De(t,"uk-invisible",n.finite&&("previous"===e&&0===i||"next"===e&&i>=n.maxIndex))})}}}],props:{clsActivated:Boolean,easing:String,index:Number,finite:Boolean,velocity:Number},data:function(){return{easing:"ease",finite:!1,velocity:1,index:0,prevIndex:-1,stack:[],percent:0,clsActive:"uk-active",clsActivated:!1,Transitioner:!1,transitionOptions:{}}},connected:function(){this.prevIndex=-1,this.index=this.getValidIndex(this.index),this.stack=[]},disconnected:function(){_e(this.slides,this.clsActive)},computed:{duration:function(t,e){var n=t.velocity;return zr(e.offsetWidth/n)},list:function(t,e){return Te(t.selList,e)},maxIndex:function(){return this.length-1},selSlides:function(t){return t.selList+" > *"},slides:{get:function(){return W(this.list.children)},watch:function(){this.$reset()}},length:function(){return this.slides.length}},events:{itemshown:function(){this.$update(this.list)}},methods:{show:function(t,e){var n=this;if(void 0===e&&(e=!1),!this.dragging&&this.length){var i=this.stack,r=e?0:i.length,o=function(){i.splice(r,1),i.length&&n.show(i.shift(),!0)};if(i[e?"unshift":"push"](t),!e&&1<i.length)2===i.length&&this._transitioner.forward(Math.min(this.duration,200));else{var s=this.index,a=Oe(this.slides,this.clsActive)&&this.slides[s],h=this.getIndex(t,this.index),c=this.slides[h];if(a!==c){if(this.dir=function(t,e){return"next"===t?1:"previous"===t?-1:t<e?-1:1}(t,s),this.prevIndex=s,this.index=h,a&&qt(a,"beforeitemhide",[this]),!qt(c,"beforeitemshow",[this,a]))return this.index=this.prevIndex,void o();var u=this._show(a,c,e).then(function(){return a&&qt(a,"itemhidden",[n]),qt(c,"itemshown",[n]),new ne(function(t){kn.write(function(){i.shift(),i.length?n.show(i.shift(),!0):n._transitioner=null,t()})})});return a&&qt(a,"itemhide",[this]),qt(c,"itemshow",[this]),u}o()}}},getIndex:function(t,e){return void 0===t&&(t=this.index),void 0===e&&(e=this.index),Z(le(t,this.slides,e,this.finite),0,this.maxIndex)},getValidIndex:function(t,e){return void 0===t&&(t=this.index),void 0===e&&(e=this.prevIndex),this.getIndex(t,e)},_show:function(t,e,n){if(this._transitioner=this._getTransitioner(t,e,this.dir,U({easing:n?e.offsetWidth<600?"cubic-bezier(0.25, 0.46, 0.45, 0.94)":"cubic-bezier(0.165, 0.84, 0.44, 1)":this.easing},this.transitionOptions)),!n&&!t)return this._transitioner.translate(1),ne.resolve();var i=this.stack.length;return this._transitioner[1<i?"forward":"show"](1<i?Math.min(this.duration,75+75/(i-1)):this.duration,this.percent)},_getDistance:function(t,e){return this._getTransitioner(t,t!==e&&e).getDistance()},_translate:function(t,e,n){void 0===e&&(e=this.prevIndex),void 0===n&&(n=this.index);var i=this._getTransitioner(e!==n&&e,n);return i.translate(t),i},_getTransitioner:function(t,e,n,i){return void 0===t&&(t=this.prevIndex),void 0===e&&(e=this.index),void 0===n&&(n=this.dir||1),void 0===i&&(i=this.transitionOptions),new this.Transitioner(D(t)?this.slides[t]:t,D(e)?this.slides[e]:e,n*(ht?-1:1),i)}}};function zr(t){return.5*t+300}var Br={mixins:[Dr],props:{animation:String},data:{animation:"slide",clsActivated:"uk-transition-active",Animations:Cr,Transitioner:function(o,s,a,t){var e=t.animation,h=t.easing,n=e.percent,i=e.translate,r=e.show;void 0===r&&(r=Q);var c=r(a),u=new ee;return{dir:a,show:function(t,e,n){var i=this;void 0===e&&(e=0);var r=n?"linear":h;return t-=Math.round(t*Z(e,-1,1)),this.translate(e),Or(s,"itemin",{percent:e,duration:t,timing:r,dir:a}),Or(o,"itemout",{percent:1-e,duration:t,timing:r,dir:a}),ne.all([Xe.start(s,c[1],t,r),Xe.start(o,c[0],t,r)]).then(function(){i.reset(),u.resolve()},Q),u.promise},stop:function(){return Xe.stop([s,o])},cancel:function(){Xe.cancel([s,o])},reset:function(){for(var t in c[0])Le([s,o],t,"")},forward:function(t,e){return void 0===e&&(e=this.percent()),Xe.cancel([s,o]),this.show(t,e,!0)},translate:function(t){this.reset();var e=i(t,a);Le(s,e[1]),Le(o,e[0]),Or(s,"itemtranslatein",{percent:t,dir:a}),Or(o,"itemtranslateout",{percent:1-t,dir:a})},percent:function(){return n(o||s,s,a)},getDistance:function(){return o&&o.offsetWidth}}}},computed:{animation:function(t){var e=t.animation,n=t.Animations;return U(e in n?n[e]:n.slide,{name:e})},transitionOptions:function(){return{animation:this.animation}}},events:{"itemshow itemhide itemshown itemhidden":function(t){var e=t.target;this.$update(e)},beforeitemshow:function(t){Ae(t.target,this.clsActive)},itemshown:function(t){Ae(t.target,this.clsActivated)},itemhidden:function(t){_e(t.target,this.clsActive,this.clsActivated)}}},Pr={mixins:[Zi,tr,ni,Br],functional:!0,props:{delayControls:Number,preload:Number,videoAutoplay:Boolean,template:String},data:function(){return{preload:1,videoAutoplay:!1,delayControls:3e3,items:[],cls:"uk-open",clsPage:"uk-lightbox-page",selList:".uk-lightbox-items",attrItem:"uk-lightbox-item",selClose:".uk-close-large",selCaption:".uk-lightbox-caption",pauseOnHover:!1,velocity:2,Animations:Mr,template:'<div class="uk-lightbox uk-overflow-hidden"> <ul class="uk-lightbox-items"></ul> <div class="uk-lightbox-toolbar uk-position-top uk-text-right uk-transition-slide-top uk-transition-opaque"> <button class="uk-lightbox-toolbar-icon uk-close-large" type="button" uk-close></button> </div> <a class="uk-lightbox-button uk-position-center-left uk-position-medium uk-transition-fade" href="#" uk-slidenav-previous uk-lightbox-item="previous"></a> <a class="uk-lightbox-button uk-position-center-right uk-position-medium uk-transition-fade" href="#" uk-slidenav-next uk-lightbox-item="next"></a> <div class="uk-lightbox-toolbar uk-lightbox-caption uk-position-bottom uk-text-center uk-transition-slide-bottom uk-transition-opaque"></div> </div>'}},created:function(){var t=Te(this.template),e=Te(this.selList,t);this.items.forEach(function(){return pe(e,"<li></li>")}),this.$mount(pe(this.container,t))},computed:{caption:function(t,e){t.selCaption;return Te(".uk-lightbox-caption",e)}},events:[{name:ft+" "+dt+" keydown",handler:"showControls"},{name:"click",self:!0,delegate:function(){return this.selSlides},handler:function(t){t.defaultPrevented||this.hide()}},{name:"shown",self:!0,handler:function(){this.showControls()}},{name:"hide",self:!0,handler:function(){this.hideControls(),_e(this.slides,this.clsActive),Xe.stop(this.slides)}},{name:"hidden",self:!0,handler:function(){this.$destroy(!0)}},{name:"keyup",el:document,handler:function(t){if(this.isToggled(this.$el))switch(t.keyCode){case 37:this.show("previous");break;case 39:this.show("next")}}},{name:"beforeitemshow",handler:function(t){this.isToggled()||(this.draggable=!1,t.preventDefault(),this.toggleNow(this.$el,!0),this.animation=Mr.scale,_e(t.target,this.clsActive),this.stack.splice(1,0,this.index))}},{name:"itemshow",handler:function(t){var e=ue(t.target),n=this.getItem(e).caption;Le(this.caption,"display",n?"":"none"),fe(this.caption,n);for(var i=0;i<=this.preload;i++)this.loadItem(this.getIndex(e+i)),this.loadItem(this.getIndex(e-i))}},{name:"itemshown",handler:function(){this.draggable=this.$props.draggable}},{name:"itemload",handler:function(t,r){var o,s=this,e=r.source,n=r.type,i=r.alt;if(this.setItem(r,"<span uk-spinner></span>"),e)if("image"===n||e.match(/\.(jp(e)?g|png|gif|svg|webp)($|\?)/i))he(e).then(function(t){return s.setItem(r,'<img width="'+t.width+'" height="'+t.height+'" src="'+e+'" alt="'+(i||"")+'">')},function(){return s.setError(r)});else if("video"===n||e.match(/\.(mp4|webm|ogv)($|\?)/i)){var a=Te("<video controls playsinline"+(r.poster?' poster="'+r.poster+'"':"")+' uk-video="'+this.videoAutoplay+'"></video>');it(a,"src",e),Yt(a,"error loadedmetadata",function(t){"error"===t?s.setError(r):(it(a,{width:a.videoWidth,height:a.videoHeight}),s.setItem(r,a))})}else if("iframe"===n||e.match(/\.(html|php)($|\?)/i))this.setItem(r,'<iframe class="uk-lightbox-iframe" src="'+e+'" frameborder="0" allowfullscreen></iframe>');else if(o=e.match(/\/\/.*?youtube(-nocookie)?\.[a-z]+\/watch\?v=([^&\s]+)/)||e.match(/()youtu\.be\/(.*)/)){var h=o[2],c=function(t,e){return void 0===t&&(t=640),void 0===e&&(e=450),s.setItem(r,Hr("https://www.youtube"+(o[1]||"")+".com/embed/"+h,t,e,s.videoAutoplay))};he("https://img.youtube.com/vi/"+h+"/maxresdefault.jpg").then(function(t){var e=t.width,n=t.height;120===e&&90===n?he("https://img.youtube.com/vi/"+h+"/0.jpg").then(function(t){var e=t.width,n=t.height;return c(e,n)},c):c(e,n)},c)}else(o=e.match(/(\/\/.*?)vimeo\.[a-z]+\/([0-9]+).*?/))&&ae("https://vimeo.com/api/oembed.json?maxwidth=1920&url="+encodeURI(e),{responseType:"json",withCredentials:!1}).then(function(t){var e=t.response,n=e.height,i=e.width;return s.setItem(r,Hr("https://player.vimeo.com/video/"+o[2],i,n,s.videoAutoplay))},function(){return s.setError(r)})}}],methods:{loadItem:function(t){void 0===t&&(t=this.index);var e=this.getItem(t);e.content||qt(this.$el,"itemload",[e])},getItem:function(t){return void 0===t&&(t=this.index),this.items[t]||{}},setItem:function(t,e){U(t,{content:e});var n=fe(this.slides[this.items.indexOf(t)],e);qt(this.$el,"itemloaded",[this,n]),this.$update(n)},setError:function(t){this.setItem(t,'<span uk-icon="icon: bolt; ratio: 2"></span>')},showControls:function(){clearTimeout(this.controlsTimer),this.controlsTimer=setTimeout(this.hideControls,this.delayControls),Ae(this.$el,"uk-active","uk-transition-active")},hideControls:function(){_e(this.$el,"uk-active","uk-transition-active")}}};function Hr(t,e,n,i){return'<iframe src="'+t+'" width="'+e+'" height="'+n+'" style="max-width: 100%; box-sizing: border-box;" frameborder="0" allowfullscreen uk-video="autoplay: '+i+'" uk-responsive></iframe>'}var Lr,Fr={install:function(t,e){t.lightboxPanel||t.component("lightboxPanel",Pr);U(e.props,t.component("lightboxPanel").options.props)},props:{toggle:String},data:{toggle:"a"},computed:{toggles:{get:function(t,e){return Ee(t.toggle,e)},watch:function(){this.hide()}},items:function(){return J(this.toggles.map(jr),"source")}},disconnected:function(){this.hide()},events:[{name:"click",delegate:function(){return this.toggle+":not(.uk-disabled)"},handler:function(t){t.preventDefault();var e=st(t.current,"href");this.show(x(this.items,function(t){return t.source===e}))}}],methods:{show:function(t){var e=this;return this.panel=this.panel||this.$create("lightboxPanel",U({},this.$props,{items:this.items})),Vt(this.panel.$el,"hidden",function(){return e.panel=!1}),this.panel.show(t)},hide:function(){return this.panel&&this.panel.hide()}}};function jr(n){return["href","caption","type","poster","alt"].reduce(function(t,e){return t["href"===e?"source":e]=st(n,e),t},{})}var Wr={},Vr={functional:!0,args:["message","status"],data:{message:"",status:"",timeout:5e3,group:null,pos:"top-center",clsClose:"uk-notification-close",clsMsg:"uk-notification-message"},install:function(r){r.notification.closeAll=function(n,i){Se(document.body,function(t){var e=r.getComponent(t,"notification");!e||n&&n!==e.group||e.close(i)})}},computed:{marginProp:function(t){return"margin"+(w(t.pos,"top")?"Top":"Bottom")},startProps:function(){var t;return(t={opacity:0})[this.marginProp]=-this.$el.offsetHeight,t}},created:function(){Wr[this.pos]||(Wr[this.pos]=pe(this.$container,'<div class="uk-notification uk-notification-'+this.pos+'"></div>'));var t=Le(Wr[this.pos],"display","block");this.$mount(pe(t,'<div class="'+this.clsMsg+(this.status?" "+this.clsMsg+"-"+this.status:"")+'"> <a href="#" class="'+this.clsClose+'" data-uk-close></a> <div>'+this.message+"</div> </div>"))},connected:function(){var t,e=this,n=F(Le(this.$el,this.marginProp));Xe.start(Le(this.$el,this.startProps),((t={opacity:1})[this.marginProp]=n,t)).then(function(){e.timeout&&(e.timer=setTimeout(e.close,e.timeout))})},events:(Lr={click:function(t){Mt(t.target,'a[href="#"],a[href=""]')&&t.preventDefault(),this.close()}},Lr[mt]=function(){this.timer&&clearTimeout(this.timer)},Lr[gt]=function(){this.timeout&&(this.timer=setTimeout(this.close,this.timeout))},Lr),methods:{close:function(t){function e(){qt(n.$el,"close",[n]),we(n.$el),Wr[n.pos].children.length||Le(Wr[n.pos],"display","none")}var n=this;this.timer&&clearTimeout(this.timer),t?e():Xe.start(this.$el,this.startProps).then(e)}}};var Rr=["x","y","bgx","bgy","rotate","scale","color","backgroundColor","borderColor","opacity","blur","hue","grayscale","invert","saturate","sepia","fopacity","stroke"],Yr={mixins:[Gi],props:Rr.reduce(function(t,e){return t[e]="list",t},{}),data:Rr.reduce(function(t,e){return t[e]=void 0,t},{}),computed:{props:function(m,g){var v=this;return Rr.reduce(function(t,e){if(P(m[e]))return t;var n,i,r,o=e.match(/color/i),s=o||"opacity"===e,a=m[e].slice(0);s&&Le(g,e,""),a.length<2&&a.unshift(("scale"===e?1:s?Le(g,e):0)||0);var h=function(t){return t.reduce(function(t,e){return O(e)&&e.replace(/-|\d/g,"").trim()||t},"")}(a);if(o){var c=g.style.color;a=a.map(function(t){return function(t,e){return Le(Le(t,"color",e),"color").split(/[(),]/g).slice(1,-1).concat(1).slice(0,4).map(F)}(g,t)}),g.style.color=c}else if(w(e,"bg")){var u="bgy"===e?"height":"width";if(a=a.map(function(t){return wn(t,u,v.$el)}),Le(g,"background-position-"+e[2],""),i=Le(g,"backgroundPosition").split(" ")["x"===e[2]?0:1],v.covers){var l=Math.min.apply(Math,a),d=Math.max.apply(Math,a),f=a.indexOf(l)<a.indexOf(d);r=d-l,a=a.map(function(t){return t-(f?l:d)}),n=(f?-r:0)+"px"}else n=i}else a=a.map(F);if("stroke"===e){if(!a.some(function(t){return t}))return t;var p=Ai(v.$el);Le(g,"strokeDasharray",p),"%"===h&&(a=a.map(function(t){return t*p/100})),a=a.reverse(),e="strokeDashoffset"}return t[e]={steps:a,unit:h,pos:n,bgPos:i,diff:r},t},{})},bgProps:function(){var e=this;return["bgx","bgy"].filter(function(t){return t in e.props})},covers:function(t,e){return function(t){var e=t.style.backgroundSize,n="cover"===Le(Le(t,"backgroundSize",""),"backgroundSize");return t.style.backgroundSize=e,n}(e)}},disconnected:function(){delete this._image},update:{read:function(t){var h=this;if(t.active=this.matchMedia,t.active){if(!t.image&&this.covers&&this.bgProps.length){var e=Le(this.$el,"backgroundImage").replace(/^none|url\(["']?(.+?)["']?\)$/,"$1");if(e){var n=new Image;n.src=e,(t.image=n).naturalWidth||(n.onload=function(){return h.$emit()})}}var i=t.image;if(i&&i.naturalWidth){var c={width:this.$el.offsetWidth,height:this.$el.offsetHeight},u={width:i.naturalWidth,height:i.naturalHeight},l=nt.cover(u,c);this.bgProps.forEach(function(t){var e=h.props[t],n=e.diff,i=e.bgPos,r=e.steps,o="bgy"===t?"height":"width",s=l[o]-c[o];if(s<n)c[o]=l[o]+n-s;else if(n<s){var a=c[o]/wn(i,o,h.$el);a&&(h.props[t].steps=r.map(function(t){return t-(s-n)/a}))}l=nt.cover(u,c)}),t.dim=l}}},write:function(t){var e=t.dim;t.active?e&&Le(this.$el,{backgroundSize:e.width+"px "+e.height+"px",backgroundRepeat:"no-repeat"}):Le(this.$el,{backgroundSize:"",backgroundRepeat:""})},events:["resize"]},methods:{reset:function(){var n=this;K(this.getCss(0),function(t,e){return Le(n.$el,e,"")})},getCss:function(l){var d=this.props;return Object.keys(d).reduce(function(t,e){var n=d[e],i=n.steps,r=n.unit,o=n.pos,s=function(t,e,n){void 0===n&&(n=2);var i=qr(t,e),r=i[0],o=i[1],s=i[2];return(D(r)?r+Math.abs(r-o)*s*(r<o?1:-1):+o).toFixed(n)}(i,l);switch(e){case"x":case"y":r=r||"px",t.transform+=" translate"+p(e)+"("+F(s).toFixed("px"===r?0:2)+r+")";break;case"rotate":r=r||"deg",t.transform+=" rotate("+(s+r)+")";break;case"scale":t.transform+=" scale("+s+")";break;case"bgy":case"bgx":t["background-position-"+e[2]]="calc("+o+" + "+s+"px)";break;case"color":case"backgroundColor":case"borderColor":var a=qr(i,l),h=a[0],c=a[1],u=a[2];t[e]="rgba("+h.map(function(t,e){return t+=u*(c[e]-t),3===e?F(t):parseInt(t,10)}).join(",")+")";break;case"blur":r=r||"px",t.filter+=" blur("+(s+r)+")";break;case"hue":r=r||"deg",t.filter+=" hue-rotate("+(s+r)+")";break;case"fopacity":r=r||"%",t.filter+=" opacity("+(s+r)+")";break;case"grayscale":case"invert":case"saturate":case"sepia":r=r||"%",t.filter+=" "+e+"("+(s+r)+")";break;default:t[e]=s}return t},{transform:"",filter:""})}}};function qr(t,e){var n=t.length-1,i=Math.min(Math.floor(n*e),n-1),r=t.slice(i,i+2);return r.push(1===e?1:e%(1/n)*n),r}var Ur={mixins:[Yr],props:{target:String,viewport:Number,easing:Number},data:{target:!1,viewport:1,easing:1},computed:{target:function(t,e){var n=t.target;return function t(e){return e?"offsetTop"in e?e:t(e.parentNode):document.body}(n&&wt(n,e)||e)}},update:{read:function(t,e){var n=t.percent;if("scroll"!==e&&(n=!1),t.active){var i=n;return{percent:n=function(t,e){return Z(t*(1-(e-e*t)))}(mn(this.target)/(this.viewport||1),this.easing),style:i!==n&&this.getCss(n)}}},write:function(t){var e=t.style;t.active?e&&Le(this.$el,e):this.reset()},events:["scroll","resize"]}};var Xr={update:{write:function(){if(!this.stack.length&&!this.dragging){var t=this.getValidIndex(this.index);~this.prevIndex&&this.index===t||this.show(t)}},events:["resize"]}};function Kr(t,e,n){var i=Zr(t,e);return n?i-function(t,e){return Qr(e).width/2-Qr(t).width/2}(t,e):Math.min(i,Gr(e))}function Gr(t){return Math.max(0,Jr(t)-Qr(t).width)}function Jr(t){return eo(t).reduce(function(t,e){return Qr(e).width+t},0)}function Zr(t,e){return(on(t).left+(ht?Qr(t).width-Qr(e).width:0))*(ht?-1:1)}function Qr(t){return t.getBoundingClientRect()}function to(t,e,n){qt(t,Ut(e,!1,!1,n))}function eo(t){return W(t.children)}var no={mixins:[ei,Dr,Xr],props:{center:Boolean,sets:Boolean},data:{center:!1,sets:!1,attrItem:"uk-slider-item",selList:".uk-slider-items",selNav:".uk-slider-nav",clsContainer:"uk-slider-container",Transitioner:function(r,i,o,t){var e=t.center,s=t.easing,a=t.list,h=new ee,n=r?Kr(r,a,e):Kr(i,a,e)+Qr(i).width*o,c=i?Kr(i,a,e):n+Qr(r).width*o*(ht?-1:1);return{dir:o,show:function(t,e,n){void 0===e&&(e=0);var i=n?"linear":s;return t-=Math.round(t*Z(e,-1,1)),this.translate(e),r&&this.updateTranslates(),e=r?e:Z(e,0,1),to(this.getItemIn(),"itemin",{percent:e,duration:t,timing:i,dir:o}),r&&to(this.getItemIn(!0),"itemout",{percent:1-e,duration:t,timing:i,dir:o}),Xe.start(a,{transform:_r(-c*(ht?-1:1),"px")},t,i).then(h.resolve,Q),h.promise},stop:function(){return Xe.stop(a)},cancel:function(){Xe.cancel(a)},reset:function(){Le(a,"transform","")},forward:function(t,e){return void 0===e&&(e=this.percent()),Xe.cancel(a),this.show(t,e,!0)},translate:function(t){var e=this.getDistance()*o*(ht?-1:1);Le(a,"transform",_r(Z(e-e*t-c,-Jr(a),Qr(a).width)*(ht?-1:1),"px")),this.updateTranslates(),r&&(t=Z(t,-1,1),to(this.getItemIn(),"itemtranslatein",{percent:t,dir:o}),to(this.getItemIn(!0),"itemtranslateout",{percent:1-t,dir:o}))},percent:function(){return Math.abs((Le(a,"transform").split(",")[4]*(ht?-1:1)+n)/(c-n))},getDistance:function(){return Math.abs(c-n)},getItemIn:function(t){void 0===t&&(t=!1);var e=this.getActives(),n=G(eo(a),"offsetLeft"),i=ue(n,e[0<o*(t?-1:1)?e.length-1:0]);return~i&&n[i+(r&&!t?o:0)]},getActives:function(){var n=Kr(r||i,a,e);return G(eo(a).filter(function(t){var e=Zr(t,a);return n<=e&&e+Qr(t).width<=Qr(a).width+n}),"offsetLeft")},updateTranslates:function(){var n=this.getActives();eo(a).forEach(function(t){var e=b(n,t);to(t,"itemtranslate"+(e?"in":"out"),{percent:e?1:0,dir:t.offsetLeft<=i.offsetLeft?1:-1})})}}}},computed:{avgWidth:function(){return Jr(this.list)/this.length},finite:function(t){return t.finite||Jr(this.list)<Qr(this.list).width+function(t){return eo(t).reduce(function(t,e){return Math.max(t,Qr(e).width)},0)}(this.list)+this.center},maxIndex:function(){if(!this.finite||this.center&&!this.sets)return this.length-1;if(this.center)return X(this.sets);Le(this.slides,"order","");for(var t=Gr(this.list),e=this.length;e--;)if(Zr(this.list.children[e],this.list)<t)return Math.min(e+1,this.length-1);return 0},sets:function(t){var o=this,e=t.sets,s=Qr(this.list).width/(this.center?2:1),a=0,h=s,c=0;return!B(e=e&&this.slides.reduce(function(t,e,n){var i=Qr(e).width;if(a<c+i&&(!o.center&&n>o.maxIndex&&(n=o.maxIndex),!b(t,n))){var r=o.slides[n+1];o.center&&r&&i<h-Qr(r).width/2?h-=i:(h=s,t.push(n),a=c+s+(o.center?i/2:0))}return c+=i,t},[]))&&e},transitionOptions:function(){return{center:this.center,list:this.list}}},connected:function(){De(this.$el,this.clsContainer,!Te("."+this.clsContainer,this.$el))},update:{write:function(){var n=this;Ee("["+this.attrItem+"],[data-"+this.attrItem+"]",this.$el).forEach(function(t){var e=st(t,n.attrItem);n.maxIndex&&De(t,"uk-hidden",z(e)&&(n.sets&&!b(n.sets,F(e))||e>n.maxIndex))}),this.dragging||this.stack.length||this._getTransitioner().translate(1)},events:["resize"]},events:{beforeitemshow:function(t){!this.dragging&&this.sets&&this.stack.length<2&&!b(this.sets,this.index)&&(this.index=this.getValidIndex());var e=Math.abs(this.index-this.prevIndex+(0<this.dir&&this.index<this.prevIndex||this.dir<0&&this.index>this.prevIndex?(this.maxIndex+1)*this.dir:0));if(!this.dragging&&1<e){for(var n=0;n<e;n++)this.stack.splice(1,0,0<this.dir?"next":"previous");t.preventDefault()}else this.duration=zr(this.avgWidth/this.velocity)*(Qr(this.dir<0||!this.slides[this.prevIndex]?this.slides[this.index]:this.slides[this.prevIndex]).width/this.avgWidth),this.reorder()},itemshow:function(){P(this.prevIndex)||Ae(this._getTransitioner().getItemIn(),this.clsActive)},itemshown:function(){var e=this,n=this._getTransitioner(this.index).getActives();this.slides.forEach(function(t){return De(t,e.clsActive,b(n,t))}),this.sets&&!b(this.sets,F(this.index))||this.slides.forEach(function(t){return De(t,e.clsActivated,b(n,t))})}},methods:{reorder:function(){var n=this;if(Le(this.slides,"order",""),!this.finite){var i=0<this.dir&&this.slides[this.prevIndex]?this.prevIndex:this.index;if(this.slides.forEach(function(t,e){return Le(t,"order",0<n.dir&&e<i?1:n.dir<0&&e>=n.index?-1:"")}),this.center)for(var t=this.slides[i],e=Qr(this.list).width/2-Qr(t).width/2,r=0;0<e;){var o=this.getIndex(--r+i,i),s=this.slides[o];Le(s,"order",i<o?-2:-1),e-=Qr(s).width}}},getValidIndex:function(t,e){if(void 0===t&&(t=this.index),void 0===e&&(e=this.prevIndex),t=this.getIndex(t,e),!this.sets)return t;var n;do{if(b(this.sets,t))return t;n=t,t=this.getIndex(t+this.dir,e)}while(t!==n);return t}}},io={mixins:[Yr],data:{selItem:"!li"},computed:{item:function(t,e){return wt(t.selItem,e)}},events:[{name:"itemshown",self:!0,el:function(){return this.item},handler:function(){Le(this.$el,this.getCss(.5))}},{name:"itemin itemout",self:!0,el:function(){return this.item},handler:function(t){var e=t.type,n=t.detail,i=n.percent,r=n.duration,o=n.timing,s=n.dir;Xe.cancel(this.$el),Le(this.$el,this.getCss(oo(e,s,i))),Xe.start(this.$el,this.getCss(ro(e)?.5:0<s?1:0),r,o).catch(Q)}},{name:"transitioncanceled transitionend",self:!0,el:function(){return this.item},handler:function(){Xe.cancel(this.$el)}},{name:"itemtranslatein itemtranslateout",self:!0,el:function(){return this.item},handler:function(t){var e=t.type,n=t.detail,i=n.percent,r=n.dir;Xe.cancel(this.$el),Le(this.$el,this.getCss(oo(e,r,i)))}}]};function ro(t){return u(t,"in")}function oo(t,e,n){return n/=2,ro(t)?e<0?1-n:n:e<0?n:1-n}var so,ao=U({},Cr,{fade:{show:function(){return[{opacity:0,zIndex:0},{zIndex:-1}]},percent:function(t){return 1-Le(t,"opacity")},translate:function(t){return[{opacity:1-t,zIndex:0},{zIndex:-1}]}},scale:{show:function(){return[{opacity:0,transform:Nr(1.5),zIndex:0},{zIndex:-1}]},percent:function(t){return 1-Le(t,"opacity")},translate:function(t){return[{opacity:1-t,transform:Nr(1+.5*t),zIndex:0},{zIndex:-1}]}},pull:{show:function(t){return t<0?[{transform:_r(30),zIndex:-1},{transform:_r(),zIndex:0}]:[{transform:_r(-100),zIndex:0},{transform:_r(),zIndex:-1}]},percent:function(t,e,n){return n<0?1-Ar(e):Ar(t)},translate:function(t,e){return e<0?[{transform:_r(30*t),zIndex:-1},{transform:_r(-100*(1-t)),zIndex:0}]:[{transform:_r(100*-t),zIndex:0},{transform:_r(30*(1-t)),zIndex:-1}]}},push:{show:function(t){return t<0?[{transform:_r(100),zIndex:0},{transform:_r(),zIndex:-1}]:[{transform:_r(-30),zIndex:-1},{transform:_r(),zIndex:0}]},percent:function(t,e,n){return 0<n?1-Ar(e):Ar(t)},translate:function(t,e){return e<0?[{transform:_r(100*t),zIndex:0},{transform:_r(-30*(1-t)),zIndex:-1}]:[{transform:_r(-30*t),zIndex:-1},{transform:_r(100*(1-t)),zIndex:0}]}}}),ho={mixins:[ei,Br,Xr],props:{ratio:String,minHeight:Number,maxHeight:Number},data:{ratio:"16:9",minHeight:!1,maxHeight:!1,selList:".uk-slideshow-items",attrItem:"uk-slideshow-item",selNav:".uk-slideshow-nav",Animations:ao},update:{read:function(){var t=this.ratio.split(":").map(Number),e=t[0],n=t[1];return n=n*this.list.offsetWidth/e||0,this.minHeight&&(n=Math.max(this.minHeight,n)),this.maxHeight&&(n=Math.min(this.maxHeight,n)),{height:n-cn(this.list,"content-box")}},write:function(t){var e=t.height;0<e&&Le(this.list,"minHeight",e)},events:["resize"]}},co={mixins:[ei,xr],props:{group:String,threshold:Number,clsItem:String,clsPlaceholder:String,clsDrag:String,clsDragState:String,clsBase:String,clsNoDrag:String,clsEmpty:String,clsCustom:String,handle:String},data:{group:!1,threshold:5,clsItem:"uk-sortable-item",clsPlaceholder:"uk-sortable-placeholder",clsDrag:"uk-sortable-drag",clsDragState:"uk-drag",clsBase:"uk-sortable",clsNoDrag:"uk-sortable-nodrag",clsEmpty:"uk-sortable-empty",clsCustom:"",handle:!1},created:function(){var o=this;["init","start","move","end"].forEach(function(t){var r=o[t];o[t]=function(t){o.scrollY=window.pageYOffset;var e=te(t,"page"),n=e.x,i=e.y;o.pos={x:n,y:i},r(t)}})},events:{name:dt,passive:!1,handler:"init"},update:{write:function(){if(this.clsEmpty&&De(this.$el,this.clsEmpty,B(this.$el.children)),Le(this.handle?Ee(this.handle,this.$el):this.$el.children,{touchAction:"none",userSelect:"none"}),this.drag){var t=nn(window),e=t.right,n=t.bottom;nn(this.drag,{top:Z(this.pos.y+this.origin.top,0,n-this.drag.offsetHeight),left:Z(this.pos.x+this.origin.left,0,e-this.drag.offsetWidth)}),function s(t){var a=t.x;var h=t.y;clearTimeout(so);(e=document.elementFromPoint(a-window.pageXOffset,h-window.pageYOffset),n=fo(),function(t,e){var n=[];for(;e(t)&&n.unshift(t),t=t&&t.parentElement;);return n}(e,function(t){return t===n||lo.test(Le(t,"overflow"))})).some(function(t){var e=t.scrollTop,n=t.scrollHeight;fo()===t&&(t=window,n-=window.innerHeight);var i=nn(t),r=i.top,o=i.bottom;if(r<h&&h<r+30?e-=5:h<o&&o-20<h&&(e+=5),0<e&&e<n)return so=setTimeout(function(){gn(t,e),s({x:a,y:h})},10)});var e,n}(this.pos)}}},methods:{init:function(t){var e=t.target,n=t.button,i=t.defaultPrevented,r=W(this.$el.children).filter(function(t){return Wt(e,t)})[0];!r||i||0<n||Ft(e)||Wt(e,"."+this.clsNoDrag)||this.handle&&!Wt(e,this.handle)||(t.preventDefault(),this.touched=[this],this.placeholder=r,this.origin=U({target:e,index:ue(r)},this.pos),Vt(document,ft,this.move),Vt(document,pt,this.end),Vt(window,"scroll",this.scroll),this.threshold||this.start(t))},start:function(t){this.drag=pe(this.$container,this.placeholder.outerHTML.replace(/^<li/i,"<div").replace(/li>$/i,"div>")),Le(this.drag,U({boxSizing:"border-box",width:this.placeholder.offsetWidth,height:this.placeholder.offsetHeight,overflow:"hidden"},Le(this.placeholder,["paddingLeft","paddingRight","paddingTop","paddingBottom"]))),it(this.drag,"uk-no-boot",""),Ae(this.drag,this.clsDrag,this.clsCustom),sn(this.drag.firstElementChild,sn(this.placeholder.firstElementChild));var e=nn(this.placeholder),n=e.left,i=e.top;U(this.origin,{left:n-this.pos.x,top:i-this.pos.y}),Ae(this.placeholder,this.clsPlaceholder),Ae(this.$el.children,this.clsItem),Ae(document.documentElement,this.clsDragState),qt(this.$el,"start",[this,this.placeholder]),this.move(t)},move:function(t){if(this.drag){this.$emit();var e="mousemove"===t.type?t.target:document.elementFromPoint(this.pos.x-window.pageXOffset,this.pos.y-window.pageYOffset),n=this.getSortable(e),i=this.getSortable(this.placeholder),r=n!==i;if(n&&!Wt(e,this.placeholder)&&(!r||n.group&&n.group===i.group)){if(e=n.$el===e.parentNode&&e||W(n.$el.children).filter(function(t){return Wt(e,t)})[0],r)i.remove(this.placeholder);else if(!e)return;n.insert(this.placeholder,e),b(this.touched,n)||this.touched.push(n)}}else(Math.abs(this.pos.x-this.origin.x)>this.threshold||Math.abs(this.pos.y-this.origin.y)>this.threshold)&&this.start(t)},end:function(t){if(Rt(document,ft,this.move),Rt(document,pt,this.end),Rt(window,"scroll",this.scroll),this.drag){clearTimeout(so);var e=this.getSortable(this.placeholder);this===e?this.origin.index!==ue(this.placeholder)&&qt(this.$el,"moved",[this,this.placeholder]):(qt(e.$el,"added",[e,this.placeholder]),qt(this.$el,"removed",[this,this.placeholder])),qt(this.$el,"stop",[this,this.placeholder]),we(this.drag),this.drag=null;var n=this.touched.map(function(t){return t.clsPlaceholder+" "+t.clsItem}).join(" ");this.touched.forEach(function(t){return _e(t.$el.children,n)}),_e(document.documentElement,this.clsDragState)}else"touchend"===t.type&&t.target.click()},scroll:function(){var t=window.pageYOffset;t!==this.scrollY&&(this.pos.y+=t-this.scrollY,this.scrollY=t,this.$emit())},insert:function(t,e){var n=this;Ae(this.$el.children,this.clsItem);function i(){e?!Wt(t,n.$el)||function(t,e){return t.parentNode===e.parentNode&&ue(t)>ue(e)}(t,e)?me(e,t):ge(e,t):pe(n.$el,t)}this.animation?this.animate(i):i()},remove:function(t){Wt(t,this.$el)&&(Le(this.handle?Ee(this.handle,t):t,{touchAction:"",userSelect:""}),this.animation?this.animate(function(){return we(t)}):we(t))},getSortable:function(t){return t&&(this.$getComponent(t,"sortable")||this.getSortable(t.parentNode))}}};var uo,lo=/auto|scroll/;function fo(){return document.scrollingElement||document.documentElement}var po,mo,go,vo=[],wo={mixins:[Zi,ni,ci],args:"title",props:{delay:Number,title:String},data:{pos:"top",title:"",delay:0,animation:["uk-animation-scale-up"],duration:100,cls:"uk-active",clsPos:"uk-tooltip"},beforeConnect:function(){this._hasTitle=rt(this.$el,"title"),it(this.$el,{title:"","aria-expanded":!1})},disconnected:function(){this.hide(),it(this.$el,{title:this._hasTitle?this.title:null,"aria-expanded":null})},methods:{show:function(){var e=this;!this.isActive()&&this.title&&(vo.forEach(function(t){return t.hide()}),vo.push(this),this._unbind=Vt(document,pt,function(t){return!Wt(t.target,e.$el)&&e.hide()}),clearTimeout(this.showTimer),this.showTimer=setTimeout(function(){e._show(),e.hideTimer=setInterval(function(){Ht(e.$el)||e.hide()},150)},this.delay))},hide:function(){this.isActive()&&!_t(this.$el,"input:focus")&&(vo.splice(vo.indexOf(this),1),clearTimeout(this.showTimer),clearInterval(this.hideTimer),it(this.$el,"aria-expanded",!1),this.toggleElement(this.tooltip,!1),this.tooltip&&we(this.tooltip),this.tooltip=!1,this._unbind())},_show:function(){this.tooltip=pe(this.container,'<div class="'+this.clsPos+'" aria-expanded="true" aria-hidden> <div class="'+this.clsPos+'-inner">'+this.title+"</div> </div>"),this.positionAt(this.tooltip,this.$el),this.origin="y"===this.getAxis()?fn(this.dir)+"-"+this.align:this.align+"-"+fn(this.dir),this.toggleElement(this.tooltip,!0)},isActive:function(){return b(vo,this)}},events:(uo={focus:"show",blur:"hide"},uo[mt+" "+gt]=function(t){Qt(t)||(t.type===mt?this.show():this.hide())},uo[dt]=function(t){Qt(t)&&(this.isActive()?this.hide():this.show())},uo)},bo={props:{allow:String,clsDragover:String,concurrent:Number,maxSize:Number,method:String,mime:String,msgInvalidMime:String,msgInvalidName:String,msgInvalidSize:String,multiple:Boolean,name:String,params:Object,type:String,url:String},data:{allow:!1,clsDragover:"uk-dragover",concurrent:1,maxSize:0,method:"POST",mime:!1,msgInvalidMime:"Invalid File Type: %s",msgInvalidName:"Invalid File Name: %s",msgInvalidSize:"Invalid File Size: %s Kilobytes Max",multiple:!1,name:"files[]",params:{},type:"",url:"",abort:Q,beforeAll:Q,beforeSend:Q,complete:Q,completeAll:Q,error:Q,fail:Q,load:Q,loadEnd:Q,loadStart:Q,progress:Q},events:{change:function(t){_t(t.target,'input[type="file"]')&&(t.preventDefault(),t.target.files&&this.upload(t.target.files),t.target.value="")},drop:function(t){xo(t);var e=t.dataTransfer;e&&e.files&&(_e(this.$el,this.clsDragover),this.upload(e.files))},dragenter:function(t){xo(t)},dragover:function(t){xo(t),Ae(this.$el,this.clsDragover)},dragleave:function(t){xo(t),_e(this.$el,this.clsDragover)}},methods:{upload:function(t){var i=this;if(t.length){qt(this.$el,"upload",[t]);for(var e=0;e<t.length;e++){if(this.maxSize&&1e3*this.maxSize<t[e].size)return void this.fail(this.msgInvalidSize.replace("%s",this.maxSize));if(this.allow&&!yo(this.allow,t[e].name))return void this.fail(this.msgInvalidName.replace("%s",this.allow));if(this.mime&&!yo(this.mime,t[e].type))return void this.fail(this.msgInvalidMime.replace("%s",this.mime))}this.multiple||(t=[t[0]]),this.beforeAll(this,t);var r=function(t,e){for(var n=[],i=0;i<t.length;i+=e){for(var r=[],o=0;o<e;o++)r.push(t[i+o]);n.push(r)}return n}(t,this.concurrent),o=function(t){var e=new FormData;for(var n in t.forEach(function(t){return e.append(i.name,t)}),i.params)e.append(n,i.params[n]);ae(i.url,{data:e,method:i.method,responseType:i.type,beforeSend:function(t){var e=t.xhr;e.upload&&Vt(e.upload,"progress",i.progress),["loadStart","load","loadEnd","abort"].forEach(function(t){return Vt(e,t.toLowerCase(),i[t])}),i.beforeSend(t)}}).then(function(t){i.complete(t),r.length?o(r.shift()):i.completeAll(t)},function(t){return i.error(t)})};o(r.shift())}}}};function yo(t,e){return e.match(new RegExp("^"+t.replace(/\//g,"\\/").replace(/\*\*/g,"(\\/[^\\/]+)*").replace(/\*/g,"[^\\/]+").replace(/((?!\\))\?/g,"$1.")+"$","i"))}function xo(t){t.preventDefault(),t.stopPropagation()}function ko(){Io(document.body,mo),kn.flush(),new MutationObserver(function(t){return t.forEach($o)}).observe(document,{childList:!0,subtree:!0,characterData:!0,attributes:!0}),po._initialized=!0}function $o(t){var e=t.target;("attributes"!==t.type?function(t){for(var e=t.addedNodes,n=t.removedNodes,i=0;i<e.length;i++)Io(e[i],mo);for(var r=0;r<n.length;r++)Io(n[r],go);return!0}(t):function(t){var e=t.target,n=t.attributeName;if("href"===n)return!0;var i=Hn(n);if(!(i&&i in po))return;if(rt(e,n))return po[i](e),!0;var r=po.getComponent(e,i);if(r)return r.$destroy(),!0}(t))&&po.update(e)}function Io(t,e){if(1===t.nodeType&&!rt(t,"uk-no-boot"))for(e(t),t=t.firstElementChild;t;){var n=t.nextElementSibling;Io(t,e),t=n}}return Ln.component("countdown",wr),Ln.component("filter",Sr),Ln.component("lightbox",Fr),Ln.component("lightboxPanel",Pr),Ln.component("notification",Vr),Ln.component("parallax",Ur),Ln.component("slider",no),Ln.component("sliderParallax",io),Ln.component("slideshow",ho),Ln.component("slideshowParallax",io),Ln.component("sortable",co),Ln.component("tooltip",wo),Ln.component("upload",bo),mo=(po=Ln).connect,go=po.disconnect,"MutationObserver"in window&&(document.body?kn.read(ko):new MutationObserver(function(){document.body&&(this.disconnect(),ko())}).observe(document,{childList:!0,subtree:!0})),Ln});",
{"status":false}
],

[
"uikit-icons.min.js_3.2.0",
"/*! UIkit 3.2.0 | http://www.getuikit.com | (c) 2014 - 2019 YOOtheme | MIT License */

!function(t,i){"object"==typeof exports&&"undefined"!=typeof module?module.exports=i():"function"==typeof define&&define.amd?define("uikiticons",i):(t=t||self).UIkitIcons=i()}(this,function(){"use strict";function i(t){i.installed||t.icon.add({"500px":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M9.624,11.866c-0.141,0.132,0.479,0.658,0.662,0.418c0.051-0.046,0.607-0.61,0.662-0.664c0,0,0.738,0.719,0.814,0.719 c0.1,0,0.207-0.055,0.322-0.17c0.27-0.269,0.135-0.416,0.066-0.495l-0.631-0.616l0.658-0.668c0.146-0.156,0.021-0.314-0.1-0.449 c-0.182-0.18-0.359-0.226-0.471-0.125l-0.656,0.654l-0.654-0.654c-0.033-0.034-0.08-0.045-0.124-0.045 c-0.079,0-0.191,0.068-0.307,0.181c-0.202,0.202-0.247,0.351-0.133,0.462l0.665,0.665L9.624,11.866z"/><path d="M11.066,2.884c-1.061,0-2.185,0.248-3.011,0.604c-0.087,0.034-0.141,0.106-0.15,0.205C7.893,3.784,7.919,3.909,7.982,4.066 c0.05,0.136,0.187,0.474,0.452,0.372c0.844-0.326,1.779-0.507,2.633-0.507c0.963,0,1.9,0.191,2.781,0.564 c0.695,0.292,1.357,0.719,2.078,1.34c0.051,0.044,0.105,0.068,0.164,0.068c0.143,0,0.273-0.137,0.389-0.271 c0.191-0.214,0.324-0.395,0.135-0.575c-0.686-0.654-1.436-1.138-2.363-1.533C13.24,3.097,12.168,2.884,11.066,2.884z"/><path d="M16.43,15.747c-0.092-0.028-0.242,0.05-0.309,0.119l0,0c-0.652,0.652-1.42,1.169-2.268,1.521 c-0.877,0.371-1.814,0.551-2.779,0.551c-0.961,0-1.896-0.189-2.775-0.564c-0.848-0.36-1.612-0.879-2.268-1.53 c-0.682-0.688-1.196-1.455-1.529-2.268c-0.325-0.799-0.471-1.643-0.471-1.643c-0.045-0.24-0.258-0.249-0.567-0.203 c-0.128,0.021-0.519,0.079-0.483,0.36v0.01c0.105,0.644,0.289,1.284,0.545,1.895c0.417,0.969,1.002,1.849,1.756,2.604 c0.757,0.754,1.636,1.34,2.604,1.757C8.901,18.785,9.97,19,11.088,19c1.104,0,2.186-0.215,3.188-0.645 c1.838-0.896,2.604-1.757,2.604-1.757c0.182-0.204,0.227-0.317-0.1-0.643C16.779,15.956,16.525,15.774,16.43,15.747z"/><path d="M5.633,13.287c0.293,0.71,0.723,1.341,1.262,1.882c0.54,0.54,1.172,0.971,1.882,1.264c0.731,0.303,1.509,0.461,2.298,0.461 c0.801,0,1.578-0.158,2.297-0.461c0.711-0.293,1.344-0.724,1.883-1.264c0.543-0.541,0.971-1.172,1.264-1.882 c0.314-0.721,0.463-1.5,0.463-2.298c0-0.79-0.148-1.569-0.463-2.289c-0.293-0.699-0.721-1.329-1.264-1.881 c-0.539-0.541-1.172-0.959-1.867-1.263c-0.721-0.303-1.5-0.461-2.299-0.461c-0.802,0-1.613,0.159-2.322,0.461 c-0.577,0.25-1.544,0.867-2.119,1.454v0.012V2.108h8.16C15.1,2.104,15.1,1.69,15.1,1.552C15.1,1.417,15.1,1,14.809,1H5.915 C5.676,1,5.527,1.192,5.527,1.384v6.84c0,0.214,0.273,0.372,0.529,0.428c0.5,0.105,0.614-0.056,0.737-0.224l0,0 c0.18-0.273,0.776-0.884,0.787-0.894c0.901-0.905,2.117-1.408,3.416-1.408c1.285,0,2.5,0.501,3.412,1.408 c0.914,0.914,1.408,2.122,1.408,3.405c0,1.288-0.508,2.496-1.408,3.405c-0.9,0.896-2.152,1.406-3.438,1.406 c-0.877,0-1.711-0.229-2.433-0.671v-4.158c0-0.553,0.237-1.151,0.643-1.614c0.462-0.519,1.094-0.799,1.782-0.799 c0.664,0,1.293,0.253,1.758,0.715c0.459,0.459,0.709,1.071,0.709,1.723c0,1.385-1.094,2.468-2.488,2.468 c-0.273,0-0.769-0.121-0.781-0.125c-0.281-0.087-0.405,0.306-0.438,0.436c-0.159,0.496,0.079,0.585,0.123,0.607 c0.452,0.137,0.743,0.157,1.129,0.157c1.973,0,3.572-1.6,3.572-3.57c0-1.964-1.6-3.552-3.572-3.552c-0.97,0-1.872,0.36-2.546,1.038 c-0.656,0.631-1.027,1.487-1.027,2.322v3.438v-0.011c-0.372-0.42-0.732-1.041-0.981-1.682c-0.102-0.248-0.315-0.202-0.607-0.113 c-0.135,0.035-0.519,0.157-0.44,0.439C5.372,12.799,5.577,13.164,5.633,13.287z"/></svg>',album:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="5" y="2" width="10" height="1"/><rect x="3" y="4" width="14" height="1"/><rect fill="none" stroke="#000" x="1.5" y="6.5" width="17" height="11"/></svg>',"arrow-down":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="10.5,16.08 5.63,10.66 6.37,10 10.5,14.58 14.63,10 15.37,10.66"/><line fill="none" stroke="#000" x1="10.5" y1="4" x2="10.5" y2="15"/></svg>',"arrow-left":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" points="10 14 5 9.5 10 5"/><line fill="none" stroke="#000" x1="16" y1="9.5" x2="5" y2="9.52"/></svg>',"arrow-right":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" points="10 5 15 9.5 10 14"/><line fill="none" stroke="#000" x1="4" y1="9.5" x2="15" y2="9.5"/></svg>',"arrow-up":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="10.5,4 15.37,9.4 14.63,10.08 10.5,5.49 6.37,10.08 5.63,9.4"/><line fill="none" stroke="#000" x1="10.5" y1="16" x2="10.5" y2="5"/></svg>',ban:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="10" cy="10" r="9"/><line fill="none" stroke="#000" stroke-width="1.1" x1="4" y1="3.5" x2="16" y2="16.5"/></svg>',behance:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M9.5,10.6c-0.4-0.5-0.9-0.9-1.6-1.1c1.7-1,2.2-3.2,0.7-4.7C7.8,4,6.3,4,5.2,4C3.5,4,1.7,4,0,4v12c1.7,0,3.4,0,5.2,0 c1,0,2.1,0,3.1-0.5C10.2,14.6,10.5,12.3,9.5,10.6L9.5,10.6z M5.6,6.1c1.8,0,1.8,2.7-0.1,2.7c-1,0-2,0-2.9,0V6.1H5.6z M2.6,13.8v-3.1 c1.1,0,2.1,0,3.2,0c2.1,0,2.1,3.2,0.1,3.2L2.6,13.8z"/><path d="M19.9,10.9C19.7,9.2,18.7,7.6,17,7c-4.2-1.3-7.3,3.4-5.3,7.1c0.9,1.7,2.8,2.3,4.7,2.1c1.7-0.2,2.9-1.3,3.4-2.9h-2.2 c-0.4,1.3-2.4,1.5-3.5,0.6c-0.4-0.4-0.6-1.1-0.6-1.7H20C20,11.7,19.9,10.9,19.9,10.9z M13.5,10.6c0-1.6,2.3-2.7,3.5-1.4 c0.4,0.4,0.5,0.9,0.6,1.4H13.5L13.5,10.6z"/><rect x="13" y="4" width="5" height="1.4"/></svg>',bell:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.1" d="M17,15.5 L3,15.5 C2.99,14.61 3.79,13.34 4.1,12.51 C4.58,11.3 4.72,10.35 5.19,7.01 C5.54,4.53 5.89,3.2 7.28,2.16 C8.13,1.56 9.37,1.5 9.81,1.5 L9.96,1.5 C9.96,1.5 11.62,1.41 12.67,2.17 C14.08,3.2 14.42,4.54 14.77,7.02 C15.26,10.35 15.4,11.31 15.87,12.52 C16.2,13.34 17.01,14.61 17,15.5 L17,15.5 Z"/><path fill="none" stroke="#000" d="M12.39,16 C12.39,17.37 11.35,18.43 9.91,18.43 C8.48,18.43 7.42,17.37 7.42,16"/></svg>',bold:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M5,15.3 C5.66,15.3 5.9,15 5.9,14.53 L5.9,5.5 C5.9,4.92 5.56,4.7 5,4.7 L5,4 L8.95,4 C12.6,4 13.7,5.37 13.7,6.9 C13.7,7.87 13.14,9.17 10.86,9.59 L10.86,9.7 C13.25,9.86 14.29,11.28 14.3,12.54 C14.3,14.47 12.94,16 9,16 L5,16 L5,15.3 Z M9,9.3 C11.19,9.3 11.8,8.5 11.85,7 C11.85,5.65 11.3,4.8 9,4.8 L7.67,4.8 L7.67,9.3 L9,9.3 Z M9.185,15.22 C11.97,15 12.39,14 12.4,12.58 C12.4,11.15 11.39,10 9,10 L7.67,10 L7.67,15 L9.18,15 Z"/></svg>',bolt:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M4.74,20 L7.73,12 L3,12 L15.43,1 L12.32,9 L17.02,9 L4.74,20 L4.74,20 L4.74,20 Z M9.18,11 L7.1,16.39 L14.47,10 L10.86,10 L12.99,4.67 L5.61,11 L9.18,11 L9.18,11 L9.18,11 Z"/></svg>',bookmark:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon fill="none" stroke="#000" points="5.5 1.5 15.5 1.5 15.5 17.5 10.5 12.5 5.5 17.5"/></svg>',calendar:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M 2,3 2,17 18,17 18,3 2,3 Z M 17,16 3,16 3,8 17,8 17,16 Z M 17,7 3,7 3,4 17,4 17,7 Z"/><rect width="1" height="3" x="6" y="2"/><rect width="1" height="3" x="13" y="2"/></svg>',camera:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="10" cy="10.8" r="3.8"/><path fill="none" stroke="#000" d="M1,4.5 C0.7,4.5 0.5,4.7 0.5,5 L0.5,17 C0.5,17.3 0.7,17.5 1,17.5 L19,17.5 C19.3,17.5 19.5,17.3 19.5,17 L19.5,5 C19.5,4.7 19.3,4.5 19,4.5 L13.5,4.5 L13.5,2.9 C13.5,2.6 13.3,2.5 13,2.5 L7,2.5 C6.7,2.5 6.5,2.6 6.5,2.9 L6.5,4.5 L1,4.5 L1,4.5 Z"/></svg>',cart:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle cx="7.3" cy="17.3" r="1.4"/><circle cx="13.3" cy="17.3" r="1.4"/><polyline fill="none" stroke="#000" points="0 2 3.2 4 5.3 12.5 16 12.5 18 6.5 8 6.5"/></svg>',check:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.1" points="4,10 8,15 17,4"/></svg>',"chevron-double-left":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.03" points="10 14 6 10 10 6"/><polyline fill="none" stroke="#000" stroke-width="1.03" points="14 14 10 10 14 6"/></svg>',"chevron-double-right":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.03" points="10 6 14 10 10 14"/><polyline fill="none" stroke="#000" stroke-width="1.03" points="6 6 10 10 6 14"/></svg>',"chevron-down":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.03" points="16 7 10 13 4 7"/></svg>',"chevron-left":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.03" points="13 16 7 10 13 4"/></svg>',"chevron-right":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.03" points="7 4 13 10 7 16"/></svg>',"chevron-up":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.03" points="4 13 10 7 16 13"/></svg>',clock:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="10" cy="10" r="9"/><rect x="9" y="4" width="1" height="7"/><path fill="none" stroke="#000" stroke-width="1.1" d="M13.018,14.197 L9.445,10.625"/></svg>',close:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.06" d="M16,16 L4,4"/><path fill="none" stroke="#000" stroke-width="1.06" d="M16,4 L4,16"/></svg>',"cloud-download":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.1" d="M6.5,14.61 L3.75,14.61 C1.96,14.61 0.5,13.17 0.5,11.39 C0.5,9.76 1.72,8.41 3.3,8.2 C3.38,5.31 5.75,3 8.68,3 C11.19,3 13.31,4.71 13.89,7.02 C14.39,6.8 14.93,6.68 15.5,6.68 C17.71,6.68 19.5,8.45 19.5,10.64 C19.5,12.83 17.71,14.6 15.5,14.6 L12.5,14.6"/><polyline fill="none" stroke="#000" points="11.75 16 9.5 18.25 7.25 16"/><path fill="none" stroke="#000" d="M9.5,18 L9.5,9.5"/></svg>',"cloud-upload":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.1" d="M6.5,14.61 L3.75,14.61 C1.96,14.61 0.5,13.17 0.5,11.39 C0.5,9.76 1.72,8.41 3.31,8.2 C3.38,5.31 5.75,3 8.68,3 C11.19,3 13.31,4.71 13.89,7.02 C14.39,6.8 14.93,6.68 15.5,6.68 C17.71,6.68 19.5,8.45 19.5,10.64 C19.5,12.83 17.71,14.6 15.5,14.6 L12.5,14.6"/><polyline fill="none" stroke="#000" points="7.25 11.75 9.5 9.5 11.75 11.75"/><path fill="none" stroke="#000" d="M9.5,18 L9.5,9.5"/></svg>',code:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.01" points="13,4 19,10 13,16"/><polyline fill="none" stroke="#000" stroke-width="1.01" points="7,4 1,10 7,16"/></svg>',cog:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" cx="9.997" cy="10" r="3.31"/><path fill="none" stroke="#000" d="M18.488,12.285 L16.205,16.237 C15.322,15.496 14.185,15.281 13.303,15.791 C12.428,16.289 12.047,17.373 12.246,18.5 L7.735,18.5 C7.938,17.374 7.553,16.299 6.684,15.791 C5.801,15.27 4.655,15.492 3.773,16.237 L1.5,12.285 C2.573,11.871 3.317,10.999 3.317,9.991 C3.305,8.98 2.573,8.121 1.5,7.716 L3.765,3.784 C4.645,4.516 5.794,4.738 6.687,4.232 C7.555,3.722 7.939,2.637 7.735,1.5 L12.263,1.5 C12.072,2.637 12.441,3.71 13.314,4.22 C14.206,4.73 15.343,4.516 16.225,3.794 L18.487,7.714 C17.404,8.117 16.661,8.988 16.67,10.009 C16.672,11.018 17.415,11.88 18.488,12.285 L18.488,12.285 Z"/></svg>',comment:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M6,18.71 L6,14 L1,14 L1,1 L19,1 L19,14 L10.71,14 L6,18.71 L6,18.71 Z M2,13 L7,13 L7,16.29 L10.29,13 L18,13 L18,2 L2,2 L2,13 L2,13 Z"/></svg>',commenting:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon fill="none" stroke="#000" points="1.5,1.5 18.5,1.5 18.5,13.5 10.5,13.5 6.5,17.5 6.5,13.5 1.5,13.5"/><circle cx="10" cy="8" r="1"/><circle cx="6" cy="8" r="1"/><circle cx="14" cy="8" r="1"/></svg>',comments:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" points="2 0.5 19.5 0.5 19.5 13"/><path d="M5,19.71 L5,15 L0,15 L0,2 L18,2 L18,15 L9.71,15 L5,19.71 L5,19.71 L5,19.71 Z M1,14 L6,14 L6,17.29 L9.29,14 L17,14 L17,3 L1,3 L1,14 L1,14 L1,14 Z"/></svg>',copy:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect fill="none" stroke="#000" x="3.5" y="2.5" width="12" height="16"/><polyline fill="none" stroke="#000" points="5 0.5 17.5 0.5 17.5 17"/></svg>',"credit-card":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect fill="none" stroke="#000" x="1.5" y="4.5" width="17" height="12"/><rect x="1" y="7" width="18" height="3"/></svg>',database:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><ellipse fill="none" stroke="#000" cx="10" cy="4.64" rx="7.5" ry="3.14"/><path fill="none" stroke="#000" d="M17.5,8.11 C17.5,9.85 14.14,11.25 10,11.25 C5.86,11.25 2.5,9.84 2.5,8.11"/><path fill="none" stroke="#000" d="M17.5,11.25 C17.5,12.99 14.14,14.39 10,14.39 C5.86,14.39 2.5,12.98 2.5,11.25"/><path fill="none" stroke="#000" d="M17.49,4.64 L17.5,14.36 C17.5,16.1 14.14,17.5 10,17.5 C5.86,17.5 2.5,16.09 2.5,14.36 L2.5,4.64"/></svg>',desktop:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="8" y="15" width="1" height="2"/><rect x="11" y="15" width="1" height="2"/><rect x="5" y="16" width="10" height="1"/><rect fill="none" stroke="#000" x="1.5" y="3.5" width="17" height="11"/></svg>',download:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" points="14,10 9.5,14.5 5,10"/><rect x="3" y="17" width="13" height="1"/><line fill="none" stroke="#000" x1="9.5" y1="13.91" x2="9.5" y2="3"/></svg>',dribbble:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.4" d="M1.3,8.9c0,0,5,0.1,8.6-1c1.4-0.4,2.6-0.9,4-1.9 c1.4-1.1,2.5-2.5,2.5-2.5"/><path fill="none" stroke="#000" stroke-width="1.4" d="M3.9,16.6c0,0,1.7-2.8,3.5-4.2 c1.8-1.3,4-2,5.7-2.2C16,10,19,10.6,19,10.6"/><path fill="none" stroke="#000" stroke-width="1.4" d="M6.9,1.6c0,0,3.3,4.6,4.2,6.8 c0.4,0.9,1.3,3.1,1.9,5.2c0.6,2,0.9,4.4,0.9,4.4"/><circle fill="none" stroke="#000" stroke-width="1.4" cx="10" cy="10" r="9"/></svg>',etsy:'<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20"><path d="M8,4.26C8,4.07,8,4,8.31,4h4.46c.79,0,1.22.67,1.53,1.91l.25,1h.76c.14-2.82.26-4,.26-4S13.65,3,12.52,3H6.81L3.75,2.92v.84l1,.2c.73.11.9.27,1,1,0,0,.06,2,.06,5.17s-.06,5.14-.06,5.14c0,.59-.23.81-1,.94l-1,.2v.84l3.06-.1h5.11c1.15,0,3.82.1,3.82.1,0-.7.45-3.88.51-4.22h-.73l-.76,1.69a2.25,2.25,0,0,1-2.45,1.47H9.4c-1,0-1.44-.4-1.44-1.24V10.44s2.16,0,2.86.06c.55,0,.85.19,1.06,1l.23,1H13L12.9,9.94,13,7.41h-.85l-.28,1.13c-.16.74-.28.84-1,1-1,.1-2.89.09-2.89.09Z"/></svg>',expand:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="13 2 18 2 18 7 17 7 17 3 13 3"/><polygon points="2 13 3 13 3 17 7 17 7 18 2 18"/><path fill="none" stroke="#000" stroke-width="1.1" d="M11,9 L17,3"/><path fill="none" stroke="#000" stroke-width="1.1" d="M3,17 L9,11"/></svg>',facebook:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M11,10h2.6l0.4-3H11V5.3c0-0.9,0.2-1.5,1.5-1.5H14V1.1c-0.3,0-1-0.1-2.1-0.1C9.6,1,8,2.4,8,5v2H5.5v3H8v8h3V10z"/></svg>',"file-edit":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" d="M18.65,1.68 C18.41,1.45 18.109,1.33 17.81,1.33 C17.499,1.33 17.209,1.45 16.98,1.68 L8.92,9.76 L8,12.33 L10.55,11.41 L18.651,3.34 C19.12,2.87 19.12,2.15 18.65,1.68 L18.65,1.68 L18.65,1.68 Z"/><polyline fill="none" stroke="#000" points="16.5 8.482 16.5 18.5 3.5 18.5 3.5 1.5 14.211 1.5"/></svg>',"file-pdf":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect fill="none" stroke="#000" width="13" height="17" x="3.5" y="1.5"/><path d="M14.65 11.67c-.48.3-1.37-.19-1.79-.37a4.65 4.65 0 0 1 1.49.06c.35.1.36.28.3.31zm-6.3.06l.43-.79a14.7 14.7 0 0 0 .75-1.64 5.48 5.48 0 0 0 1.25 1.55l.2.15a16.36 16.36 0 0 0-2.63.73zM9.5 5.32c.2 0 .32.5.32.97a1.99 1.99 0 0 1-.23 1.04 5.05 5.05 0 0 1-.17-1.3s0-.71.08-.71zm-3.9 9a4.35 4.35 0 0 1 1.21-1.46l.24-.22a4.35 4.35 0 0 1-1.46 1.68zm9.23-3.3a2.05 2.05 0 0 0-1.32-.3 11.07 11.07 0 0 0-1.58.11 4.09 4.09 0 0 1-.74-.5 5.39 5.39 0 0 1-1.32-2.06 10.37 10.37 0 0 0 .28-2.62 1.83 1.83 0 0 0-.07-.25.57.57 0 0 0-.52-.4H9.4a.59.59 0 0 0-.6.38 6.95 6.95 0 0 0 .37 3.14c-.26.63-1 2.12-1 2.12-.3.58-.57 1.08-.82 1.5l-.8.44A3.11 3.11 0 0 0 5 14.16a.39.39 0 0 0 .15.42l.24.13c1.15.56 2.28-1.74 2.66-2.42a23.1 23.1 0 0 1 3.59-.85 4.56 4.56 0 0 0 2.91.8.5.5 0 0 0 .3-.21 1.1 1.1 0 0 0 .12-.75.84.84 0 0 0-.14-.25z"/></svg>',"file-text":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect fill="none" stroke="#000" width="13" height="17" x="3.5" y="1.5"/><line fill="none" stroke="#000" x1="6" x2="12" y1="12.5" y2="12.5"/><line fill="none" stroke="#000" x1="6" x2="14" y1="8.5" y2="8.5"/><line fill="none" stroke="#000" x1="6" x2="14" y1="6.5" y2="6.5"/><line fill="none" stroke="#000" x1="6" x2="14" y1="10.5" y2="10.5"/></svg>',file:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect fill="none" stroke="#000" x="3.5" y="1.5" width="13" height="17"/></svg>',flickr:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle cx="5.5" cy="9.5" r="3.5"/><circle cx="14.5" cy="9.5" r="3.5"/></svg>',folder:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon fill="none" stroke="#000" points="9.5 5.5 8.5 3.5 1.5 3.5 1.5 16.5 18.5 16.5 18.5 5.5"/></svg>',forward:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M2.47,13.11 C4.02,10.02 6.27,7.85 9.04,6.61 C9.48,6.41 10.27,6.13 11,5.91 L11,2 L18.89,9 L11,16 L11,12.13 C9.25,12.47 7.58,13.19 6.02,14.25 C3.03,16.28 1.63,18.54 1.63,18.54 C1.63,18.54 1.38,15.28 2.47,13.11 L2.47,13.11 Z M5.3,13.53 C6.92,12.4 9.04,11.4 12,10.92 L12,13.63 L17.36,9 L12,4.25 L12,6.8 C11.71,6.86 10.86,7.02 9.67,7.49 C6.79,8.65 4.58,10.96 3.49,13.08 C3.18,13.7 2.68,14.87 2.49,16 C3.28,15.05 4.4,14.15 5.3,13.53 L5.3,13.53 Z"/></svg>',foursquare:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M15.23,2 C15.96,2 16.4,2.41 16.5,2.86 C16.57,3.15 16.56,3.44 16.51,3.73 C16.46,4.04 14.86,11.72 14.75,12.03 C14.56,12.56 14.16,12.82 13.61,12.83 C13.03,12.84 11.09,12.51 10.69,13 C10.38,13.38 7.79,16.39 6.81,17.53 C6.61,17.76 6.4,17.96 6.08,17.99 C5.68,18.04 5.29,17.87 5.17,17.45 C5.12,17.28 5.1,17.09 5.1,16.91 C5.1,12.4 4.86,7.81 5.11,3.31 C5.17,2.5 5.81,2.12 6.53,2 L15.23,2 L15.23,2 Z M9.76,11.42 C9.94,11.19 10.17,11.1 10.45,11.1 L12.86,11.1 C13.12,11.1 13.31,10.94 13.36,10.69 C13.37,10.64 13.62,9.41 13.74,8.83 C13.81,8.52 13.53,8.28 13.27,8.28 C12.35,8.29 11.42,8.28 10.5,8.28 C9.84,8.28 9.83,7.69 9.82,7.21 C9.8,6.85 10.13,6.55 10.5,6.55 C11.59,6.56 12.67,6.55 13.76,6.55 C14.03,6.55 14.23,6.4 14.28,6.14 C14.34,5.87 14.67,4.29 14.67,4.29 C14.67,4.29 14.82,3.74 14.19,3.74 L7.34,3.74 C7,3.75 6.84,4.02 6.84,4.33 C6.84,7.58 6.85,14.95 6.85,14.99 C6.87,15 8.89,12.51 9.76,11.42 L9.76,11.42 Z"/></svg>',future:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline points="19 2 18 2 18 6 14 6 14 7 19 7 19 2"/><path fill="none" stroke="#000" stroke-width="1.1" d="M18,6.548 C16.709,3.29 13.354,1 9.6,1 C4.6,1 0.6,5 0.6,10 C0.6,15 4.6,19 9.6,19 C14.6,19 18.6,15 18.6,10"/><rect x="9" y="4" width="1" height="7"/><path d="M13.018,14.197 L9.445,10.625" fill="none" stroke="#000" stroke-width="1.1"/></svg>',"git-branch":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.2" cx="7" cy="3" r="2"/><circle fill="none" stroke="#000" stroke-width="1.2" cx="14" cy="6" r="2"/><circle fill="none" stroke="#000" stroke-width="1.2" cx="7" cy="17" r="2"/><path fill="none" stroke="#000" stroke-width="2" d="M14,8 C14,10.41 12.43,10.87 10.56,11.25 C9.09,11.54 7,12.06 7,15 L7,5"/></svg>',"git-fork":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.2" cx="5.79" cy="2.79" r="1.79"/><circle fill="none" stroke="#000" stroke-width="1.2" cx="14.19" cy="2.79" r="1.79"/><ellipse fill="none" stroke="#000" stroke-width="1.2" cx="10.03" cy="16.79" rx="1.79" ry="1.79"/><path fill="none" stroke="#000" stroke-width="2" d="M5.79,4.57 L5.79,6.56 C5.79,9.19 10.03,10.22 10.03,13.31 C10.03,14.86 10.04,14.55 10.04,14.55 C10.04,14.37 10.04,14.86 10.04,13.31 C10.04,10.22 14.2,9.19 14.2,6.56 L14.2,4.57"/></svg>',"github-alt":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M10,0.5 C4.75,0.5 0.5,4.76 0.5,10.01 C0.5,15.26 4.75,19.51 10,19.51 C15.24,19.51 19.5,15.26 19.5,10.01 C19.5,4.76 15.25,0.5 10,0.5 L10,0.5 Z M12.81,17.69 C12.81,17.69 12.81,17.7 12.79,17.69 C12.47,17.75 12.35,17.59 12.35,17.36 L12.35,16.17 C12.35,15.45 12.09,14.92 11.58,14.56 C12.2,14.51 12.77,14.39 13.26,14.21 C13.87,13.98 14.36,13.69 14.74,13.29 C15.42,12.59 15.76,11.55 15.76,10.17 C15.76,9.25 15.45,8.46 14.83,7.8 C15.1,7.08 15.07,6.29 14.75,5.44 L14.51,5.42 C14.34,5.4 14.06,5.46 13.67,5.61 C13.25,5.78 12.79,6.03 12.31,6.35 C11.55,6.16 10.81,6.05 10.09,6.05 C9.36,6.05 8.61,6.15 7.88,6.35 C7.28,5.96 6.75,5.68 6.26,5.54 C6.07,5.47 5.9,5.44 5.78,5.44 L5.42,5.44 C5.06,6.29 5.04,7.08 5.32,7.8 C4.7,8.46 4.4,9.25 4.4,10.17 C4.4,11.94 4.96,13.16 6.08,13.84 C6.53,14.13 7.05,14.32 7.69,14.43 C8.03,14.5 8.32,14.54 8.55,14.55 C8.07,14.89 7.82,15.42 7.82,16.16 L7.82,17.51 C7.8,17.69 7.7,17.8 7.51,17.8 C4.21,16.74 1.82,13.65 1.82,10.01 C1.82,5.5 5.49,1.83 10,1.83 C14.5,1.83 18.17,5.5 18.17,10.01 C18.18,13.53 15.94,16.54 12.81,17.69 L12.81,17.69 Z"/></svg>',github:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M10,1 C5.03,1 1,5.03 1,10 C1,13.98 3.58,17.35 7.16,18.54 C7.61,18.62 7.77,18.34 7.77,18.11 C7.77,17.9 7.76,17.33 7.76,16.58 C5.26,17.12 4.73,15.37 4.73,15.37 C4.32,14.33 3.73,14.05 3.73,14.05 C2.91,13.5 3.79,13.5 3.79,13.5 C4.69,13.56 5.17,14.43 5.17,14.43 C5.97,15.8 7.28,15.41 7.79,15.18 C7.87,14.6 8.1,14.2 8.36,13.98 C6.36,13.75 4.26,12.98 4.26,9.53 C4.26,8.55 4.61,7.74 5.19,7.11 C5.1,6.88 4.79,5.97 5.28,4.73 C5.28,4.73 6.04,4.49 7.75,5.65 C8.47,5.45 9.24,5.35 10,5.35 C10.76,5.35 11.53,5.45 12.25,5.65 C13.97,4.48 14.72,4.73 14.72,4.73 C15.21,5.97 14.9,6.88 14.81,7.11 C15.39,7.74 15.73,8.54 15.73,9.53 C15.73,12.99 13.63,13.75 11.62,13.97 C11.94,14.25 12.23,14.8 12.23,15.64 C12.23,16.84 12.22,17.81 12.22,18.11 C12.22,18.35 12.38,18.63 12.84,18.54 C16.42,17.35 19,13.98 19,10 C19,5.03 14.97,1 10,1 L10,1 Z"/></svg>',gitter:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="3.5" y="1" width="1.531" height="11.471"/><rect x="7.324" y="4.059" width="1.529" height="15.294"/><rect x="11.148" y="4.059" width="1.527" height="15.294"/><rect x="14.971" y="4.059" width="1.529" height="8.412"/></svg>',"google-plus":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M12.9,9c0,2.7-0.6,5-3.2,6.3c-3.7,1.8-8.1,0.2-9.4-3.6C-1.1,7.6,1.9,3.3,6.1,3c1.7-0.1,3.2,0.3,4.6,1.3 c0.1,0.1,0.3,0.2,0.4,0.4c-0.5,0.5-1.2,1-1.7,1.6c-1-0.8-2.1-1.1-3.5-0.9C5,5.6,4.2,6,3.6,6.7c-1.3,1.3-1.5,3.4-0.5,5 c1,1.7,2.6,2.3,4.6,1.9c1.4-0.3,2.4-1.2,2.6-2.6H6.9V9H12.9z"/><polygon points="20,9 20,11 18,11 18,13 16,13 16,11 14,11 14,9 16,9 16,7 18,7 18,9"/></svg>',google:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M17.86,9.09 C18.46,12.12 17.14,16.05 13.81,17.56 C9.45,19.53 4.13,17.68 2.47,12.87 C0.68,7.68 4.22,2.42 9.5,2.03 C11.57,1.88 13.42,2.37 15.05,3.65 C15.22,3.78 15.37,3.93 15.61,4.14 C14.9,4.81 14.23,5.45 13.5,6.14 C12.27,5.08 10.84,4.72 9.28,4.98 C8.12,5.17 7.16,5.76 6.37,6.63 C4.88,8.27 4.62,10.86 5.76,12.82 C6.95,14.87 9.17,15.8 11.57,15.25 C13.27,14.87 14.76,13.33 14.89,11.75 L10.51,11.75 L10.51,9.09 L17.86,9.09 L17.86,9.09 Z"/></svg>',grid:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="2" y="2" width="3" height="3"/><rect x="8" y="2" width="3" height="3"/><rect x="14" y="2" width="3" height="3"/><rect x="2" y="8" width="3" height="3"/><rect x="8" y="8" width="3" height="3"/><rect x="14" y="8" width="3" height="3"/><rect x="2" y="14" width="3" height="3"/><rect x="8" y="14" width="3" height="3"/><rect x="14" y="14" width="3" height="3"/></svg>',happy:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle cx="13" cy="7" r="1"/><circle cx="7" cy="7" r="1"/><circle fill="none" stroke="#000" cx="10" cy="10" r="8.5"/><path fill="none" stroke="#000" d="M14.6,11.4 C13.9,13.3 12.1,14.5 10,14.5 C7.9,14.5 6.1,13.3 5.4,11.4"/></svg>',hashtag:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M15.431,8 L15.661,7 L12.911,7 L13.831,3 L12.901,3 L11.98,7 L9.29,7 L10.21,3 L9.281,3 L8.361,7 L5.23,7 L5,8 L8.13,8 L7.21,12 L4.23,12 L4,13 L6.98,13 L6.061,17 L6.991,17 L7.911,13 L10.601,13 L9.681,17 L10.611,17 L11.531,13 L14.431,13 L14.661,12 L11.76,12 L12.681,8 L15.431,8 Z M10.831,12 L8.141,12 L9.061,8 L11.75,8 L10.831,12 Z"/></svg>',heart:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.03" d="M10,4 C10,4 8.1,2 5.74,2 C3.38,2 1,3.55 1,6.73 C1,8.84 2.67,10.44 2.67,10.44 L10,18 L17.33,10.44 C17.33,10.44 19,8.84 19,6.73 C19,3.55 16.62,2 14.26,2 C11.9,2 10,4 10,4 L10,4 Z"/></svg>',history:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="#000" points="1 2 2 2 2 6 6 6 6 7 1 7 1 2"/><path fill="none" stroke="#000" stroke-width="1.1" d="M2.1,6.548 C3.391,3.29 6.746,1 10.5,1 C15.5,1 19.5,5 19.5,10 C19.5,15 15.5,19 10.5,19 C5.5,19 1.5,15 1.5,10"/><rect x="9" y="4" width="1" height="7"/><path fill="none" stroke="#000" stroke-width="1.1" d="M13.018,14.197 L9.445,10.625"/></svg>',home:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="18.65 11.35 10 2.71 1.35 11.35 0.65 10.65 10 1.29 19.35 10.65"/><polygon points="15 4 18 4 18 7 17 7 17 5 15 5"/><polygon points="3 11 4 11 4 18 7 18 7 12 12 12 12 18 16 18 16 11 17 11 17 19 11 19 11 13 8 13 8 19 3 19"/></svg>',image:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle cx="16.1" cy="6.1" r="1.1"/><rect fill="none" stroke="#000" x=".5" y="2.5" width="19" height="15"/><polyline fill="none" stroke="#000" stroke-width="1.01" points="4,13 8,9 13,14"/><polyline fill="none" stroke="#000" stroke-width="1.01" points="11,12 12.5,10.5 16,14"/></svg>',info:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M12.13,11.59 C11.97,12.84 10.35,14.12 9.1,14.16 C6.17,14.2 9.89,9.46 8.74,8.37 C9.3,8.16 10.62,7.83 10.62,8.81 C10.62,9.63 10.12,10.55 9.88,11.32 C8.66,15.16 12.13,11.15 12.14,11.18 C12.16,11.21 12.16,11.35 12.13,11.59 C12.08,11.95 12.16,11.35 12.13,11.59 L12.13,11.59 Z M11.56,5.67 C11.56,6.67 9.36,7.15 9.36,6.03 C9.36,5 11.56,4.54 11.56,5.67 L11.56,5.67 Z"/><circle fill="none" stroke="#000" stroke-width="1.1" cx="10" cy="10" r="9"/></svg>',instagram:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M13.55,1H6.46C3.45,1,1,3.44,1,6.44v7.12c0,3,2.45,5.44,5.46,5.44h7.08c3.02,0,5.46-2.44,5.46-5.44V6.44 C19.01,3.44,16.56,1,13.55,1z M17.5,14c0,1.93-1.57,3.5-3.5,3.5H6c-1.93,0-3.5-1.57-3.5-3.5V6c0-1.93,1.57-3.5,3.5-3.5h8 c1.93,0,3.5,1.57,3.5,3.5V14z"/><circle cx="14.87" cy="5.26" r="1.09"/><path d="M10.03,5.45c-2.55,0-4.63,2.06-4.63,4.6c0,2.55,2.07,4.61,4.63,4.61c2.56,0,4.63-2.061,4.63-4.61 C14.65,7.51,12.58,5.45,10.03,5.45L10.03,5.45L10.03,5.45z M10.08,13c-1.66,0-3-1.34-3-2.99c0-1.65,1.34-2.99,3-2.99s3,1.34,3,2.99 C13.08,11.66,11.74,13,10.08,13L10.08,13L10.08,13z"/></svg>',italic:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M12.63,5.48 L10.15,14.52 C10,15.08 10.37,15.25 11.92,15.3 L11.72,16 L6,16 L6.2,15.31 C7.78,15.26 8.19,15.09 8.34,14.53 L10.82,5.49 C10.97,4.92 10.63,4.76 9.09,4.71 L9.28,4 L15,4 L14.81,4.69 C13.23,4.75 12.78,4.91 12.63,5.48 L12.63,5.48 Z"/></svg>',joomla:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M7.8,13.4l1.7-1.7L5.9,8c-0.6-0.5-0.6-1.5,0-2c0.6-0.6,1.4-0.6,2,0l1.7-1.7c-1-1-2.3-1.3-3.6-1C5.8,2.2,4.8,1.4,3.7,1.4 c-1.3,0-2.3,1-2.3,2.3c0,1.1,0.8,2,1.8,2.3c-0.4,1.3-0.1,2.8,1,3.8L7.8,13.4L7.8,13.4z"/><path d="M10.2,4.3c1-1,2.5-1.4,3.8-1c0.2-1.1,1.1-2,2.3-2c1.3,0,2.3,1,2.3,2.3c0,1.2-0.9,2.2-2,2.3c0.4,1.3,0,2.8-1,3.8L13.9,8 c0.6-0.5,0.6-1.5,0-2c-0.5-0.6-1.5-0.6-2,0L8.2,9.7L6.5,8"/><path d="M14.1,16.8c-1.3,0.4-2.8,0.1-3.8-1l1.7-1.7c0.6,0.6,1.5,0.6,2,0c0.5-0.6,0.6-1.5,0-2l-3.7-3.7L12,6.7l3.7,3.7 c1,1,1.3,2.4,1,3.6c1.1,0.2,2,1.1,2,2.3c0,1.3-1,2.3-2.3,2.3C15.2,18.6,14.3,17.8,14.1,16.8"/><path d="M13.2,12.2l-3.7,3.7c-1,1-2.4,1.3-3.6,1c-0.2,1-1.2,1.8-2.2,1.8c-1.3,0-2.3-1-2.3-2.3c0-1.1,0.8-2,1.8-2.3 c-0.3-1.3,0-2.7,1-3.7l1.7,1.7c-0.6,0.6-0.6,1.5,0,2c0.6,0.6,1.4,0.6,2,0l3.7-3.7"/></svg>',laptop:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect y="16" width="20" height="1"/><rect fill="none" stroke="#000" x="2.5" y="4.5" width="15" height="10"/></svg>',lifesaver:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M10,0.5 C4.76,0.5 0.5,4.76 0.5,10 C0.5,15.24 4.76,19.5 10,19.5 C15.24,19.5 19.5,15.24 19.5,10 C19.5,4.76 15.24,0.5 10,0.5 L10,0.5 Z M10,1.5 C11.49,1.5 12.89,1.88 14.11,2.56 L11.85,4.82 C11.27,4.61 10.65,4.5 10,4.5 C9.21,4.5 8.47,4.67 7.79,4.96 L5.58,2.75 C6.87,1.95 8.38,1.5 10,1.5 L10,1.5 Z M4.96,7.8 C4.67,8.48 4.5,9.21 4.5,10 C4.5,10.65 4.61,11.27 4.83,11.85 L2.56,14.11 C1.88,12.89 1.5,11.49 1.5,10 C1.5,8.38 1.95,6.87 2.75,5.58 L4.96,7.79 L4.96,7.8 L4.96,7.8 Z M10,18.5 C8.25,18.5 6.62,17.97 5.27,17.06 L7.46,14.87 C8.22,15.27 9.08,15.5 10,15.5 C10.79,15.5 11.53,15.33 12.21,15.04 L14.42,17.25 C13.13,18.05 11.62,18.5 10,18.5 L10,18.5 Z M10,14.5 C7.52,14.5 5.5,12.48 5.5,10 C5.5,7.52 7.52,5.5 10,5.5 C12.48,5.5 14.5,7.52 14.5,10 C14.5,12.48 12.48,14.5 10,14.5 L10,14.5 Z M15.04,12.21 C15.33,11.53 15.5,10.79 15.5,10 C15.5,9.08 15.27,8.22 14.87,7.46 L17.06,5.27 C17.97,6.62 18.5,8.25 18.5,10 C18.5,11.62 18.05,13.13 17.25,14.42 L15.04,12.21 L15.04,12.21 Z"/></svg>',link:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.1" d="M10.625,12.375 L7.525,15.475 C6.825,16.175 5.925,16.175 5.225,15.475 L4.525,14.775 C3.825,14.074 3.825,13.175 4.525,12.475 L7.625,9.375"/><path fill="none" stroke="#000" stroke-width="1.1" d="M9.325,7.375 L12.425,4.275 C13.125,3.575 14.025,3.575 14.724,4.275 L15.425,4.975 C16.125,5.675 16.125,6.575 15.425,7.275 L12.325,10.375"/><path fill="none" stroke="#000" stroke-width="1.1" d="M7.925,11.875 L11.925,7.975"/></svg>',linkedin:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M5.77,17.89 L5.77,7.17 L2.21,7.17 L2.21,17.89 L5.77,17.89 L5.77,17.89 Z M3.99,5.71 C5.23,5.71 6.01,4.89 6.01,3.86 C5.99,2.8 5.24,2 4.02,2 C2.8,2 2,2.8 2,3.85 C2,4.88 2.77,5.7 3.97,5.7 L3.99,5.7 L3.99,5.71 L3.99,5.71 Z"/><path d="M7.75,17.89 L11.31,17.89 L11.31,11.9 C11.31,11.58 11.33,11.26 11.43,11.03 C11.69,10.39 12.27,9.73 13.26,9.73 C14.55,9.73 15.06,10.71 15.06,12.15 L15.06,17.89 L18.62,17.89 L18.62,11.74 C18.62,8.45 16.86,6.92 14.52,6.92 C12.6,6.92 11.75,7.99 11.28,8.73 L11.3,8.73 L11.3,7.17 L7.75,7.17 C7.79,8.17 7.75,17.89 7.75,17.89 L7.75,17.89 L7.75,17.89 Z"/></svg>',list:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="6" y="4" width="12" height="1"/><rect x="6" y="9" width="12" height="1"/><rect x="6" y="14" width="12" height="1"/><rect x="2" y="4" width="2" height="1"/><rect x="2" y="9" width="2" height="1"/><rect x="2" y="14" width="2" height="1"/></svg>',location:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.01" d="M10,0.5 C6.41,0.5 3.5,3.39 3.5,6.98 C3.5,11.83 10,19 10,19 C10,19 16.5,11.83 16.5,6.98 C16.5,3.39 13.59,0.5 10,0.5 L10,0.5 Z"/><circle fill="none" stroke="#000" cx="10" cy="6.8" r="2.3"/></svg>',lock:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect fill="none" stroke="#000" height="10" width="13" y="8.5" x="3.5"/><path fill="none" stroke="#000" d="M6.5,8 L6.5,4.88 C6.5,3.01 8.07,1.5 10,1.5 C11.93,1.5 13.5,3.01 13.5,4.88 L13.5,8"/></svg>',mail:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" points="1.4,6.5 10,11 18.6,6.5"/><path d="M 1,4 1,16 19,16 19,4 1,4 Z M 18,15 2,15 2,5 18,5 18,15 Z"/></svg>',menu:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="2" y="4" width="16" height="1"/><rect x="2" y="9" width="16" height="1"/><rect x="2" y="14" width="16" height="1"/></svg>',microphone:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><line fill="none" stroke="#000" x1="10" x2="10" y1="16.44" y2="18.5"/><line fill="none" stroke="#000" x1="7" x2="13" y1="18.5" y2="18.5"/><path fill="none" stroke="#000" stroke-width="1.1" d="M13.5 4.89v5.87a3.5 3.5 0 0 1-7 0V4.89a3.5 3.5 0 0 1 7 0z"/><path fill="none" stroke="#000" stroke-width="1.1" d="M15.5 10.36V11a5.5 5.5 0 0 1-11 0v-.6"/></svg>',"minus-circle":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="9.5" cy="9.5" r="9"/><line fill="none" stroke="#000" x1="5" y1="9.5" x2="14" y2="9.5"/></svg>',minus:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect height="1" width="18" y="9" x="1"/></svg>',"more-vertical":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle cx="10" cy="3" r="2"/><circle cx="10" cy="10" r="2"/><circle cx="10" cy="17" r="2"/></svg>',more:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle cx="3" cy="10" r="2"/><circle cx="10" cy="10" r="2"/><circle cx="17" cy="10" r="2"/></svg>',move:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="4,5 1,5 1,9 2,9 2,6 4,6"/><polygon points="1,16 2,16 2,18 4,18 4,19 1,19"/><polygon points="14,16 14,19 11,19 11,18 13,18 13,16"/><rect fill="none" stroke="#000" x="5.5" y="1.5" width="13" height="13"/><rect x="1" y="11" width="1" height="3"/><rect x="6" y="18" width="3" height="1"/></svg>',nut:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon fill="none" stroke="#000" points="2.5,5.7 10,1.3 17.5,5.7 17.5,14.3 10,18.7 2.5,14.3"/><circle fill="none" stroke="#000" cx="10" cy="10" r="3.5"/></svg>',pagekit:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="3,1 17,1 17,16 10,16 10,13 14,13 14,4 6,4 6,16 10,16 10,19 3,19"/></svg>',"paint-bucket":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M10.21,1 L0,11.21 L8.1,19.31 L18.31,9.1 L10.21,1 L10.21,1 Z M16.89,9.1 L15,11 L1.7,11 L10.21,2.42 L16.89,9.1 Z"/><path fill="none" stroke="#000" stroke-width="1.1" d="M6.42,2.33 L11.7,7.61"/><path d="M18.49,12 C18.49,12 20,14.06 20,15.36 C20,16.28 19.24,17 18.49,17 L18.49,17 C17.74,17 17,16.28 17,15.36 C17,14.06 18.49,12 18.49,12 L18.49,12 Z"/></svg>',pencil:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" d="M17.25,6.01 L7.12,16.1 L3.82,17.2 L5.02,13.9 L15.12,3.88 C15.71,3.29 16.66,3.29 17.25,3.88 C17.83,4.47 17.83,5.42 17.25,6.01 L17.25,6.01 Z"/><path fill="none" stroke="#000" d="M15.98,7.268 L13.851,5.148"/></svg>',"phone-landscape":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" d="M17,5.5 C17.8,5.5 18.5,6.2 18.5,7 L18.5,14 C18.5,14.8 17.8,15.5 17,15.5 L3,15.5 C2.2,15.5 1.5,14.8 1.5,14 L1.5,7 C1.5,6.2 2.2,5.5 3,5.5 L17,5.5 L17,5.5 L17,5.5 Z"/><circle cx="3.8" cy="10.5" r=".8"/></svg>',phone:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" d="M15.5,17 C15.5,17.8 14.8,18.5 14,18.5 L7,18.5 C6.2,18.5 5.5,17.8 5.5,17 L5.5,3 C5.5,2.2 6.2,1.5 7,1.5 L14,1.5 C14.8,1.5 15.5,2.2 15.5,3 L15.5,17 L15.5,17 L15.5,17 Z"/><circle cx="10.5" cy="16.5" r=".8"/></svg>',pinterest:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M10.21,1 C5.5,1 3,4.16 3,7.61 C3,9.21 3.85,11.2 5.22,11.84 C5.43,11.94 5.54,11.89 5.58,11.69 C5.62,11.54 5.8,10.8 5.88,10.45 C5.91,10.34 5.89,10.24 5.8,10.14 C5.36,9.59 5,8.58 5,7.65 C5,5.24 6.82,2.91 9.93,2.91 C12.61,2.91 14.49,4.74 14.49,7.35 C14.49,10.3 13,12.35 11.06,12.35 C9.99,12.35 9.19,11.47 9.44,10.38 C9.75,9.08 10.35,7.68 10.35,6.75 C10.35,5.91 9.9,5.21 8.97,5.21 C7.87,5.21 6.99,6.34 6.99,7.86 C6.99,8.83 7.32,9.48 7.32,9.48 C7.32,9.48 6.24,14.06 6.04,14.91 C5.7,16.35 6.08,18.7 6.12,18.9 C6.14,19.01 6.26,19.05 6.33,18.95 C6.44,18.81 7.74,16.85 8.11,15.44 C8.24,14.93 8.79,12.84 8.79,12.84 C9.15,13.52 10.19,14.09 11.29,14.09 C14.58,14.09 16.96,11.06 16.96,7.3 C16.94,3.7 14,1 10.21,1"/></svg>',"play-circle":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon fill="none" stroke="#000" stroke-width="1.1" points="8.5 7 13.5 10 8.5 13"/><circle fill="none" stroke="#000" stroke-width="1.1" cx="10" cy="10" r="9"/></svg>',play:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon fill="none" stroke="#000" points="6.5,5 14.5,10 6.5,15"/></svg>',"plus-circle":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="9.5" cy="9.5" r="9"/><line fill="none" stroke="#000" x1="9.5" y1="5" x2="9.5" y2="14"/><line fill="none" stroke="#000" x1="5" y1="9.5" x2="14" y2="9.5"/></svg>',plus:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="9" y="1" width="1" height="17"/><rect x="1" y="9" width="17" height="1"/></svg>',print:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" points="4.5 13.5 1.5 13.5 1.5 6.5 18.5 6.5 18.5 13.5 15.5 13.5"/><polyline fill="none" stroke="#000" points="15.5 6.5 15.5 2.5 4.5 2.5 4.5 6.5"/><rect fill="none" stroke="#000" width="11" height="6" x="4.5" y="11.5"/><rect width="8" height="1" x="6" y="13"/><rect width="8" height="1" x="6" y="15"/></svg>',pull:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="6.85,8 9.5,10.6 12.15,8 12.85,8.7 9.5,12 6.15,8.7"/><line fill="none" stroke="#000" x1="9.5" y1="11" x2="9.5" y2="2"/><polyline fill="none" stroke="#000" points="6,5.5 3.5,5.5 3.5,18.5 15.5,18.5 15.5,5.5 13,5.5"/></svg>',push:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="12.15,4 9.5,1.4 6.85,4 6.15,3.3 9.5,0 12.85,3.3"/><line fill="none" stroke="#000" x1="9.5" y1="10" x2="9.5" y2="1"/><polyline fill="none" stroke="#000" points="6 5.5 3.5 5.5 3.5 18.5 15.5 18.5 15.5 5.5 13 5.5"/></svg>',question:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="10" cy="10" r="9"/><circle cx="10.44" cy="14.42" r="1.05"/><path fill="none" stroke="#000" stroke-width="1.2" d="M8.17,7.79 C8.17,4.75 12.72,4.73 12.72,7.72 C12.72,8.67 11.81,9.15 11.23,9.75 C10.75,10.24 10.51,10.73 10.45,11.4 C10.44,11.53 10.43,11.64 10.43,11.75"/></svg>',"quote-right":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M17.27,7.79 C17.27,9.45 16.97,10.43 15.99,12.02 C14.98,13.64 13,15.23 11.56,15.97 L11.1,15.08 C12.34,14.2 13.14,13.51 14.02,11.82 C14.27,11.34 14.41,10.92 14.49,10.54 C14.3,10.58 14.09,10.6 13.88,10.6 C12.06,10.6 10.59,9.12 10.59,7.3 C10.59,5.48 12.06,4 13.88,4 C15.39,4 16.67,5.02 17.05,6.42 C17.19,6.82 17.27,7.27 17.27,7.79 L17.27,7.79 Z"/><path d="M8.68,7.79 C8.68,9.45 8.38,10.43 7.4,12.02 C6.39,13.64 4.41,15.23 2.97,15.97 L2.51,15.08 C3.75,14.2 4.55,13.51 5.43,11.82 C5.68,11.34 5.82,10.92 5.9,10.54 C5.71,10.58 5.5,10.6 5.29,10.6 C3.47,10.6 2,9.12 2,7.3 C2,5.48 3.47,4 5.29,4 C6.8,4 8.08,5.02 8.46,6.42 C8.6,6.82 8.68,7.27 8.68,7.79 L8.68,7.79 Z"/></svg>',receiver:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.01" d="M6.189,13.611C8.134,15.525 11.097,18.239 13.867,18.257C16.47,18.275 18.2,16.241 18.2,16.241L14.509,12.551L11.539,13.639L6.189,8.29L7.313,5.355L3.76,1.8C3.76,1.8 1.732,3.537 1.7,6.092C1.667,8.809 4.347,11.738 6.189,13.611"/></svg>',reddit:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M19 9.05a2.56 2.56 0 0 0-2.56-2.56 2.59 2.59 0 0 0-1.88.82 10.63 10.63 0 0 0-4.14-1v-.08c.58-1.62 1.58-3.89 2.7-4.1.38-.08.77.12 1.19.57a1.15 1.15 0 0 0-.06.37 1.48 1.48 0 1 0 1.51-1.45 1.43 1.43 0 0 0-.76.19A2.29 2.29 0 0 0 12.91 1c-2.11.43-3.39 4.38-3.63 5.19 0 0 0 .11-.06.11a10.65 10.65 0 0 0-3.75 1A2.56 2.56 0 0 0 1 9.05a2.42 2.42 0 0 0 .72 1.76A5.18 5.18 0 0 0 1.24 13c0 3.66 3.92 6.64 8.73 6.64s8.74-3 8.74-6.64a5.23 5.23 0 0 0-.46-2.13A2.58 2.58 0 0 0 19 9.05zm-16.88 0a1.44 1.44 0 0 1 2.27-1.19 7.68 7.68 0 0 0-2.07 1.91 1.33 1.33 0 0 1-.2-.72zM10 18.4c-4.17 0-7.55-2.4-7.55-5.4S5.83 7.53 10 7.53 17.5 10 17.5 13s-3.38 5.4-7.5 5.4zm7.69-8.61a7.62 7.62 0 0 0-2.09-1.91 1.41 1.41 0 0 1 .84-.28 1.47 1.47 0 0 1 1.44 1.45 1.34 1.34 0 0 1-.21.72z"/><path d="M6.69 12.58a1.39 1.39 0 1 1 1.39-1.39 1.38 1.38 0 0 1-1.38 1.39z"/><path d="M14.26 11.2a1.39 1.39 0 1 1-1.39-1.39 1.39 1.39 0 0 1 1.39 1.39z"/><path d="M13.09 14.88a.54.54 0 0 1-.09.77 5.3 5.3 0 0 1-3.26 1.19 5.61 5.61 0 0 1-3.4-1.22.55.55 0 1 1 .73-.83 4.09 4.09 0 0 0 5.25 0 .56.56 0 0 1 .77.09z"/></svg>',refresh:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.1" d="M17.08,11.15 C17.09,11.31 17.1,11.47 17.1,11.64 C17.1,15.53 13.94,18.69 10.05,18.69 C6.16,18.68 3,15.53 3,11.63 C3,7.74 6.16,4.58 10.05,4.58 C10.9,4.58 11.71,4.73 12.46,5"/><polyline fill="none" stroke="#000" points="9.9 2 12.79 4.89 9.79 7.9"/></svg>',reply:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M17.7,13.11 C16.12,10.02 13.84,7.85 11.02,6.61 C10.57,6.41 9.75,6.13 9,5.91 L9,2 L1,9 L9,16 L9,12.13 C10.78,12.47 12.5,13.19 14.09,14.25 C17.13,16.28 18.56,18.54 18.56,18.54 C18.56,18.54 18.81,15.28 17.7,13.11 L17.7,13.11 Z M14.82,13.53 C13.17,12.4 11.01,11.4 8,10.92 L8,13.63 L2.55,9 L8,4.25 L8,6.8 C8.3,6.86 9.16,7.02 10.37,7.49 C13.3,8.65 15.54,10.96 16.65,13.08 C16.97,13.7 17.48,14.86 17.68,16 C16.87,15.05 15.73,14.15 14.82,13.53 L14.82,13.53 Z"/></svg>',rss:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle cx="3.12" cy="16.8" r="1.85"/><path fill="none" stroke="#000" stroke-width="1.1" d="M1.5,8.2 C1.78,8.18 2.06,8.16 2.35,8.16 C7.57,8.16 11.81,12.37 11.81,17.57 C11.81,17.89 11.79,18.19 11.76,18.5"/><path fill="none" stroke="#000" stroke-width="1.1" d="M1.5,2.52 C1.78,2.51 2.06,2.5 2.35,2.5 C10.72,2.5 17.5,9.24 17.5,17.57 C17.5,17.89 17.49,18.19 17.47,18.5"/></svg>',search:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="9" cy="9" r="7"/><path fill="none" stroke="#000" stroke-width="1.1" d="M14,14 L18,18 L14,14 Z"/></svg>',server:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="3" y="3" width="1" height="2"/><rect x="5" y="3" width="1" height="2"/><rect x="7" y="3" width="1" height="2"/><rect x="16" y="3" width="1" height="1"/><rect x="16" y="10" width="1" height="1"/><circle fill="none" stroke="#000" cx="9.9" cy="17.4" r="1.4"/><rect x="3" y="10" width="1" height="2"/><rect x="5" y="10" width="1" height="2"/><rect x="9.5" y="14" width="1" height="2"/><rect x="3" y="17" width="6" height="1"/><rect x="11" y="17" width="6" height="1"/><rect fill="none" stroke="#000" x="1.5" y="1.5" width="17" height="5"/><rect fill="none" stroke="#000" x="1.5" y="8.5" width="17" height="5"/></svg>',settings:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><ellipse fill="none" stroke="#000" cx="6.11" cy="3.55" rx="2.11" ry="2.15"/><ellipse fill="none" stroke="#000" cx="6.11" cy="15.55" rx="2.11" ry="2.15"/><circle fill="none" stroke="#000" cx="13.15" cy="9.55" r="2.15"/><rect x="1" y="3" width="3" height="1"/><rect x="10" y="3" width="8" height="1"/><rect x="1" y="9" width="8" height="1"/><rect x="15" y="9" width="3" height="1"/><rect x="1" y="15" width="3" height="1"/><rect x="10" y="15" width="8" height="1"/></svg>',shrink:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="11 4 12 4 12 8 16 8 16 9 11 9"/><polygon points="4 11 9 11 9 16 8 16 8 12 4 12"/><path fill="none" stroke="#000" stroke-width="1.1" d="M12,8 L18,2"/><path fill="none" stroke="#000" stroke-width="1.1" d="M2,18 L8,12"/></svg>',"sign-in":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="7 2 17 2 17 17 7 17 7 16 16 16 16 3 7 3"/><polygon points="9.1 13.4 8.5 12.8 11.28 10 4 10 4 9 11.28 9 8.5 6.2 9.1 5.62 13 9.5"/></svg>',"sign-out":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="13.1 13.4 12.5 12.8 15.28 10 8 10 8 9 15.28 9 12.5 6.2 13.1 5.62 17 9.5"/><polygon points="13 2 3 2 3 17 13 17 13 16 4 16 4 3 13 3"/></svg>',social:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><line fill="none" stroke="#000" stroke-width="1.1" x1="13.4" y1="14" x2="6.3" y2="10.7"/><line fill="none" stroke="#000" stroke-width="1.1" x1="13.5" y1="5.5" x2="6.5" y2="8.8"/><circle fill="none" stroke="#000" stroke-width="1.1" cx="15.5" cy="4.6" r="2.3"/><circle fill="none" stroke="#000" stroke-width="1.1" cx="15.5" cy="14.8" r="2.3"/><circle fill="none" stroke="#000" stroke-width="1.1" cx="4.5" cy="9.8" r="2.3"/></svg>',soundcloud:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M17.2,9.4c-0.4,0-0.8,0.1-1.101,0.2c-0.199-2.5-2.399-4.5-5-4.5c-0.6,0-1.2,0.1-1.7,0.3C9.2,5.5,9.1,5.6,9.1,5.6V15h8 c1.601,0,2.801-1.2,2.801-2.8C20,10.7,18.7,9.4,17.2,9.4L17.2,9.4z"/><rect x="6" y="6.5" width="1.5" height="8.5"/><rect x="3" y="8" width="1.5" height="7"/><rect y="10" width="1.5" height="5"/></svg>',star:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon fill="none" stroke="#000" stroke-width="1.01" points="10 2 12.63 7.27 18.5 8.12 14.25 12.22 15.25 18 10 15.27 4.75 18 5.75 12.22 1.5 8.12 7.37 7.27"/></svg>',strikethrough:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M6,13.02 L6.65,13.02 C7.64,15.16 8.86,16.12 10.41,16.12 C12.22,16.12 12.92,14.93 12.92,13.89 C12.92,12.55 11.99,12.03 9.74,11.23 C8.05,10.64 6.23,10.11 6.23,7.83 C6.23,5.5 8.09,4.09 10.4,4.09 C11.44,4.09 12.13,4.31 12.72,4.54 L13.33,4 L13.81,4 L13.81,7.59 L13.16,7.59 C12.55,5.88 11.52,4.89 10.07,4.89 C8.84,4.89 7.89,5.69 7.89,7.03 C7.89,8.29 8.89,8.78 10.88,9.45 C12.57,10.03 14.38,10.6 14.38,12.91 C14.38,14.75 13.27,16.93 10.18,16.93 C9.18,16.93 8.17,16.69 7.46,16.39 L6.52,17 L6,17 L6,13.02 L6,13.02 Z"/><rect x="3" y="10" width="15" height="1"/></svg>',table:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="1" y="3" width="18" height="1"/><rect x="1" y="7" width="18" height="1"/><rect x="1" y="11" width="18" height="1"/><rect x="1" y="15" width="18" height="1"/></svg>',"tablet-landscape":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" d="M1.5,5 C1.5,4.2 2.2,3.5 3,3.5 L17,3.5 C17.8,3.5 18.5,4.2 18.5,5 L18.5,16 C18.5,16.8 17.8,17.5 17,17.5 L3,17.5 C2.2,17.5 1.5,16.8 1.5,16 L1.5,5 L1.5,5 L1.5,5 Z"/><circle cx="3.7" cy="10.5" r=".8"/></svg>',tablet:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" d="M5,18.5 C4.2,18.5 3.5,17.8 3.5,17 L3.5,3 C3.5,2.2 4.2,1.5 5,1.5 L16,1.5 C16.8,1.5 17.5,2.2 17.5,3 L17.5,17 C17.5,17.8 16.8,18.5 16,18.5 L5,18.5 L5,18.5 L5,18.5 Z"/><circle cx="10.5" cy="16.3" r=".8"/></svg>',tag:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" stroke-width="1.1" d="M17.5,3.71 L17.5,7.72 C17.5,7.96 17.4,8.2 17.21,8.39 L8.39,17.2 C7.99,17.6 7.33,17.6 6.93,17.2 L2.8,13.07 C2.4,12.67 2.4,12.01 2.8,11.61 L11.61,2.8 C11.81,2.6 12.08,2.5 12.34,2.5 L16.19,2.5 C16.52,2.5 16.86,2.63 17.11,2.88 C17.35,3.11 17.48,3.4 17.5,3.71 L17.5,3.71 Z"/><circle cx="14" cy="6" r="1"/></svg>',thumbnails:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect fill="none" stroke="#000" x="3.5" y="3.5" width="5" height="5"/><rect fill="none" stroke="#000" x="11.5" y="3.5" width="5" height="5"/><rect fill="none" stroke="#000" x="11.5" y="11.5" width="5" height="5"/><rect fill="none" stroke="#000" x="3.5" y="11.5" width="5" height="5"/></svg>',trash:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" points="6.5 3 6.5 1.5 13.5 1.5 13.5 3"/><polyline fill="none" stroke="#000" points="4.5 4 4.5 18.5 15.5 18.5 15.5 4"/><rect x="8" y="7" width="1" height="9"/><rect x="11" y="7" width="1" height="9"/><rect x="2" y="3" width="16" height="1"/></svg>',"triangle-down":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="5 7 15 7 10 12"/></svg>',"triangle-left":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="12 5 7 10 12 15"/></svg>',"triangle-right":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="8 5 13 10 8 15"/></svg>',"triangle-up":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="5 13 10 8 15 13"/></svg>',tripadvisor:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M19.021,7.866C19.256,6.862,20,5.854,20,5.854h-3.346C14.781,4.641,12.504,4,9.98,4C7.363,4,4.999,4.651,3.135,5.876H0\tc0,0,0.738,0.987,0.976,1.988c-0.611,0.837-0.973,1.852-0.973,2.964c0,2.763,2.249,5.009,5.011,5.009\tc1.576,0,2.976-0.737,3.901-1.879l1.063,1.599l1.075-1.615c0.475,0.611,1.1,1.111,1.838,1.451c1.213,0.547,2.574,0.612,3.825,0.15\tc2.589-0.963,3.913-3.852,2.964-6.439c-0.175-0.463-0.4-0.876-0.675-1.238H19.021z M16.38,14.594\tc-1.002,0.371-2.088,0.328-3.06-0.119c-0.688-0.317-1.252-0.817-1.657-1.438c-0.164-0.25-0.313-0.52-0.417-0.811\tc-0.124-0.328-0.186-0.668-0.217-1.014c-0.063-0.689,0.037-1.396,0.339-2.043c0.448-0.971,1.251-1.71,2.25-2.079\tc2.075-0.765,4.375,0.3,5.14,2.366c0.762,2.066-0.301,4.37-2.363,5.134L16.38,14.594L16.38,14.594z M8.322,13.066\tc-0.72,1.059-1.935,1.76-3.309,1.76c-2.207,0-4.001-1.797-4.001-3.996c0-2.203,1.795-4.002,4.001-4.002\tc2.204,0,3.999,1.8,3.999,4.002c0,0.137-0.024,0.261-0.04,0.396c-0.067,0.678-0.284,1.313-0.648,1.853v-0.013H8.322z M2.472,10.775\tc0,1.367,1.112,2.479,2.476,2.479c1.363,0,2.472-1.11,2.472-2.479c0-1.359-1.11-2.468-2.472-2.468\tC3.584,8.306,2.473,9.416,2.472,10.775L2.472,10.775z M12.514,10.775c0,1.367,1.104,2.479,2.471,2.479\tc1.363,0,2.474-1.108,2.474-2.479c0-1.359-1.11-2.468-2.474-2.468c-1.364,0-2.477,1.109-2.477,2.468H12.514z M3.324,10.775\tc0-0.893,0.726-1.618,1.614-1.618c0.889,0,1.625,0.727,1.625,1.618c0,0.898-0.725,1.627-1.625,1.627\tc-0.901,0-1.625-0.729-1.625-1.627H3.324z M13.354,10.775c0-0.893,0.726-1.618,1.627-1.618c0.886,0,1.61,0.727,1.61,1.618\tc0,0.898-0.726,1.627-1.626,1.627s-1.625-0.729-1.625-1.627H13.354z M9.977,4.875c1.798,0,3.425,0.324,4.849,0.968\tc-0.535,0.015-1.061,0.108-1.586,0.3c-1.264,0.463-2.264,1.388-2.815,2.604c-0.262,0.551-0.398,1.133-0.448,1.72\tC9.79,7.905,7.677,5.873,5.076,5.82C6.501,5.208,8.153,4.875,9.94,4.875H9.977z"/></svg>',tumblr:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M6.885,8.598c0,0,0,3.393,0,4.996c0,0.282,0,0.66,0.094,0.942c0.377,1.509,1.131,2.545,2.545,3.11 c1.319,0.472,2.356,0.472,3.676,0c0.565-0.188,1.132-0.659,1.132-0.659l-0.849-2.263c0,0-1.036,0.378-1.603,0.283 c-0.565-0.094-1.226-0.66-1.226-1.508c0-1.603,0-4.902,0-4.902h2.828V5.771h-2.828V2H8.205c0,0-0.094,0.66-0.188,0.942 C7.828,3.791,7.262,4.733,6.603,5.394C5.848,6.147,5,6.43,5,6.43v2.168H6.885z"/></svg>',tv:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="7" y="16" width="6" height="1"/><rect fill="none" stroke="#000" x=".5" y="3.5" width="19" height="11"/></svg>',twitter:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M19,4.74 C18.339,5.029 17.626,5.229 16.881,5.32 C17.644,4.86 18.227,4.139 18.503,3.28 C17.79,3.7 17.001,4.009 16.159,4.17 C15.485,3.45 14.526,3 13.464,3 C11.423,3 9.771,4.66 9.771,6.7 C9.771,6.99 9.804,7.269 9.868,7.539 C6.795,7.38 4.076,5.919 2.254,3.679 C1.936,4.219 1.754,4.86 1.754,5.539 C1.754,6.82 2.405,7.95 3.397,8.61 C2.79,8.589 2.22,8.429 1.723,8.149 L1.723,8.189 C1.723,9.978 2.997,11.478 4.686,11.82 C4.376,11.899 4.049,11.939 3.713,11.939 C3.475,11.939 3.245,11.919 3.018,11.88 C3.49,13.349 4.852,14.419 6.469,14.449 C5.205,15.429 3.612,16.019 1.882,16.019 C1.583,16.019 1.29,16.009 1,15.969 C2.635,17.019 4.576,17.629 6.662,17.629 C13.454,17.629 17.17,12 17.17,7.129 C17.17,6.969 17.166,6.809 17.157,6.649 C17.879,6.129 18.504,5.478 19,4.74"/></svg>',uikit:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon points="14.4,3.1 11.3,5.1 15,7.3 15,12.9 10,15.7 5,12.9 5,8.5 2,6.8 2,14.8 9.9,19.5 18,14.8 18,5.3"/><polygon points="9.8,4.2 6.7,2.4 9.8,0.4 12.9,2.3"/></svg>',unlock:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect fill="none" stroke="#000" x="3.5" y="8.5" width="13" height="10"/><path fill="none" stroke="#000" d="M6.5,8.5 L6.5,4.9 C6.5,3 8.1,1.5 10,1.5 C11.9,1.5 13.5,3 13.5,4.9"/></svg>',upload:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" points="5 8 9.5 3.5 14 8"/><rect x="3" y="17" width="13" height="1"/><line fill="none" stroke="#000" x1="9.5" y1="15" x2="9.5" y2="4"/></svg>',user:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="9.9" cy="6.4" r="4.4"/><path fill="none" stroke="#000" stroke-width="1.1" d="M1.5,19 C2.3,14.5 5.8,11.2 10,11.2 C14.2,11.2 17.7,14.6 18.5,19.2"/></svg>',users:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="7.7" cy="8.6" r="3.5"/><path fill="none" stroke="#000" stroke-width="1.1" d="M1,18.1 C1.7,14.6 4.4,12.1 7.6,12.1 C10.9,12.1 13.7,14.8 14.3,18.3"/><path fill="none" stroke="#000" stroke-width="1.1" d="M11.4,4 C12.8,2.4 15.4,2.8 16.3,4.7 C17.2,6.6 15.7,8.9 13.6,8.9 C16.5,8.9 18.8,11.3 19.2,14.1"/></svg>',"video-camera":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><polygon fill="none" stroke="#000" points="17.5 6.9 17.5 13.1 13.5 10.4 13.5 14.5 2.5 14.5 2.5 5.5 13.5 5.5 13.5 9.6 17.5 6.9"/></svg>',vimeo:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M2.065,7.59C1.84,7.367,1.654,7.082,1.468,6.838c-0.332-0.42-0.137-0.411,0.274-0.772c1.026-0.91,2.004-1.896,3.127-2.688 c1.017-0.713,2.365-1.173,3.286-0.039c0.849,1.045,0.869,2.629,1.084,3.891c0.215,1.309,0.421,2.648,0.88,3.901 c0.127,0.352,0.37,1.018,0.81,1.074c0.567,0.078,1.145-0.917,1.408-1.289c0.684-0.987,1.611-2.317,1.494-3.587 c-0.115-1.349-1.572-1.095-2.482-0.773c0.146-1.514,1.555-3.216,2.912-3.792c1.439-0.597,3.579-0.587,4.302,1.036 c0.772,1.759,0.078,3.802-0.763,5.396c-0.918,1.731-2.1,3.333-3.363,4.829c-1.114,1.329-2.432,2.787-4.093,3.422 c-1.897,0.723-3.021-0.686-3.667-2.318c-0.705-1.777-1.056-3.771-1.565-5.621C4.898,8.726,4.644,7.836,4.136,7.191 C3.473,6.358,2.72,7.141,2.065,7.59C1.977,7.502,2.115,7.551,2.065,7.59L2.065,7.59z"/></svg>',warning:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle cx="10" cy="14" r="1"/><circle fill="none" stroke="#000" stroke-width="1.1" cx="10" cy="10" r="9"/><path d="M10.97,7.72 C10.85,9.54 10.56,11.29 10.56,11.29 C10.51,11.87 10.27,12 9.99,12 C9.69,12 9.49,11.87 9.43,11.29 C9.43,11.29 9.16,9.54 9.03,7.72 C8.96,6.54 9.03,6 9.03,6 C9.03,5.45 9.46,5.02 9.99,5 C10.53,5.01 10.97,5.44 10.97,6 C10.97,6 11.04,6.54 10.97,7.72 L10.97,7.72 Z"/></svg>',whatsapp:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M16.7,3.3c-1.8-1.8-4.1-2.8-6.7-2.8c-5.2,0-9.4,4.2-9.4,9.4c0,1.7,0.4,3.3,1.3,4.7l-1.3,4.9l5-1.3c1.4,0.8,2.9,1.2,4.5,1.2 l0,0l0,0c5.2,0,9.4-4.2,9.4-9.4C19.5,7.4,18.5,5,16.7,3.3 M10.1,17.7L10.1,17.7c-1.4,0-2.8-0.4-4-1.1l-0.3-0.2l-3,0.8l0.8-2.9 l-0.2-0.3c-0.8-1.2-1.2-2.7-1.2-4.2c0-4.3,3.5-7.8,7.8-7.8c2.1,0,4.1,0.8,5.5,2.3c1.5,1.5,2.3,3.4,2.3,5.5 C17.9,14.2,14.4,17.7,10.1,17.7 M14.4,11.9c-0.2-0.1-1.4-0.7-1.6-0.8c-0.2-0.1-0.4-0.1-0.5,0.1c-0.2,0.2-0.6,0.8-0.8,0.9 c-0.1,0.2-0.3,0.2-0.5,0.1c-0.2-0.1-1-0.4-1.9-1.2c-0.7-0.6-1.2-1.4-1.3-1.6c-0.1-0.2,0-0.4,0.1-0.5C8,8.8,8.1,8.7,8.2,8.5 c0.1-0.1,0.2-0.2,0.2-0.4c0.1-0.2,0-0.3,0-0.4C8.4,7.6,7.9,6.5,7.7,6C7.5,5.5,7.3,5.6,7.2,5.6c-0.1,0-0.3,0-0.4,0 c-0.2,0-0.4,0.1-0.6,0.3c-0.2,0.2-0.8,0.8-0.8,2c0,1.2,0.8,2.3,1,2.4c0.1,0.2,1.7,2.5,4,3.5c0.6,0.2,1,0.4,1.3,0.5 c0.6,0.2,1.1,0.2,1.5,0.1c0.5-0.1,1.4-0.6,1.6-1.1c0.2-0.5,0.2-1,0.1-1.1C14.8,12.1,14.6,12,14.4,11.9"/></svg>',wordpress:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M10,0.5c-5.2,0-9.5,4.3-9.5,9.5s4.3,9.5,9.5,9.5c5.2,0,9.5-4.3,9.5-9.5S15.2,0.5,10,0.5L10,0.5L10,0.5z M15.6,3.9h-0.1 c-0.8,0-1.4,0.7-1.4,1.5c0,0.7,0.4,1.3,0.8,1.9c0.3,0.6,0.7,1.3,0.7,2.3c0,0.7-0.3,1.5-0.6,2.7L14.1,15l-3-8.9 c0.5,0,0.9-0.1,0.9-0.1C12.5,6,12.5,5.3,12,5.4c0,0-1.3,0.1-2.2,0.1C9,5.5,7.7,5.4,7.7,5.4C7.2,5.3,7.2,6,7.6,6c0,0,0.4,0.1,0.9,0.1 l1.3,3.5L8,15L5,6.1C5.5,6.1,5.9,6,5.9,6C6.4,6,6.3,5.3,5.9,5.4c0,0-1.3,0.1-2.2,0.1c-0.2,0-0.3,0-0.5,0c1.5-2.2,4-3.7,6.9-3.7 C12.2,1.7,14.1,2.6,15.6,3.9L15.6,3.9L15.6,3.9z M2.5,6.6l3.9,10.8c-2.7-1.3-4.6-4.2-4.6-7.4C1.8,8.8,2,7.6,2.5,6.6L2.5,6.6L2.5,6.6 z M10.2,10.7l2.5,6.9c0,0,0,0.1,0.1,0.1C11.9,18,11,18.2,10,18.2c-0.8,0-1.6-0.1-2.3-0.3L10.2,10.7L10.2,10.7L10.2,10.7z M14.2,17.1 l2.5-7.3c0.5-1.2,0.6-2.1,0.6-2.9c0-0.3,0-0.6-0.1-0.8c0.6,1.2,1,2.5,1,4C18.3,13,16.6,15.7,14.2,17.1L14.2,17.1L14.2,17.1z"/></svg>',world:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#000" d="M1,10.5 L19,10.5"/><path fill="none" stroke="#000" d="M2.35,15.5 L17.65,15.5"/><path fill="none" stroke="#000" d="M2.35,5.5 L17.523,5.5"/><path fill="none" stroke="#000" d="M10,19.46 L9.98,19.46 C7.31,17.33 5.61,14.141 5.61,10.58 C5.61,7.02 7.33,3.83 10,1.7 C10.01,1.7 9.99,1.7 10,1.7 L10,1.7 C12.67,3.83 14.4,7.02 14.4,10.58 C14.4,14.141 12.67,17.33 10,19.46 L10,19.46 L10,19.46 L10,19.46 Z"/><circle fill="none" stroke="#000" cx="10" cy="10.5" r="9"/></svg>',xing:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M4.4,4.56 C4.24,4.56 4.11,4.61 4.05,4.72 C3.98,4.83 3.99,4.97 4.07,5.12 L5.82,8.16 L5.82,8.17 L3.06,13.04 C2.99,13.18 2.99,13.33 3.06,13.44 C3.12,13.55 3.24,13.62 3.4,13.62 L6,13.62 C6.39,13.62 6.57,13.36 6.71,13.12 C6.71,13.12 9.41,8.35 9.51,8.16 C9.49,8.14 7.72,5.04 7.72,5.04 C7.58,4.81 7.39,4.56 6.99,4.56 L4.4,4.56 L4.4,4.56 Z"/><path d="M15.3,1 C14.91,1 14.74,1.25 14.6,1.5 C14.6,1.5 9.01,11.42 8.82,11.74 C8.83,11.76 12.51,18.51 12.51,18.51 C12.64,18.74 12.84,19 13.23,19 L15.82,19 C15.98,19 16.1,18.94 16.16,18.83 C16.23,18.72 16.23,18.57 16.16,18.43 L12.5,11.74 L12.5,11.72 L18.25,1.56 C18.32,1.42 18.32,1.27 18.25,1.16 C18.21,1.06 18.08,1 17.93,1 L15.3,1 L15.3,1 Z"/></svg>',yelp:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M17.175,14.971c-0.112,0.77-1.686,2.767-2.406,3.054c-0.246,0.1-0.487,0.076-0.675-0.069\tc-0.122-0.096-2.446-3.859-2.446-3.859c-0.194-0.293-0.157-0.682,0.083-0.978c0.234-0.284,0.581-0.393,0.881-0.276\tc0.016,0.01,4.21,1.394,4.332,1.482c0.178,0.148,0.263,0.379,0.225,0.646L17.175,14.971L17.175,14.971z M11.464,10.789\tc-0.203-0.307-0.199-0.666,0.009-0.916c0,0,2.625-3.574,2.745-3.657c0.203-0.135,0.452-0.141,0.69-0.025\tc0.691,0.335,2.085,2.405,2.167,3.199v0.027c0.024,0.271-0.082,0.491-0.273,0.623c-0.132,0.083-4.43,1.155-4.43,1.155\tc-0.322,0.096-0.68-0.06-0.882-0.381L11.464,10.789z M9.475,9.563C9.32,9.609,8.848,9.757,8.269,8.817c0,0-3.916-6.16-4.007-6.351\tc-0.057-0.212,0.011-0.455,0.202-0.65C5.047,1.211,8.21,0.327,9.037,0.529c0.27,0.069,0.457,0.238,0.522,0.479\tc0.047,0.266,0.433,5.982,0.488,7.264C10.098,9.368,9.629,9.517,9.475,9.563z M9.927,19.066c-0.083,0.225-0.273,0.373-0.54,0.421\tc-0.762,0.13-3.15-0.751-3.647-1.342c-0.096-0.131-0.155-0.262-0.167-0.394c-0.011-0.095,0-0.189,0.036-0.272\tc0.061-0.155,2.917-3.538,2.917-3.538c0.214-0.272,0.595-0.355,0.952-0.213c0.345,0.13,0.56,0.428,0.536,0.749\tC10.014,14.479,9.977,18.923,9.927,19.066z M3.495,13.912c-0.235-0.009-0.444-0.148-0.568-0.382c-0.089-0.17-0.151-0.453-0.19-0.794\tC2.63,11.701,2.761,10.144,3.07,9.648c0.145-0.226,0.357-0.345,0.592-0.336c0.154,0,4.255,1.667,4.255,1.667\tc0.321,0.118,0.521,0.453,0.5,0.833c-0.023,0.37-0.236,0.655-0.551,0.738L3.495,13.912z"/></svg>',youtube:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M15,4.1c1,0.1,2.3,0,3,0.8c0.8,0.8,0.9,2.1,0.9,3.1C19,9.2,19,10.9,19,12c-0.1,1.1,0,2.4-0.5,3.4c-0.5,1.1-1.4,1.5-2.5,1.6 c-1.2,0.1-8.6,0.1-11,0c-1.1-0.1-2.4-0.1-3.2-1c-0.7-0.8-0.7-2-0.8-3C1,11.8,1,10.1,1,8.9c0-1.1,0-2.4,0.5-3.4C2,4.5,3,4.3,4.1,4.2 C5.3,4.1,12.6,4,15,4.1z M8,7.5v6l5.5-3L8,7.5z"/></svg>'})}return"undefined"!=typeof window&&window.UIkit&&window.UIkit.use(i),i});",
{"status":false}
],

[
"ace.js_2019-10-17",
"// https://github.com/ajaxorg/ace-builds/blob/master/src-min-noconflict/ace.js
(function(){function o(n){var i=e;n&&(e[n]||(e[n]={}),i=e[n]);if(!i.define||!i.define.packaged)t.original=i.define,i.define=t,i.define.packaged=!0;if(!i.require||!i.require.packaged)r.original=i.require,i.require=r,i.require.packaged=!0}var ACE_NAMESPACE = "ace",e=function(){return this}();!e&&typeof window!="undefined"&&(e=window);if(!ACE_NAMESPACE&&typeof requirejs!="undefined")return;var t=function(e,n,r){if(typeof e!="string"){t.original?t.original.apply(this,arguments):(console.error("dropping module because define wasn't a string."),console.trace());return}arguments.length==2&&(r=n),t.modules[e]||(t.payloads[e]=r,t.modules[e]=null)};t.modules={},t.payloads={};var n=function(e,t,n){if(typeof t=="string"){var i=s(e,t);if(i!=undefined)return n&&n(),i}else if(Object.prototype.toString.call(t)==="[object Array]"){var o=[];for(var u=0,a=t.length;u<a;++u){var f=s(e,t[u]);if(f==undefined&&r.original)return;o.push(f)}return n&&n.apply(null,o)||!0}},r=function(e,t){var i=n("",e,t);return i==undefined&&r.original?r.original.apply(this,arguments):i},i=function(e,t){if(t.indexOf("!")!==-1){var n=t.split("!");return i(e,n[0])+"!"+i(e,n[1])}if(t.charAt(0)=="."){var r=e.split("/").slice(0,-1).join("/");t=r+"/"+t;while(t.indexOf(".")!==-1&&s!=t){var s=t;t=t.replace(/\/\.\//,"/").replace(/[^\/]+\/\.\.\//,"")}}return t},s=function(e,r){r=i(e,r);var s=t.modules[r];if(!s){s=t.payloads[r];if(typeof s=="function"){var o={},u={id:r,uri:"",exports:o,packaged:!0},a=function(e,t){return n(r,e,t)},f=s(a,o,u);o=f||u.exports,t.modules[r]=o,delete t.payloads[r]}s=t.modules[r]=o||s}return s};o(ACE_NAMESPACE)})(),ace.define("ace/lib/regexp",["require","exports","module"],function(e,t,n){"use strict";function o(e){return(e.global?"g":"")+(e.ignoreCase?"i":"")+(e.multiline?"m":"")+(e.extended?"x":"")+(e.sticky?"y":"")}function u(e,t,n){if(Array.prototype.indexOf)return e.indexOf(t,n);for(var r=n||0;r<e.length;r++)if(e[r]===t)return r;return-1}var r={exec:RegExp.prototype.exec,test:RegExp.prototype.test,match:String.prototype.match,replace:String.prototype.replace,split:String.prototype.split},i=r.exec.call(/()??/,"")[1]===undefined,s=function(){var e=/^/g;return r.test.call(e,""),!e.lastIndex}();if(s&&i)return;RegExp.prototype.exec=function(e){var t=r.exec.apply(this,arguments),n,a;if(typeof e=="string"&&t){!i&&t.length>1&&u(t,"")>-1&&(a=RegExp(this.source,r.replace.call(o(this),"g","")),r.replace.call(e.slice(t.index),a,function(){for(var e=1;e<arguments.length-2;e++)arguments[e]===undefined&&(t[e]=undefined)}));if(this._xregexp&&this._xregexp.captureNames)for(var f=1;f<t.length;f++)n=this._xregexp.captureNames[f-1],n&&(t[n]=t[f]);!s&&this.global&&!t[0].length&&this.lastIndex>t.index&&this.lastIndex--}return t},s||(RegExp.prototype.test=function(e){var t=r.exec.call(this,e);return t&&this.global&&!t[0].length&&this.lastIndex>t.index&&this.lastIndex--,!!t})}),ace.define("ace/lib/es5-shim",["require","exports","module"],function(e,t,n){function r(){}function w(e){try{return Object.defineProperty(e,"sentinel",{}),"sentinel"in e}catch(t){}}function H(e){return e=+e,e!==e?e=0:e!==0&&e!==1/0&&e!==-1/0&&(e=(e>0||-1)*Math.floor(Math.abs(e))),e}function B(e){var t=typeof e;return e===null||t==="undefined"||t==="boolean"||t==="number"||t==="string"}function j(e){var t,n,r;if(B(e))return e;n=e.valueOf;if(typeof n=="function"){t=n.call(e);if(B(t))return t}r=e.toString;if(typeof r=="function"){t=r.call(e);if(B(t))return t}throw new TypeError}Function.prototype.bind||(Function.prototype.bind=function(t){var n=this;if(typeof n!="function")throw new TypeError("Function.prototype.bind called on incompatible "+n);var i=u.call(arguments,1),s=function(){if(this instanceof s){var e=n.apply(this,i.concat(u.call(arguments)));return Object(e)===e?e:this}return n.apply(t,i.concat(u.call(arguments)))};return n.prototype&&(r.prototype=n.prototype,s.prototype=new r,r.prototype=null),s});var i=Function.prototype.call,s=Array.prototype,o=Object.prototype,u=s.slice,a=i.bind(o.toString),f=i.bind(o.hasOwnProperty),l,c,h,p,d;if(d=f(o,"__defineGetter__"))l=i.bind(o.__defineGetter__),c=i.bind(o.__defineSetter__),h=i.bind(o.__lookupGetter__),p=i.bind(o.__lookupSetter__);if([1,2].splice(0).length!=2)if(!function(){function e(e){var t=new Array(e+2);return t[0]=t[1]=0,t}var t=[],n;t.splice.apply(t,e(20)),t.splice.apply(t,e(26)),n=t.length,t.splice(5,0,"XXX"),n+1==t.length;if(n+1==t.length)return!0}())Array.prototype.splice=function(e,t){var n=this.length;e>0?e>n&&(e=n):e==void 0?e=0:e<0&&(e=Math.max(n+e,0)),e+t<n||(t=n-e);var r=this.slice(e,e+t),i=u.call(arguments,2),s=i.length;if(e===n)s&&this.push.apply(this,i);else{var o=Math.min(t,n-e),a=e+o,f=a+s-o,l=n-a,c=n-o;if(f<a)for(var h=0;h<l;++h)this[f+h]=this[a+h];else if(f>a)for(h=l;h--;)this[f+h]=this[a+h];if(s&&e===c)this.length=c,this.push.apply(this,i);else{this.length=c+s;for(h=0;h<s;++h)this[e+h]=i[h]}}return r};else{var v=Array.prototype.splice;Array.prototype.splice=function(e,t){return arguments.length?v.apply(this,[e===void 0?0:e,t===void 0?this.length-e:t].concat(u.call(arguments,2))):[]}}Array.isArray||(Array.isArray=function(t){return a(t)=="[object Array]"});var m=Object("a"),g=m[0]!="a"||!(0 in m);Array.prototype.forEach||(Array.prototype.forEach=function(t){var n=F(this),r=g&&a(this)=="[object String]"?this.split(""):n,i=arguments[1],s=-1,o=r.length>>>0;if(a(t)!="[object Function]")throw new TypeError;while(++s<o)s in r&&t.call(i,r[s],s,n)}),Array.prototype.map||(Array.prototype.map=function(t){var n=F(this),r=g&&a(this)=="[object String]"?this.split(""):n,i=r.length>>>0,s=Array(i),o=arguments[1];if(a(t)!="[object Function]")throw new TypeError(t+" is not a function");for(var u=0;u<i;u++)u in r&&(s[u]=t.call(o,r[u],u,n));return s}),Array.prototype.filter||(Array.prototype.filter=function(t){var n=F(this),r=g&&a(this)=="[object String]"?this.split(""):n,i=r.length>>>0,s=[],o,u=arguments[1];if(a(t)!="[object Function]")throw new TypeError(t+" is not a function");for(var f=0;f<i;f++)f in r&&(o=r[f],t.call(u,o,f,n)&&s.push(o));return s}),Array.prototype.every||(Array.prototype.every=function(t){var n=F(this),r=g&&a(this)=="[object String]"?this.split(""):n,i=r.length>>>0,s=arguments[1];if(a(t)!="[object Function]")throw new TypeError(t+" is not a function");for(var o=0;o<i;o++)if(o in r&&!t.call(s,r[o],o,n))return!1;return!0}),Array.prototype.some||(Array.prototype.some=function(t){var n=F(this),r=g&&a(this)=="[object String]"?this.split(""):n,i=r.length>>>0,s=arguments[1];if(a(t)!="[object Function]")throw new TypeError(t+" is not a function");for(var o=0;o<i;o++)if(o in r&&t.call(s,r[o],o,n))return!0;return!1}),Array.prototype.reduce||(Array.prototype.reduce=function(t){var n=F(this),r=g&&a(this)=="[object String]"?this.split(""):n,i=r.length>>>0;if(a(t)!="[object Function]")throw new TypeError(t+" is not a function");if(!i&&arguments.length==1)throw new TypeError("reduce of empty array with no initial value");var s=0,o;if(arguments.length>=2)o=arguments[1];else do{if(s in r){o=r[s++];break}if(++s>=i)throw new TypeError("reduce of empty array with no initial value")}while(!0);for(;s<i;s++)s in r&&(o=t.call(void 0,o,r[s],s,n));return o}),Array.prototype.reduceRight||(Array.prototype.reduceRight=function(t){var n=F(this),r=g&&a(this)=="[object String]"?this.split(""):n,i=r.length>>>0;if(a(t)!="[object Function]")throw new TypeError(t+" is not a function");if(!i&&arguments.length==1)throw new TypeError("reduceRight of empty array with no initial value");var s,o=i-1;if(arguments.length>=2)s=arguments[1];else do{if(o in r){s=r[o--];break}if(--o<0)throw new TypeError("reduceRight of empty array with no initial value")}while(!0);do o in this&&(s=t.call(void 0,s,r[o],o,n));while(o--);return s});if(!Array.prototype.indexOf||[0,1].indexOf(1,2)!=-1)Array.prototype.indexOf=function(t){var n=g&&a(this)=="[object String]"?this.split(""):F(this),r=n.length>>>0;if(!r)return-1;var i=0;arguments.length>1&&(i=H(arguments[1])),i=i>=0?i:Math.max(0,r+i);for(;i<r;i++)if(i in n&&n[i]===t)return i;return-1};if(!Array.prototype.lastIndexOf||[0,1].lastIndexOf(0,-3)!=-1)Array.prototype.lastIndexOf=function(t){var n=g&&a(this)=="[object String]"?this.split(""):F(this),r=n.length>>>0;if(!r)return-1;var i=r-1;arguments.length>1&&(i=Math.min(i,H(arguments[1]))),i=i>=0?i:r-Math.abs(i);for(;i>=0;i--)if(i in n&&t===n[i])return i;return-1};Object.getPrototypeOf||(Object.getPrototypeOf=function(t){return t.__proto__||(t.constructor?t.constructor.prototype:o)});if(!Object.getOwnPropertyDescriptor){var y="Object.getOwnPropertyDescriptor called on a non-object: ";Object.getOwnPropertyDescriptor=function(t,n){if(typeof t!="object"&&typeof t!="function"||t===null)throw new TypeError(y+t);if(!f(t,n))return;var r,i,s;r={enumerable:!0,configurable:!0};if(d){var u=t.__proto__;t.__proto__=o;var i=h(t,n),s=p(t,n);t.__proto__=u;if(i||s)return i&&(r.get=i),s&&(r.set=s),r}return r.value=t[n],r}}Object.getOwnPropertyNames||(Object.getOwnPropertyNames=function(t){return Object.keys(t)});if(!Object.create){var b;Object.prototype.__proto__===null?b=function(){return{__proto__:null}}:b=function(){var e={};for(var t in e)e[t]=null;return e.constructor=e.hasOwnProperty=e.propertyIsEnumerable=e.isPrototypeOf=e.toLocaleString=e.toString=e.valueOf=e.__proto__=null,e},Object.create=function(t,n){var r;if(t===null)r=b();else{if(typeof t!="object")throw new TypeError("typeof prototype["+typeof t+"] != 'object'");var i=function(){};i.prototype=t,r=new i,r.__proto__=t}return n!==void 0&&Object.defineProperties(r,n),r}}if(Object.defineProperty){var E=w({}),S=typeof document=="undefined"||w(document.createElement("div"));if(!E||!S)var x=Object.defineProperty}if(!Object.defineProperty||x){var T="Property description must be an object: ",N="Object.defineProperty called on non-object: ",C="getters & setters can not be defined on this javascript engine";Object.defineProperty=function(t,n,r){if(typeof t!="object"&&typeof t!="function"||t===null)throw new TypeError(N+t);if(typeof r!="object"&&typeof r!="function"||r===null)throw new TypeError(T+r);if(x)try{return x.call(Object,t,n,r)}catch(i){}if(f(r,"value"))if(d&&(h(t,n)||p(t,n))){var s=t.__proto__;t.__proto__=o,delete t[n],t[n]=r.value,t.__proto__=s}else t[n]=r.value;else{if(!d)throw new TypeError(C);f(r,"get")&&l(t,n,r.get),f(r,"set")&&c(t,n,r.set)}return t}}Object.defineProperties||(Object.defineProperties=function(t,n){for(var r in n)f(n,r)&&Object.defineProperty(t,r,n[r]);return t}),Object.seal||(Object.seal=function(t){return t}),Object.freeze||(Object.freeze=function(t){return t});try{Object.freeze(function(){})}catch(k){Object.freeze=function(t){return function(n){return typeof n=="function"?n:t(n)}}(Object.freeze)}Object.preventExtensions||(Object.preventExtensions=function(t){return t}),Object.isSealed||(Object.isSealed=function(t){return!1}),Object.isFrozen||(Object.isFrozen=function(t){return!1}),Object.isExtensible||(Object.isExtensible=function(t){if(Object(t)===t)throw new TypeError;var n="";while(f(t,n))n+="?";t[n]=!0;var r=f(t,n);return delete t[n],r});if(!Object.keys){var L=!0,A=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"],O=A.length;for(var M in{toString:null})L=!1;Object.keys=function I(e){if(typeof e!="object"&&typeof e!="function"||e===null)throw new TypeError("Object.keys called on a non-object");var I=[];for(var t in e)f(e,t)&&I.push(t);if(L)for(var n=0,r=O;n<r;n++){var i=A[n];f(e,i)&&I.push(i)}return I}}Date.now||(Date.now=function(){return(new Date).getTime()});var _="	\n\x0b\f\r \u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029\ufeff";if(!String.prototype.trim||_.trim()){_="["+_+"]";var D=new RegExp("^"+_+_+"*"),P=new RegExp(_+_+"*$");String.prototype.trim=function(){return String(this).replace(D,"").replace(P,"")}}var F=function(e){if(e==null)throw new TypeError("can't convert "+e+" to object");return Object(e)}}),ace.define("ace/lib/fixoldbrowsers",["require","exports","module","ace/lib/regexp","ace/lib/es5-shim"],function(e,t,n){"use strict";e("./regexp"),e("./es5-shim"),typeof Element!="undefined"&&!Element.prototype.remove&&Object.defineProperty(Element.prototype,"remove",{enumerable:!1,writable:!0,configurable:!0,value:function(){this.parentNode&&this.parentNode.removeChild(this)}})}),ace.define("ace/lib/useragent",["require","exports","module"],function(e,t,n){"use strict";t.OS={LINUX:"LINUX",MAC:"MAC",WINDOWS:"WINDOWS"},t.getOS=function(){return t.isMac?t.OS.MAC:t.isLinux?t.OS.LINUX:t.OS.WINDOWS};var r=typeof navigator=="object"?navigator:{},i=(/mac|win|linux/i.exec(r.platform)||["other"])[0].toLowerCase(),s=r.userAgent||"",o=r.appName||"";t.isWin=i=="win",t.isMac=i=="mac",t.isLinux=i=="linux",t.isIE=o=="Microsoft Internet Explorer"||o.indexOf("MSAppHost")>=0?parseFloat((s.match(/(?:MSIE |Trident\/[0-9]+[\.0-9]+;.*rv:)([0-9]+[\.0-9]+)/)||[])[1]):parseFloat((s.match(/(?:Trident\/[0-9]+[\.0-9]+;.*rv:)([0-9]+[\.0-9]+)/)||[])[1]),t.isOldIE=t.isIE&&t.isIE<9,t.isGecko=t.isMozilla=s.match(/ Gecko\/\d+/),t.isOpera=typeof opera=="object"&&Object.prototype.toString.call(window.opera)=="[object Opera]",t.isWebKit=parseFloat(s.split("WebKit/")[1])||undefined,t.isChrome=parseFloat(s.split(" Chrome/")[1])||undefined,t.isEdge=parseFloat(s.split(" Edge/")[1])||undefined,t.isAIR=s.indexOf("AdobeAIR")>=0,t.isAndroid=s.indexOf("Android")>=0,t.isChromeOS=s.indexOf(" CrOS ")>=0,t.isIOS=/iPad|iPhone|iPod/.test(s)&&!window.MSStream,t.isIOS&&(t.isMac=!0),t.isMobile=t.isIOS||t.isAndroid}),ace.define("ace/lib/dom",["require","exports","module","ace/lib/useragent"],function(e,t,n){"use strict";var r=e("./useragent"),i="http://www.w3.org/1999/xhtml";t.buildDom=function o(e,t,n){if(typeof e=="string"&&e){var r=document.createTextNode(e);return t&&t.appendChild(r),r}if(!Array.isArray(e))return e;if(typeof e[0]!="string"||!e[0]){var i=[];for(var s=0;s<e.length;s++){var u=o(e[s],t,n);u&&i.push(u)}return i}var a=document.createElement(e[0]),f=e[1],l=1;f&&typeof f=="object"&&!Array.isArray(f)&&(l=2);for(var s=l;s<e.length;s++)o(e[s],a,n);return l==2&&Object.keys(f).forEach(function(e){var t=f[e];e==="class"?a.className=Array.isArray(t)?t.join(" "):t:typeof t=="function"||e=="value"?a[e]=t:e==="ref"?n&&(n[t]=a):t!=null&&a.setAttribute(e,t)}),t&&t.appendChild(a),a},t.getDocumentHead=function(e){return e||(e=document),e.head||e.getElementsByTagName("head")[0]||e.documentElement},t.createElement=function(e,t){return document.createElementNS?document.createElementNS(t||i,e):document.createElement(e)},t.removeChildren=function(e){e.innerHTML=""},t.createTextNode=function(e,t){var n=t?t.ownerDocument:document;return n.createTextNode(e)},t.createFragment=function(e){var t=e?e.ownerDocument:document;return t.createDocumentFragment()},t.hasCssClass=function(e,t){var n=(e.className+"").split(/\s+/g);return n.indexOf(t)!==-1},t.addCssClass=function(e,n){t.hasCssClass(e,n)||(e.className+=" "+n)},t.removeCssClass=function(e,t){var n=e.className.split(/\s+/g);for(;;){var r=n.indexOf(t);if(r==-1)break;n.splice(r,1)}e.className=n.join(" ")},t.toggleCssClass=function(e,t){var n=e.className.split(/\s+/g),r=!0;for(;;){var i=n.indexOf(t);if(i==-1)break;r=!1,n.splice(i,1)}return r&&n.push(t),e.className=n.join(" "),r},t.setCssClass=function(e,n,r){r?t.addCssClass(e,n):t.removeCssClass(e,n)},t.hasCssString=function(e,t){var n=0,r;t=t||document;if(r=t.querySelectorAll("style"))while(n<r.length)if(r[n++].id===e)return!0},t.importCssString=function(n,r,i){var s=i;if(!i||!i.getRootNode)s=document;else{s=i.getRootNode();if(!s||s==i)s=document}var o=s.ownerDocument||s;if(r&&t.hasCssString(r,s))return null;r&&(n+="\n/*# sourceURL=ace/css/"+r+" */");var u=t.createElement("style");u.appendChild(o.createTextNode(n)),r&&(u.id=r),s==o&&(s=t.getDocumentHead(o)),s.insertBefore(u,s.firstChild)},t.importCssStylsheet=function(e,n){t.buildDom(["link",{rel:"stylesheet",href:e}],t.getDocumentHead(n))},t.scrollbarWidth=function(e){var n=t.createElement("ace_inner");n.style.width="100%",n.style.minWidth="0px",n.style.height="200px",n.style.display="block";var r=t.createElement("ace_outer"),i=r.style;i.position="absolute",i.left="-10000px",i.overflow="hidden",i.width="200px",i.minWidth="0px",i.height="150px",i.display="block",r.appendChild(n);var s=e.documentElement;s.appendChild(r);var o=n.offsetWidth;i.overflow="scroll";var u=n.offsetWidth;return o==u&&(u=r.clientWidth),s.removeChild(r),o-u},typeof document=="undefined"&&(t.importCssString=function(){}),t.computedStyle=function(e,t){return window.getComputedStyle(e,"")||{}},t.setStyle=function(e,t,n){e[t]!==n&&(e[t]=n)},t.HAS_CSS_ANIMATION=!1,t.HAS_CSS_TRANSFORMS=!1,t.HI_DPI=r.isWin?typeof window!="undefined"&&window.devicePixelRatio>=1.5:!0;if(typeof document!="undefined"){var s=document.createElement("div");t.HI_DPI&&s.style.transform!==undefined&&(t.HAS_CSS_TRANSFORMS=!0),!r.isEdge&&typeof s.style.animationName!="undefined"&&(t.HAS_CSS_ANIMATION=!0),s=null}t.HAS_CSS_TRANSFORMS?t.translate=function(e,t,n){e.style.transform="translate("+Math.round(t)+"px, "+Math.round(n)+"px)"}:t.translate=function(e,t,n){e.style.top=Math.round(n)+"px",e.style.left=Math.round(t)+"px"}}),ace.define("ace/lib/oop",["require","exports","module"],function(e,t,n){"use strict";t.inherits=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})},t.mixin=function(e,t){for(var n in t)e[n]=t[n];return e},t.implement=function(e,n){t.mixin(e,n)}}),ace.define("ace/lib/keys",["require","exports","module","ace/lib/oop"],function(e,t,n){"use strict";var r=e("./oop"),i=function(){var e={MODIFIER_KEYS:{16:"Shift",17:"Ctrl",18:"Alt",224:"Meta",91:"MetaLeft",92:"MetaRight",93:"ContextMenu"},KEY_MODS:{ctrl:1,alt:2,option:2,shift:4,"super":8,meta:8,command:8,cmd:8},FUNCTION_KEYS:{8:"Backspace",9:"Tab",13:"Return",19:"Pause",27:"Esc",32:"Space",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"Left",38:"Up",39:"Right",40:"Down",44:"Print",45:"Insert",46:"Delete",96:"Numpad0",97:"Numpad1",98:"Numpad2",99:"Numpad3",100:"Numpad4",101:"Numpad5",102:"Numpad6",103:"Numpad7",104:"Numpad8",105:"Numpad9","-13":"NumpadEnter",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"Numlock",145:"Scrolllock"},PRINTABLE_KEYS:{32:" ",48:"0",49:"1",50:"2",51:"3",52:"4",53:"5",54:"6",55:"7",56:"8",57:"9",59:";",61:"=",65:"a",66:"b",67:"c",68:"d",69:"e",70:"f",71:"g",72:"h",73:"i",74:"j",75:"k",76:"l",77:"m",78:"n",79:"o",80:"p",81:"q",82:"r",83:"s",84:"t",85:"u",86:"v",87:"w",88:"x",89:"y",90:"z",107:"+",109:"-",110:".",186:";",187:"=",188:",",189:"-",190:".",191:"/",192:"`",219:"[",220:"\\",221:"]",222:"'",111:"/",106:"*"}},t,n;for(n in e.FUNCTION_KEYS)t=e.FUNCTION_KEYS[n].toLowerCase(),e[t]=parseInt(n,10);for(n in e.PRINTABLE_KEYS)t=e.PRINTABLE_KEYS[n].toLowerCase(),e[t]=parseInt(n,10);return r.mixin(e,e.MODIFIER_KEYS),r.mixin(e,e.PRINTABLE_KEYS),r.mixin(e,e.FUNCTION_KEYS),e.enter=e["return"],e.escape=e.esc,e.del=e["delete"],e[173]="-",function(){var t=["cmd","ctrl","alt","shift"];for(var n=Math.pow(2,t.length);n--;)e.KEY_MODS[n]=t.filter(function(t){return n&e.KEY_MODS[t]}).join("-")+"-"}(),e.KEY_MODS[0]="",e.KEY_MODS[-1]="input-",e}();r.mixin(t,i),t.keyCodeToString=function(e){var t=i[e];return typeof t!="string"&&(t=String.fromCharCode(e)),t.toLowerCase()}}),ace.define("ace/lib/event",["require","exports","module","ace/lib/keys","ace/lib/useragent"],function(e,t,n){"use strict";function a(e,t,n){var a=u(t);if(!i.isMac&&s){t.getModifierState&&(t.getModifierState("OS")||t.getModifierState("Win"))&&(a|=8);if(s.altGr){if((3&a)==3)return;s.altGr=0}if(n===18||n===17){var f="location"in t?t.location:t.keyLocation;if(n===17&&f===1)s[n]==1&&(o=t.timeStamp);else if(n===18&&a===3&&f===2){var l=t.timeStamp-o;l<50&&(s.altGr=!0)}}}n in r.MODIFIER_KEYS&&(n=-1);if(!a&&n===13){var f="location"in t?t.location:t.keyLocation;if(f===3){e(t,a,-n);if(t.defaultPrevented)return}}if(i.isChromeOS&&a&8){e(t,a,n);if(t.defaultPrevented)return;a&=-9}return!!a||n in r.FUNCTION_KEYS||n in r.PRINTABLE_KEYS?e(t,a,n):!1}function f(){s=Object.create(null)}var r=e("./keys"),i=e("./useragent"),s=null,o=0;t.addListener=function(e,t,n){if(e.addEventListener)return e.addEventListener(t,n,!1);if(e.attachEvent){var r=function(){n.call(e,window.event)};n._wrapper=r,e.attachEvent("on"+t,r)}},t.removeListener=function(e,t,n){if(e.removeEventListener)return e.removeEventListener(t,n,!1);e.detachEvent&&e.detachEvent("on"+t,n._wrapper||n)},t.stopEvent=function(e){return t.stopPropagation(e),t.preventDefault(e),!1},t.stopPropagation=function(e){e.stopPropagation?e.stopPropagation():e.cancelBubble=!0},t.preventDefault=function(e){e.preventDefault?e.preventDefault():e.returnValue=!1},t.getButton=function(e){return e.type=="dblclick"?0:e.type=="contextmenu"||i.isMac&&e.ctrlKey&&!e.altKey&&!e.shiftKey?2:e.preventDefault?e.button:{1:0,2:2,4:1}[e.button]},t.capture=function(e,n,r){function i(e){n&&n(e),r&&r(e),t.removeListener(document,"mousemove",n,!0),t.removeListener(document,"mouseup",i,!0),t.removeListener(document,"dragstart",i,!0)}return t.addListener(document,"mousemove",n,!0),t.addListener(document,"mouseup",i,!0),t.addListener(document,"dragstart",i,!0),i},t.addMouseWheelListener=function(e,n){"onmousewheel"in e?t.addListener(e,"mousewheel",function(e){var t=8;e.wheelDeltaX!==undefined?(e.wheelX=-e.wheelDeltaX/t,e.wheelY=-e.wheelDeltaY/t):(e.wheelX=0,e.wheelY=-e.wheelDelta/t),n(e)}):"onwheel"in e?t.addListener(e,"wheel",function(e){var t=.35;switch(e.deltaMode){case e.DOM_DELTA_PIXEL:e.wheelX=e.deltaX*t||0,e.wheelY=e.deltaY*t||0;break;case e.DOM_DELTA_LINE:case e.DOM_DELTA_PAGE:e.wheelX=(e.deltaX||0)*5,e.wheelY=(e.deltaY||0)*5}n(e)}):t.addListener(e,"DOMMouseScroll",function(e){e.axis&&e.axis==e.HORIZONTAL_AXIS?(e.wheelX=(e.detail||0)*5,e.wheelY=0):(e.wheelX=0,e.wheelY=(e.detail||0)*5),n(e)})},t.addMultiMouseDownListener=function(e,n,r,s){function c(e){t.getButton(e)!==0?o=0:e.detail>1?(o++,o>4&&(o=1)):o=1;if(i.isIE){var c=Math.abs(e.clientX-u)>5||Math.abs(e.clientY-a)>5;if(!f||c)o=1;f&&clearTimeout(f),f=setTimeout(function(){f=null},n[o-1]||600),o==1&&(u=e.clientX,a=e.clientY)}e._clicks=o,r[s]("mousedown",e);if(o>4)o=0;else if(o>1)return r[s](l[o],e)}function h(e){o=2,f&&clearTimeout(f),f=setTimeout(function(){f=null},n[o-1]||600),r[s]("mousedown",e),r[s](l[o],e)}var o=0,u,a,f,l={2:"dblclick",3:"tripleclick",4:"quadclick"};Array.isArray(e)||(e=[e]),e.forEach(function(e){t.addListener(e,"mousedown",c),i.isOldIE&&t.addListener(e,"dblclick",h)})};var u=!i.isMac||!i.isOpera||"KeyboardEvent"in window?function(e){return 0|(e.ctrlKey?1:0)|(e.altKey?2:0)|(e.shiftKey?4:0)|(e.metaKey?8:0)}:function(e){return 0|(e.metaKey?1:0)|(e.altKey?2:0)|(e.shiftKey?4:0)|(e.ctrlKey?8:0)};t.getModifierString=function(e){return r.KEY_MODS[u(e)]},t.addCommandKeyListener=function(e,n){var r=t.addListener;if(i.isOldGecko||i.isOpera&&!("KeyboardEvent"in window)){var o=null;r(e,"keydown",function(e){o=e.keyCode}),r(e,"keypress",function(e){return a(n,e,o)})}else{var u=null;r(e,"keydown",function(e){s[e.keyCode]=(s[e.keyCode]||0)+1;var t=a(n,e,e.keyCode);return u=e.defaultPrevented,t}),r(e,"keypress",function(e){u&&(e.ctrlKey||e.altKey||e.shiftKey||e.metaKey)&&(t.stopEvent(e),u=null)}),r(e,"keyup",function(e){s[e.keyCode]=null}),s||(f(),r(window,"focus",f))}};if(typeof window=="object"&&window.postMessage&&!i.isOldIE){var l=1;t.nextTick=function(e,n){n=n||window;var r="zero-timeout-message-"+l++,i=function(s){s.data==r&&(t.stopPropagation(s),t.removeListener(n,"message",i),e())};t.addListener(n,"message",i),n.postMessage(r,"*")}}t.$idleBlocked=!1,t.onIdle=function(e,n){return setTimeout(function r(){t.$idleBlocked?setTimeout(r,100):e()},n)},t.$idleBlockId=null,t.blockIdle=function(e){t.$idleBlockId&&clearTimeout(t.$idleBlockId),t.$idleBlocked=!0,t.$idleBlockId=setTimeout(function(){t.$idleBlocked=!1},e||100)},t.nextFrame=typeof window=="object"&&(window.requestAnimationFrame||window.mozRequestAnimationFrame||window.webkitRequestAnimationFrame||window.msRequestAnimationFrame||window.oRequestAnimationFrame),t.nextFrame?t.nextFrame=t.nextFrame.bind(window):t.nextFrame=function(e){setTimeout(e,17)}}),ace.define("ace/range",["require","exports","module"],function(e,t,n){"use strict";var r=function(e,t){return e.row-t.row||e.column-t.column},i=function(e,t,n,r){this.start={row:e,column:t},this.end={row:n,column:r}};(function(){this.isEqual=function(e){return this.start.row===e.start.row&&this.end.row===e.end.row&&this.start.column===e.start.column&&this.end.column===e.end.column},this.toString=function(){return"Range: ["+this.start.row+"/"+this.start.column+"] -> ["+this.end.row+"/"+this.end.column+"]"},this.contains=function(e,t){return this.compare(e,t)==0},this.compareRange=function(e){var t,n=e.end,r=e.start;return t=this.compare(n.row,n.column),t==1?(t=this.compare(r.row,r.column),t==1?2:t==0?1:0):t==-1?-2:(t=this.compare(r.row,r.column),t==-1?-1:t==1?42:0)},this.comparePoint=function(e){return this.compare(e.row,e.column)},this.containsRange=function(e){return this.comparePoint(e.start)==0&&this.comparePoint(e.end)==0},this.intersects=function(e){var t=this.compareRange(e);return t==-1||t==0||t==1},this.isEnd=function(e,t){return this.end.row==e&&this.end.column==t},this.isStart=function(e,t){return this.start.row==e&&this.start.column==t},this.setStart=function(e,t){typeof e=="object"?(this.start.column=e.column,this.start.row=e.row):(this.start.row=e,this.start.column=t)},this.setEnd=function(e,t){typeof e=="object"?(this.end.column=e.column,this.end.row=e.row):(this.end.row=e,this.end.column=t)},this.inside=function(e,t){return this.compare(e,t)==0?this.isEnd(e,t)||this.isStart(e,t)?!1:!0:!1},this.insideStart=function(e,t){return this.compare(e,t)==0?this.isEnd(e,t)?!1:!0:!1},this.insideEnd=function(e,t){return this.compare(e,t)==0?this.isStart(e,t)?!1:!0:!1},this.compare=function(e,t){return!this.isMultiLine()&&e===this.start.row?t<this.start.column?-1:t>this.end.column?1:0:e<this.start.row?-1:e>this.end.row?1:this.start.row===e?t>=this.start.column?0:-1:this.end.row===e?t<=this.end.column?0:1:0},this.compareStart=function(e,t){return this.start.row==e&&this.start.column==t?-1:this.compare(e,t)},this.compareEnd=function(e,t){return this.end.row==e&&this.end.column==t?1:this.compare(e,t)},this.compareInside=function(e,t){return this.end.row==e&&this.end.column==t?1:this.start.row==e&&this.start.column==t?-1:this.compare(e,t)},this.clipRows=function(e,t){if(this.end.row>t)var n={row:t+1,column:0};else if(this.end.row<e)var n={row:e,column:0};if(this.start.row>t)var r={row:t+1,column:0};else if(this.start.row<e)var r={row:e,column:0};return i.fromPoints(r||this.start,n||this.end)},this.extend=function(e,t){var n=this.compare(e,t);if(n==0)return this;if(n==-1)var r={row:e,column:t};else var s={row:e,column:t};return i.fromPoints(r||this.start,s||this.end)},this.isEmpty=function(){return this.start.row===this.end.row&&this.start.column===this.end.column},this.isMultiLine=function(){return this.start.row!==this.end.row},this.clone=function(){return i.fromPoints(this.start,this.end)},this.collapseRows=function(){return this.end.column==0?new i(this.start.row,0,Math.max(this.start.row,this.end.row-1),0):new i(this.start.row,0,this.end.row,0)},this.toScreenRange=function(e){var t=e.documentToScreenPosition(this.start),n=e.documentToScreenPosition(this.end);return new i(t.row,t.column,n.row,n.column)},this.moveBy=function(e,t){this.start.row+=e,this.start.column+=t,this.end.row+=e,this.end.column+=t}}).call(i.prototype),i.fromPoints=function(e,t){return new i(e.row,e.column,t.row,t.column)},i.comparePoints=r,i.comparePoints=function(e,t){return e.row-t.row||e.column-t.column},t.Range=i}),ace.define("ace/lib/lang",["require","exports","module"],function(e,t,n){"use strict";t.last=function(e){return e[e.length-1]},t.stringReverse=function(e){return e.split("").reverse().join("")},t.stringRepeat=function(e,t){var n="";while(t>0){t&1&&(n+=e);if(t>>=1)e+=e}return n};var r=/^\s\s*/,i=/\s\s*$/;t.stringTrimLeft=function(e){return e.replace(r,"")},t.stringTrimRight=function(e){return e.replace(i,"")},t.copyObject=function(e){var t={};for(var n in e)t[n]=e[n];return t},t.copyArray=function(e){var t=[];for(var n=0,r=e.length;n<r;n++)e[n]&&typeof e[n]=="object"?t[n]=this.copyObject(e[n]):t[n]=e[n];return t},t.deepCopy=function s(e){if(typeof e!="object"||!e)return e;var t;if(Array.isArray(e)){t=[];for(var n=0;n<e.length;n++)t[n]=s(e[n]);return t}if(Object.prototype.toString.call(e)!=="[object Object]")return e;t={};for(var n in e)t[n]=s(e[n]);return t},t.arrayToMap=function(e){var t={};for(var n=0;n<e.length;n++)t[e[n]]=1;return t},t.createMap=function(e){var t=Object.create(null);for(var n in e)t[n]=e[n];return t},t.arrayRemove=function(e,t){for(var n=0;n<=e.length;n++)t===e[n]&&e.splice(n,1)},t.escapeRegExp=function(e){return e.replace(/([.*+?^${}()|[\]\/\\])/g,"\\$1")},t.escapeHTML=function(e){return(""+e).replace(/&/g,"&#38;").replace(/"/g,"&#34;").replace(/'/g,"&#39;").replace(/</g,"&#60;")},t.getMatchOffsets=function(e,t){var n=[];return e.replace(t,function(e){n.push({offset:arguments[arguments.length-2],length:e.length})}),n},t.deferredCall=function(e){var t=null,n=function(){t=null,e()},r=function(e){return r.cancel(),t=setTimeout(n,e||0),r};return r.schedule=r,r.call=function(){return this.cancel(),e(),r},r.cancel=function(){return clearTimeout(t),t=null,r},r.isPending=function(){return t},r},t.delayedCall=function(e,t){var n=null,r=function(){n=null,e()},i=function(e){n==null&&(n=setTimeout(r,e||t))};return i.delay=function(e){n&&clearTimeout(n),n=setTimeout(r,e||t)},i.schedule=i,i.call=function(){this.cancel(),e()},i.cancel=function(){n&&clearTimeout(n),n=null},i.isPending=function(){return n},i}}),ace.define("ace/clipboard",["require","exports","module"],function(e,t,n){"use strict";var r;n.exports={lineMode:!1,pasteCancelled:function(){return r&&r>Date.now()-50?!0:r=!1},cancel:function(){r=Date.now()}}}),ace.define("ace/keyboard/textinput",["require","exports","module","ace/lib/event","ace/lib/useragent","ace/lib/dom","ace/lib/lang","ace/clipboard","ace/lib/keys"],function(e,t,n){"use strict";var r=e("../lib/event"),i=e("../lib/useragent"),s=e("../lib/dom"),o=e("../lib/lang"),u=e("../clipboard"),a=i.isChrome<18,f=i.isIE,l=i.isChrome>63,c=400,h=e("../lib/keys"),p=h.KEY_MODS,d=i.isIOS,v=d?/\s/:/\n/,m=function(e,t){function z(){S=!0,n.blur(),n.focus(),S=!1}function X(e){e.keyCode==27&&n.value.length<n.selectionStart&&(y||(x=n.value),T=N=-1,L()),W()}function $(){clearTimeout(V),V=setTimeout(function(){w&&(n.style.cssText=w,w=""),t.renderer.$isMousePressed=!1,t.renderer.$keepTextAreaAtCursor&&t.renderer.$moveTextAreaToCursor()},0)}function K(e,t,n){var r=null,i=!1;n.addEventListener("keydown",function(e){r&&clearTimeout(r),i=!0},!0),n.addEventListener("keyup",function(e){r=setTimeout(function(){i=!1},100)},!0);var s=function(e){if(document.activeElement!==n)return;if(i||y||t.$mouseHandler.isMousePressed)return;if(m)return;var r=n.selectionStart,s=n.selectionEnd,o=null,u=0;if(r==0)o=h.up;else if(r==1)o=h.home;else if(s>N&&x[s]=="\n")o=h.end;else if(r<T&&x[r-1]==" ")o=h.left,u=p.option;else if(r<T||r==T&&N!=T&&r==s)o=h.left;else if(s>N&&x.slice(0,s).split("\n").length>2)o=h.down;else if(s>N&&x[s-1]==" ")o=h.right,u=p.option;else if(s>N||s==N&&N!=T&&r==s)o=h.right;r!==s&&(u|=p.shift);if(o){var a=t.onCommandKey({},u,o);if(!a&&t.commands){o=h.keyCodeToString(o);var f=t.commands.findKeyCommand(u,o);f&&t.execCommand(f)}T=r,N=s,L("")}};document.addEventListener("selectionchange",s),t.on("destroy",function(){document.removeEventListener("selectionchange",s)})}var n=s.createElement("textarea");n.className="ace_text-input",n.setAttribute("wrap","off"),n.setAttribute("autocorrect","off"),n.setAttribute("autocapitalize","off"),n.setAttribute("spellcheck",!1),n.style.opacity="0",e.insertBefore(n,e.firstChild);var m=!1,g=!1,y=!1,b=!1,w="";i.isMobile||(n.style.fontSize="1px");var E=!1,S=!1,x="",T=0,N=0;try{var C=document.activeElement===n}catch(k){}r.addListener(n,"blur",function(e){if(S)return;t.onBlur(e),C=!1}),r.addListener(n,"focus",function(e){if(S)return;C=!0;if(i.isEdge)try{if(!document.hasFocus())return}catch(e){}t.onFocus(e),i.isEdge?setTimeout(L):L()}),this.$focusScroll=!1,this.focus=function(){if(w||l||this.$focusScroll=="browser")return n.focus({preventScroll:!0});var e=n.style.top;n.style.position="fixed",n.style.top="0px";try{var t=n.getBoundingClientRect().top!=0}catch(r){return}var i=[];if(t){var s=n.parentElement;while(s&&s.nodeType==1)i.push(s),s.setAttribute("ace_nocontext",!0),!s.parentElement&&s.getRootNode?s=s.getRootNode().host:s=s.parentElement}n.focus({preventScroll:!0}),t&&i.forEach(function(e){e.removeAttribute("ace_nocontext")}),setTimeout(function(){n.style.position="",n.style.top=="0px"&&(n.style.top=e)},0)},this.blur=function(){n.blur()},this.isFocused=function(){return C},t.on("beforeEndOperation",function(){if(t.curOp&&t.curOp.command.name=="insertstring")return;y&&(x=n.value="",U()),L()});var L=d?function(e){if(!C||m&&!e||b)return;e||(e="");var r="\n ab"+e+"cde fg\n";r!=n.value&&(n.value=x=r);var i=4,s=4+(e.length||(t.selection.isEmpty()?0:1));(T!=i||N!=s)&&n.setSelectionRange(i,s),T=i,N=s}:function(){if(y||b)return;if(!C&&!_)return;y=!0;var e=t.selection,r=e.getRange(),i=e.cursor.row,s=r.start.column,o=r.end.column,u=t.session.getLine(i);if(r.start.row!=i){var a=t.session.getLine(i-1);s=r.start.row<i-1?0:s,o+=a.length+1,u=a+"\n"+u}else if(r.end.row!=i){var f=t.session.getLine(i+1);o=r.end.row>i+1?f.length:o,o+=u.length+1,u=u+"\n"+f}u.length>c&&(s<c&&o<c?u=u.slice(0,c):(u="\n",s=0,o=1));var l=u+"\n\n";l!=x&&(n.value=x=l,T=N=l.length),_&&(T=n.selectionStart,N=n.selectionEnd);if(N!=o||T!=s||n.selectionEnd!=N)try{n.setSelectionRange(s,o),T=s,N=o}catch(h){}y=!1};C&&t.onFocus();var A=function(e){return e.selectionStart===0&&e.selectionEnd>=x.length&&e.value===x&&x&&e.selectionEnd!==N},O=function(e){if(y)return;m?m=!1:A(n)&&(t.selectAll(),L())},M=null;this.setInputHandler=function(e){M=e},this.getInputHandler=function(){return M};var _=!1,D=function(e,r){_&&(_=!1);if(g)return L(),e&&t.onPaste(e),g=!1,"";var i=n.selectionStart,s=n.selectionEnd,o=T,u=x.length-N,a=e,f=e.length-i,l=e.length-s,c=0;while(o>0&&x[c]==e[c])c++,o--;a=a.slice(c),c=1;while(u>0&&x.length-c>T-1&&x[x.length-c]==e[e.length-c])c++,u--;f-=c-1,l-=c-1;var h=a.length-c+1;return h<0&&(o=-h,h=0),a=a.slice(0,h),!r&&f==a.length&&!o&&!u&&!l?"":(b=!0,a&&!o&&!u&&!f&&!l||E?t.onTextInput(a):t.onTextInput(a,{extendLeft:o,extendRight:u,restoreStart:f,restoreEnd:l}),b=!1,x=e,T=i,N=s,a)},P=function(e){if(y)return R();if(e&&e.inputType){if(e.inputType=="historyUndo")return t.execCommand("undo");if(e.inputType=="historyRedo")return t.execCommand("redo")}var r=n.value,i=D(r,!0);(r.length>c+100||v.test(i))&&L()},H=function(e,t,n){var r=e.clipboardData||window.clipboardData;if(!r||a)return;var i=f||n?"Text":"text/plain";try{return t?r.setData(i,t)!==!1:r.getData(i)}catch(e){if(!n)return H(e,t,!0)}},B=function(e,i){var s=t.getCopyText();if(!s)return r.preventDefault(e);H(e,s)?(d&&(L(s),m=s,setTimeout(function(){m=!1},10)),i?t.onCut():t.onCopy(),r.preventDefault(e)):(m=!0,n.value=s,n.select(),setTimeout(function(){m=!1,L(),i?t.onCut():t.onCopy()}))},j=function(e){B(e,!0)},F=function(e){B(e,!1)},I=function(e){var s=H(e);if(u.pasteCancelled())return;typeof s=="string"?(s&&t.onPaste(s,e),i.isIE&&setTimeout(L),r.preventDefault(e)):(n.value="",g=!0)};r.addCommandKeyListener(n,t.onCommandKey.bind(t)),r.addListener(n,"select",O),r.addListener(n,"input",P),r.addListener(n,"cut",j),r.addListener(n,"copy",F),r.addListener(n,"paste",I),(!("oncut"in n)||!("oncopy"in n)||!("onpaste"in n))&&r.addListener(e,"keydown",function(e){if(i.isMac&&!e.metaKey||!e.ctrlKey)return;switch(e.keyCode){case 67:F(e);break;case 86:I(e);break;case 88:j(e)}});var q=function(e){if(y||!t.onCompositionStart||t.$readOnly)return;y={};if(E)return;setTimeout(R,0),t.on("mousedown",z);var r=t.getSelectionRange();r.end.row=r.start.row,r.end.column=r.start.column,y.markerRange=r,y.selectionStart=T,t.onCompositionStart(y),y.useTextareaForIME?(n.value="",x="",T=0,N=0):(n.msGetInputContext&&(y.context=n.msGetInputContext()),n.getInputContext&&(y.context=n.getInputContext()))},R=function(){if(!y||!t.onCompositionUpdate||t.$readOnly)return;if(E)return z();if(y.useTextareaForIME)t.onCompositionUpdate(n.value);else{var e=n.value;D(e),y.markerRange&&(y.context&&(y.markerRange.start.column=y.selectionStart=y.context.compositionStartOffset),y.markerRange.end.column=y.markerRange.start.column+N-y.selectionStart)}},U=function(e){if(!t.onCompositionEnd||t.$readOnly)return;y=!1,t.onCompositionEnd(),t.off("mousedown",z),e&&P()},W=o.delayedCall(R,50).schedule.bind(null,null);r.addListener(n,"compositionstart",q),r.addListener(n,"compositionupdate",R),r.addListener(n,"keyup",X),r.addListener(n,"keydown",W),r.addListener(n,"compositionend",U),this.getElement=function(){return n},this.setCommandMode=function(e){E=e,n.readOnly=!1},this.setReadOnly=function(e){E||(n.readOnly=e)},this.setCopyWithEmptySelection=function(e){},this.onContextMenu=function(e){_=!0,L(),t._emit("nativecontextmenu",{target:t,domEvent:e}),this.moveToMouse(e,!0)},this.moveToMouse=function(e,o){w||(w=n.style.cssText),n.style.cssText=(o?"z-index:100000;":"")+(i.isIE?"opacity:0.1;":"")+"text-indent: -"+(T+N)*t.renderer.characterWidth*.5+"px;";var u=t.container.getBoundingClientRect(),a=s.computedStyle(t.container),f=u.top+(parseInt(a.borderTopWidth)||0),l=u.left+(parseInt(u.borderLeftWidth)||0),c=u.bottom-f-n.clientHeight-2,h=function(e){s.translate(n,e.clientX-l-2,Math.min(e.clientY-f-2,c))};h(e);if(e.type!="mousedown")return;t.renderer.$isMousePressed=!0,clearTimeout(V),i.isWin&&r.capture(t.container,h,$)},this.onContextMenuClose=$;var V,J=function(e){t.textInput.onContextMenu(e),$()};r.addListener(n,"mouseup",J),r.addListener(n,"mousedown",function(e){e.preventDefault(),$()}),r.addListener(t.renderer.scroller,"contextmenu",J),r.addListener(n,"contextmenu",J),d&&K(e,t,n)};t.TextInput=m}),ace.define("ace/mouse/default_handlers",["require","exports","module","ace/lib/useragent"],function(e,t,n){"use strict";function o(e){e.$clickSelection=null;var t=e.editor;t.setDefaultHandler("mousedown",this.onMouseDown.bind(e)),t.setDefaultHandler("dblclick",this.onDoubleClick.bind(e)),t.setDefaultHandler("tripleclick",this.onTripleClick.bind(e)),t.setDefaultHandler("quadclick",this.onQuadClick.bind(e)),t.setDefaultHandler("mousewheel",this.onMouseWheel.bind(e));var n=["select","startSelect","selectEnd","selectAllEnd","selectByWordsEnd","selectByLinesEnd","dragWait","dragWaitEnd","focusWait"];n.forEach(function(t){e[t]=this[t]},this),e.selectByLines=this.extendSelectionBy.bind(e,"getLineRange"),e.selectByWords=this.extendSelectionBy.bind(e,"getWordRange")}function u(e,t,n,r){return Math.sqrt(Math.pow(n-e,2)+Math.pow(r-t,2))}function a(e,t){if(e.start.row==e.end.row)var n=2*t.column-e.start.column-e.end.column;else if(e.start.row==e.end.row-1&&!e.start.column&&!e.end.column)var n=t.column-4;else var n=2*t.row-e.start.row-e.end.row;return n<0?{cursor:e.start,anchor:e.end}:{cursor:e.end,anchor:e.start}}var r=e("../lib/useragent"),i=0,s=550;(function(){this.onMouseDown=function(e){var t=e.inSelection(),n=e.getDocumentPosition();this.mousedownEvent=e;var i=this.editor,s=e.getButton();if(s!==0){var o=i.getSelectionRange(),u=o.isEmpty();(u||s==1)&&i.selection.moveToPosition(n),s==2&&(i.textInput.onContextMenu(e.domEvent),r.isMozilla||e.preventDefault());return}this.mousedownEvent.time=Date.now();if(t&&!i.isFocused()){i.focus();if(this.$focusTimeout&&!this.$clickSelection&&!i.inMultiSelectMode){this.setState("focusWait"),this.captureMouse(e);return}}return this.captureMouse(e),this.startSelect(n,e.domEvent._clicks>1),e.preventDefault()},this.startSelect=function(e,t){e=e||this.editor.renderer.screenToTextCoordinates(this.x,this.y);var n=this.editor;if(!this.mousedownEvent)return;this.mousedownEvent.getShiftKey()?n.selection.selectToPosition(e):t||n.selection.moveToPosition(e),t||this.select(),n.renderer.scroller.setCapture&&n.renderer.scroller.setCapture(),n.setStyle("ace_selecting"),this.setState("select")},this.select=function(){var e,t=this.editor,n=t.renderer.screenToTextCoordinates(this.x,this.y);if(this.$clickSelection){var r=this.$clickSelection.comparePoint(n);if(r==-1)e=this.$clickSelection.end;else if(r==1)e=this.$clickSelection.start;else{var i=a(this.$clickSelection,n);n=i.cursor,e=i.anchor}t.selection.setSelectionAnchor(e.row,e.column)}t.selection.selectToPosition(n),t.renderer.scrollCursorIntoView()},this.extendSelectionBy=function(e){var t,n=this.editor,r=n.renderer.screenToTextCoordinates(this.x,this.y),i=n.selection[e](r.row,r.column);if(this.$clickSelection){var s=this.$clickSelection.comparePoint(i.start),o=this.$clickSelection.comparePoint(i.end);if(s==-1&&o<=0){t=this.$clickSelection.end;if(i.end.row!=r.row||i.end.column!=r.column)r=i.start}else if(o==1&&s>=0){t=this.$clickSelection.start;if(i.start.row!=r.row||i.start.column!=r.column)r=i.end}else if(s==-1&&o==1)r=i.end,t=i.start;else{var u=a(this.$clickSelection,r);r=u.cursor,t=u.anchor}n.selection.setSelectionAnchor(t.row,t.column)}n.selection.selectToPosition(r),n.renderer.scrollCursorIntoView()},this.selectEnd=this.selectAllEnd=this.selectByWordsEnd=this.selectByLinesEnd=function(){this.$clickSelection=null,this.editor.unsetStyle("ace_selecting"),this.editor.renderer.scroller.releaseCapture&&this.editor.renderer.scroller.releaseCapture()},this.focusWait=function(){var e=u(this.mousedownEvent.x,this.mousedownEvent.y,this.x,this.y),t=Date.now();(e>i||t-this.mousedownEvent.time>this.$focusTimeout)&&this.startSelect(this.mousedownEvent.getDocumentPosition())},this.onDoubleClick=function(e){var t=e.getDocumentPosition(),n=this.editor,r=n.session,i=r.getBracketRange(t);i?(i.isEmpty()&&(i.start.column--,i.end.column++),this.setState("select")):(i=n.selection.getWordRange(t.row,t.column),this.setState("selectByWords")),this.$clickSelection=i,this.select()},this.onTripleClick=function(e){var t=e.getDocumentPosition(),n=this.editor;this.setState("selectByLines");var r=n.getSelectionRange();r.isMultiLine()&&r.contains(t.row,t.column)?(this.$clickSelection=n.selection.getLineRange(r.start.row),this.$clickSelection.end=n.selection.getLineRange(r.end.row).end):this.$clickSelection=n.selection.getLineRange(t.row),this.select()},this.onQuadClick=function(e){var t=this.editor;t.selectAll(),this.$clickSelection=t.getSelectionRange(),this.setState("selectAll")},this.onMouseWheel=function(e){if(e.getAccelKey())return;e.getShiftKey()&&e.wheelY&&!e.wheelX&&(e.wheelX=e.wheelY,e.wheelY=0);var t=this.editor;this.$lastScroll||(this.$lastScroll={t:0,vx:0,vy:0,allowed:0});var n=this.$lastScroll,r=e.domEvent.timeStamp,i=r-n.t,o=i?e.wheelX/i:n.vx,u=i?e.wheelY/i:n.vy;i<s&&(o=(o+n.vx)/2,u=(u+n.vy)/2);var a=Math.abs(o/u),f=!1;a>=1&&t.renderer.isScrollableBy(e.wheelX*e.speed,0)&&(f=!0),a<=1&&t.renderer.isScrollableBy(0,e.wheelY*e.speed)&&(f=!0);if(f)n.allowed=r;else if(r-n.allowed<s){var l=Math.abs(o)<=1.5*Math.abs(n.vx)&&Math.abs(u)<=1.5*Math.abs(n.vy);l?(f=!0,n.allowed=r):n.allowed=0}n.t=r,n.vx=o,n.vy=u;if(f)return t.renderer.scrollBy(e.wheelX*e.speed,e.wheelY*e.speed),e.stop()}}).call(o.prototype),t.DefaultHandlers=o}),ace.define("ace/tooltip",["require","exports","module","ace/lib/oop","ace/lib/dom"],function(e,t,n){"use strict";function s(e){this.isOpen=!1,this.$element=null,this.$parentNode=e}var r=e("./lib/oop"),i=e("./lib/dom");(function(){this.$init=function(){return this.$element=i.createElement("div"),this.$element.className="ace_tooltip",this.$element.style.display="none",this.$parentNode.appendChild(this.$element),this.$element},this.getElement=function(){return this.$element||this.$init()},this.setText=function(e){this.getElement().textContent=e},this.setHtml=function(e){this.getElement().innerHTML=e},this.setPosition=function(e,t){this.getElement().style.left=e+"px",this.getElement().style.top=t+"px"},this.setClassName=function(e){i.addCssClass(this.getElement(),e)},this.show=function(e,t,n){e!=null&&this.setText(e),t!=null&&n!=null&&this.setPosition(t,n),this.isOpen||(this.getElement().style.display="block",this.isOpen=!0)},this.hide=function(){this.isOpen&&(this.getElement().style.display="none",this.isOpen=!1)},this.getHeight=function(){return this.getElement().offsetHeight},this.getWidth=function(){return this.getElement().offsetWidth},this.destroy=function(){this.isOpen=!1,this.$element&&this.$element.parentNode&&this.$element.parentNode.removeChild(this.$element)}}).call(s.prototype),t.Tooltip=s}),ace.define("ace/mouse/default_gutter_handler",["require","exports","module","ace/lib/dom","ace/lib/oop","ace/lib/event","ace/tooltip"],function(e,t,n){"use strict";function u(e){function l(){var r=u.getDocumentPosition().row,s=n.$annotations[r];if(!s)return c();var o=t.session.getLength();if(r==o){var a=t.renderer.pixelToScreenCoordinates(0,u.y).row,l=u.$pos;if(a>t.session.documentToScreenRow(l.row,l.column))return c()}if(f==s)return;f=s.text.join("<br/>"),i.setHtml(f),i.show(),t._signal("showGutterTooltip",i),t.on("mousewheel",c);if(e.$tooltipFollowsMouse)h(u);else{var p=u.domEvent.target,d=p.getBoundingClientRect(),v=i.getElement().style;v.left=d.right+"px",v.top=d.bottom+"px"}}function c(){o&&(o=clearTimeout(o)),f&&(i.hide(),f=null,t._signal("hideGutterTooltip",i),t.removeEventListener("mousewheel",c))}function h(e){i.setPosition(e.x,e.y)}var t=e.editor,n=t.renderer.$gutterLayer,i=new a(t.container);e.editor.setDefaultHandler("guttermousedown",function(r){if(!t.isFocused()||r.getButton()!=0)return;var i=n.getRegion(r);if(i=="foldWidgets")return;var s=r.getDocumentPosition().row,o=t.session.selection;if(r.getShiftKey())o.selectTo(s,0);else{if(r.domEvent.detail==2)return t.selectAll(),r.preventDefault();e.$clickSelection=t.selection.getLineRange(s)}return e.setState("selectByLines"),e.captureMouse(r),r.preventDefault()});var o,u,f;e.editor.setDefaultHandler("guttermousemove",function(t){var n=t.domEvent.target||t.domEvent.srcElement;if(r.hasCssClass(n,"ace_fold-widget"))return c();f&&e.$tooltipFollowsMouse&&h(t),u=t;if(o)return;o=setTimeout(function(){o=null,u&&!e.isMousePressed?l():c()},50)}),s.addListener(t.renderer.$gutter,"mouseout",function(e){u=null;if(!f||o)return;o=setTimeout(function(){o=null,c()},50)}),t.on("changeSession",c)}function a(e){o.call(this,e)}var r=e("../lib/dom"),i=e("../lib/oop"),s=e("../lib/event"),o=e("../tooltip").Tooltip;i.inherits(a,o),function(){this.setPosition=function(e,t){var n=window.innerWidth||document.documentElement.clientWidth,r=window.innerHeight||document.documentElement.clientHeight,i=this.getWidth(),s=this.getHeight();e+=15,t+=15,e+i>n&&(e-=e+i-n),t+s>r&&(t-=20+s),o.prototype.setPosition.call(this,e,t)}}.call(a.prototype),t.GutterHandler=u}),ace.define("ace/mouse/mouse_event",["require","exports","module","ace/lib/event","ace/lib/useragent"],function(e,t,n){"use strict";var r=e("../lib/event"),i=e("../lib/useragent"),s=t.MouseEvent=function(e,t){this.domEvent=e,this.editor=t,this.x=this.clientX=e.clientX,this.y=this.clientY=e.clientY,this.$pos=null,this.$inSelection=null,this.propagationStopped=!1,this.defaultPrevented=!1};(function(){this.stopPropagation=function(){r.stopPropagation(this.domEvent),this.propagationStopped=!0},this.preventDefault=function(){r.preventDefault(this.domEvent),this.defaultPrevented=!0},this.stop=function(){this.stopPropagation(),this.preventDefault()},this.getDocumentPosition=function(){return this.$pos?this.$pos:(this.$pos=this.editor.renderer.screenToTextCoordinates(this.clientX,this.clientY),this.$pos)},this.inSelection=function(){if(this.$inSelection!==null)return this.$inSelection;var e=this.editor,t=e.getSelectionRange();if(t.isEmpty())this.$inSelection=!1;else{var n=this.getDocumentPosition();this.$inSelection=t.contains(n.row,n.column)}return this.$inSelection},this.getButton=function(){return r.getButton(this.domEvent)},this.getShiftKey=function(){return this.domEvent.shiftKey},this.getAccelKey=i.isMac?function(){return this.domEvent.metaKey}:function(){return this.domEvent.ctrlKey}}).call(s.prototype)}),ace.define("ace/mouse/dragdrop_handler",["require","exports","module","ace/lib/dom","ace/lib/event","ace/lib/useragent"],function(e,t,n){"use strict";function f(e){function T(e,n){var r=Date.now(),i=!n||e.row!=n.row,s=!n||e.column!=n.column;if(!S||i||s)t.moveCursorToPosition(e),S=r,x={x:p,y:d};else{var o=l(x.x,x.y,p,d);o>a?S=null:r-S>=u&&(t.renderer.scrollCursorIntoView(),S=null)}}function N(e,n){var r=Date.now(),i=t.renderer.layerConfig.lineHeight,s=t.renderer.layerConfig.characterWidth,u=t.renderer.scroller.getBoundingClientRect(),a={x:{left:p-u.left,right:u.right-p},y:{top:d-u.top,bottom:u.bottom-d}},f=Math.min(a.x.left,a.x.right),l=Math.min(a.y.top,a.y.bottom),c={row:e.row,column:e.column};f/s<=2&&(c.column+=a.x.left<a.x.right?-3:2),l/i<=1&&(c.row+=a.y.top<a.y.bottom?-1:1);var h=e.row!=c.row,v=e.column!=c.column,m=!n||e.row!=n.row;h||v&&!m?E?r-E>=o&&t.renderer.scrollCursorIntoView(c):E=r:E=null}function C(){var e=g;g=t.renderer.screenToTextCoordinates(p,d),T(g,e),N(g,e)}function k(){m=t.selection.toOrientedRange(),h=t.session.addMarker(m,"ace_selection",t.getSelectionStyle()),t.clearSelection(),t.isFocused()&&t.renderer.$cursorLayer.setBlinking(!1),clearInterval(v),C(),v=setInterval(C,20),y=0,i.addListener(document,"mousemove",O)}function L(){clearInterval(v),t.session.removeMarker(h),h=null,t.selection.fromOrientedRange(m),t.isFocused()&&!w&&t.$resetCursorStyle(),m=null,g=null,y=0,E=null,S=null,i.removeListener(document,"mousemove",O)}function O(){A==null&&(A=setTimeout(function(){A!=null&&h&&L()},20))}function M(e){var t=e.types;return!t||Array.prototype.some.call(t,function(e){return e=="text/plain"||e=="Text"})}function _(e){var t=["copy","copymove","all","uninitialized"],n=["move","copymove","linkmove","all","uninitialized"],r=s.isMac?e.altKey:e.ctrlKey,i="uninitialized";try{i=e.dataTransfer.effectAllowed.toLowerCase()}catch(e){}var o="none";return r&&t.indexOf(i)>=0?o="copy":n.indexOf(i)>=0?o="move":t.indexOf(i)>=0&&(o="copy"),o}var t=e.editor,n=r.createElement("img");n.src="data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==",s.isOpera&&(n.style.cssText="width:1px;height:1px;position:fixed;top:0;left:0;z-index:2147483647;opacity:0;");var f=["dragWait","dragWaitEnd","startDrag","dragReadyEnd","onMouseDrag"];f.forEach(function(t){e[t]=this[t]},this),t.addEventListener("mousedown",this.onMouseDown.bind(e));var c=t.container,h,p,d,v,m,g,y=0,b,w,E,S,x;this.onDragStart=function(e){if(this.cancelDrag||!c.draggable){var r=this;return setTimeout(function(){r.startSelect(),r.captureMouse(e)},0),e.preventDefault()}m=t.getSelectionRange();var i=e.dataTransfer;i.effectAllowed=t.getReadOnly()?"copy":"copyMove",s.isOpera&&(t.container.appendChild(n),n.scrollTop=0),i.setDragImage&&i.setDragImage(n,0,0),s.isOpera&&t.container.removeChild(n),i.clearData(),i.setData("Text",t.session.getTextRange()),w=!0,this.setState("drag")},this.onDragEnd=function(e){c.draggable=!1,w=!1,this.setState(null);if(!t.getReadOnly()){var n=e.dataTransfer.dropEffect;!b&&n=="move"&&t.session.remove(t.getSelectionRange()),t.$resetCursorStyle()}this.editor.unsetStyle("ace_dragging"),this.editor.renderer.setCursorStyle("")},this.onDragEnter=function(e){if(t.getReadOnly()||!M(e.dataTransfer))return;return p=e.clientX,d=e.clientY,h||k(),y++,e.dataTransfer.dropEffect=b=_(e),i.preventDefault(e)},this.onDragOver=function(e){if(t.getReadOnly()||!M(e.dataTransfer))return;return p=e.clientX,d=e.clientY,h||(k(),y++),A!==null&&(A=null),e.dataTransfer.dropEffect=b=_(e),i.preventDefault(e)},this.onDragLeave=function(e){y--;if(y<=0&&h)return L(),b=null,i.preventDefault(e)},this.onDrop=function(e){if(!g)return;var n=e.dataTransfer;if(w)switch(b){case"move":m.contains(g.row,g.column)?m={start:g,end:g}:m=t.moveText(m,g);break;case"copy":m=t.moveText(m,g,!0)}else{var r=n.getData("Text");m={start:g,end:t.session.insert(g,r)},t.focus(),b=null}return L(),i.preventDefault(e)},i.addListener(c,"dragstart",this.onDragStart.bind(e)),i.addListener(c,"dragend",this.onDragEnd.bind(e)),i.addListener(c,"dragenter",this.onDragEnter.bind(e)),i.addListener(c,"dragover",this.onDragOver.bind(e)),i.addListener(c,"dragleave",this.onDragLeave.bind(e)),i.addListener(c,"drop",this.onDrop.bind(e));var A=null}function l(e,t,n,r){return Math.sqrt(Math.pow(n-e,2)+Math.pow(r-t,2))}var r=e("../lib/dom"),i=e("../lib/event"),s=e("../lib/useragent"),o=200,u=200,a=5;(function(){this.dragWait=function(){var e=Date.now()-this.mousedownEvent.time;e>this.editor.getDragDelay()&&this.startDrag()},this.dragWaitEnd=function(){var e=this.editor.container;e.draggable=!1,this.startSelect(this.mousedownEvent.getDocumentPosition()),this.selectEnd()},this.dragReadyEnd=function(e){this.editor.$resetCursorStyle(),this.editor.unsetStyle("ace_dragging"),this.editor.renderer.setCursorStyle(""),this.dragWaitEnd()},this.startDrag=function(){this.cancelDrag=!1;var e=this.editor,t=e.container;t.draggable=!0,e.renderer.$cursorLayer.setBlinking(!1),e.setStyle("ace_dragging");var n=s.isWin?"default":"move";e.renderer.setCursorStyle(n),this.setState("dragReady")},this.onMouseDrag=function(e){var t=this.editor.container;if(s.isIE&&this.state=="dragReady"){var n=l(this.mousedownEvent.x,this.mousedownEvent.y,this.x,this.y);n>3&&t.dragDrop()}if(this.state==="dragWait"){var n=l(this.mousedownEvent.x,this.mousedownEvent.y,this.x,this.y);n>0&&(t.draggable=!1,this.startSelect(this.mousedownEvent.getDocumentPosition()))}},this.onMouseDown=function(e){if(!this.$dragEnabled)return;this.mousedownEvent=e;var t=this.editor,n=e.inSelection(),r=e.getButton(),i=e.domEvent.detail||1;if(i===1&&r===0&&n){if(e.editor.inMultiSelectMode&&(e.getAccelKey()||e.getShiftKey()))return;this.mousedownEvent.time=Date.now();var o=e.domEvent.target||e.domEvent.srcElement;"unselectable"in o&&(o.unselectable="on");if(t.getDragDelay()){if(s.isWebKit){this.cancelDrag=!0;var u=t.container;u.draggable=!0}this.setState("dragWait")}else this.startDrag();this.captureMouse(e,this.onMouseDrag.bind(this)),e.defaultPrevented=!0}}}).call(f.prototype),t.DragdropHandler=f}),ace.define("ace/mouse/touch_handler",["require","exports","module","ace/mouse/mouse_event","ace/lib/dom"],function(e,t,n){"use strict";var r=e("./mouse_event").MouseEvent,i=e("../lib/dom");t.addTouchListeners=function(e,t){function y(){var e=window.navigator&&window.navigator.clipboard,r=!1,s=function(){var n=t.getCopyText(),s=t.session.getUndoManager().hasUndo();g.replaceChild(i.buildDom(r?["span",!n&&["span",{"class":"ace_mobile-button",action:"selectall"},"Select All"],n&&["span",{"class":"ace_mobile-button",action:"copy"},"Copy"],n&&["span",{"class":"ace_mobile-button",action:"cut"},"Cut"],e&&["span",{"class":"ace_mobile-button",action:"paste"},"Paste"],s&&["span",{"class":"ace_mobile-button",action:"undo"},"Undo"],["span",{"class":"ace_mobile-button",action:"find"},"Find"],["span",{"class":"ace_mobile-button",action:"openCommandPallete"},"Pallete"]]:["span"]),g.firstChild)},o=function(n){var i=n.target.getAttribute("action");if(i=="more"||!r)return r=!r,s();if(i=="paste")e.readText().then(function(e){t.execCommand(i,e)});else if(i){if(i=="cut"||i=="copy")e?e.writeText(t.getCopyText()):document.execCommand("copy");t.execCommand(i)}g.firstChild.style.display="none",r=!1,i!="openCommandPallete"&&t.focus()};g=i.buildDom(["div",{"class":"ace_mobile-menu",ontouchstart:function(e){n="menu",e.stopPropagation(),e.preventDefault(),t.textInput.focus()},ontouchend:function(e){e.stopPropagation(),e.preventDefault(),o(e)},onclick:o},["span"],["span",{"class":"ace_mobile-button",action:"more"},"..."]],t.container)}function b(){g||y();var e=t.selection.cursor,n=t.renderer.textToScreenCoordinates(e.row,e.column),r=t.container.getBoundingClientRect();g.style.top=n.pageY-r.top-3+"px",g.style.right="10px",g.style.display="",g.firstChild.style.display="none",t.on("input",w)}function w(e){g&&(g.style.display="none"),t.off("input",w)}function E(){f=null,clearTimeout(f);var e=t.selection.getRange(),r=e.contains(h.row,h.column);if(e.isEmpty()||!r)t.selection.moveToPosition(h),t.selection.selectWord();n="wait",b()}function S(){f=null,clearTimeout(f),t.selection.moveToPosition(h);var e=p>=2?t.selection.getLineRange(h.row):t.session.getBracketRange(h);e&&!e.isEmpty()?t.selection.setRange(e):t.selection.selectWord(),n="wait"}function x(){c+=60,l=setInterval(function(){c--<=0&&(clearInterval(l),l=null),Math.abs(d)<.01&&(d=0),Math.abs(v)<.01&&(v=0),c<20&&(d=.9*d),c<20&&(v=.9*v);var e=t.session.getScrollTop();t.renderer.scrollBy(10*d,10*v),e==t.session.getScrollTop()&&(c=0)},10)}var n="scroll",s,o,u,a,f,l,c=0,h,p=0,d=0,v=0,m,g;e.addEventListener("contextmenu",function(e){if(!m)return;var n=t.textInput.getElement();n.focus()}),e.addEventListener("touchstart",function(e){var i=e.touches;if(f||i.length>1){clearTimeout(f),f=null,u=-1,n="zoom";return}m=t.$mouseHandler.isMousePressed=!0;var l=t.renderer.layerConfig.lineHeight,g=t.renderer.layerConfig.lineHeight,y=e.timeStamp;a=y;var b=i[0],w=b.clientX,x=b.clientY;Math.abs(s-w)+Math.abs(o-x)>l&&(u=-1),s=e.clientX=w,o=e.clientY=x,d=v=0;var T=new r(e,t);h=T.getDocumentPosition();if(y-u<500&&i.length==1&&!c)p++,e.preventDefault(),e.button=0,S();else{p=0;var N=t.selection.cursor,C=t.selection.isEmpty()?N:t.selection.anchor,k=t.renderer.$cursorLayer.getPixelPosition(N,!0),L=t.renderer.$cursorLayer.getPixelPosition(C,!0),A=t.renderer.scroller.getBoundingClientRect(),O=function(e,t){return e/=g,t=t/l-.75,e*e+t*t};if(e.clientX<A.left){n="zoom";return}var M=O(e.clientX-A.left-k.left,e.clientY-A.top-k.top),_=O(e.clientX-A.left-L.left,e.clientY-A.top-L.top);M<3.5&&_<3.5&&(n=M>_?"cursor":"anchor"),_<3.5?n="anchor":M<3.5?n="cursor":n="scroll",f=setTimeout(E,450)}u=y}),e.addEventListener("touchend",function(e){m=t.$mouseHandler.isMousePressed=!1,l&&clearInterval(l),n=="zoom"?(n="",c=0):f?(t.selection.moveToPosition(h),c=0,b()):n=="scroll"?(x(),e.preventDefault(),w()):b(),clearTimeout(f),f=null}),e.addEventListener("touchmove",function(e){f&&(clearTimeout(f),f=null);var i=e.touches;if(i.length>1||n=="zoom")return;var u=i[0],l=s-u.clientX,c=o-u.clientY;if(n=="wait"){if(!(l*l+c*c>4))return e.preventDefault();n="cursor"}s=u.clientX,o=u.clientY,e.clientX=u.clientX,e.clientY=u.clientY;var h=e.timeStamp,p=h-a;a=h;if(n=="scroll"){var m=new r(e,t);m.speed=1,m.wheelX=l,m.wheelY=c,10*Math.abs(l)<Math.abs(c)&&(l=0),10*Math.abs(c)<Math.abs(l)&&(c=0),p!=0&&(d=l/p,v=c/p),t._emit("mousewheel",m),m.propagationStopped||(d=v=0)}else{var g=new r(e,t),y=g.getDocumentPosition();n=="cursor"?t.selection.moveCursorToPosition(y):n=="anchor"&&t.selection.setSelectionAnchor(y.row,y.column),t.renderer.scrollCursorIntoView(y),e.preventDefault()}})}}),ace.define("ace/lib/net",["require","exports","module","ace/lib/dom"],function(e,t,n){"use strict";var r=e("./dom");t.get=function(e,t){var n=new XMLHttpRequest;n.open("GET",e,!0),n.onreadystatechange=function(){n.readyState===4&&t(n.responseText)},n.send(null)},t.loadScript=function(e,t){var n=r.getDocumentHead(),i=document.createElement("script");i.src=e,n.appendChild(i),i.onload=i.onreadystatechange=function(e,n){if(n||!i.readyState||i.readyState=="loaded"||i.readyState=="complete")i=i.onload=i.onreadystatechange=null,n||t()}},t.qualifyURL=function(e){var t=document.createElement("a");return t.href=e,t.href}}),ace.define("ace/lib/event_emitter",["require","exports","module"],function(e,t,n){"use strict";var r={},i=function(){this.propagationStopped=!0},s=function(){this.defaultPrevented=!0};r._emit=r._dispatchEvent=function(e,t){this._eventRegistry||(this._eventRegistry={}),this._defaultHandlers||(this._defaultHandlers={});var n=this._eventRegistry[e]||[],r=this._defaultHandlers[e];if(!n.length&&!r)return;if(typeof t!="object"||!t)t={};t.type||(t.type=e),t.stopPropagation||(t.stopPropagation=i),t.preventDefault||(t.preventDefault=s),n=n.slice();for(var o=0;o<n.length;o++){n[o](t,this);if(t.propagationStopped)break}if(r&&!t.defaultPrevented)return r(t,this)},r._signal=function(e,t){var n=(this._eventRegistry||{})[e];if(!n)return;n=n.slice();for(var r=0;r<n.length;r++)n[r](t,this)},r.once=function(e,t){var n=this;this.addEventListener(e,function r(){n.removeEventListener(e,r),t.apply(null,arguments)});if(!t)return new Promise(function(e){t=e})},r.setDefaultHandler=function(e,t){var n=this._defaultHandlers;n||(n=this._defaultHandlers={_disabled_:{}});if(n[e]){var r=n[e],i=n._disabled_[e];i||(n._disabled_[e]=i=[]),i.push(r);var s=i.indexOf(t);s!=-1&&i.splice(s,1)}n[e]=t},r.removeDefaultHandler=function(e,t){var n=this._defaultHandlers;if(!n)return;var r=n._disabled_[e];if(n[e]==t)r&&this.setDefaultHandler(e,r.pop());else if(r){var i=r.indexOf(t);i!=-1&&r.splice(i,1)}},r.on=r.addEventListener=function(e,t,n){this._eventRegistry=this._eventRegistry||{};var r=this._eventRegistry[e];return r||(r=this._eventRegistry[e]=[]),r.indexOf(t)==-1&&r[n?"unshift":"push"](t),t},r.off=r.removeListener=r.removeEventListener=function(e,t){this._eventRegistry=this._eventRegistry||{};var n=this._eventRegistry[e];if(!n)return;var r=n.indexOf(t);r!==-1&&n.splice(r,1)},r.removeAllListeners=function(e){this._eventRegistry&&(this._eventRegistry[e]=[])},t.EventEmitter=r}),ace.define("ace/lib/app_config",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"],function(e,t,n){"no use strict";function o(e){typeof console!="undefined"&&console.warn&&console.warn.apply(console,arguments)}function u(e,t){var n=new Error(e);n.data=t,typeof console=="object"&&console.error&&console.error(n),setTimeout(function(){throw n})}var r=e("./oop"),i=e("./event_emitter").EventEmitter,s={setOptions:function(e){Object.keys(e).forEach(function(t){this.setOption(t,e[t])},this)},getOptions:function(e){var t={};if(!e){var n=this.$options;e=Object.keys(n).filter(function(e){return!n[e].hidden})}else Array.isArray(e)||(t=e,e=Object.keys(t));return e.forEach(function(e){t[e]=this.getOption(e)},this),t},setOption:function(e,t){if(this["$"+e]===t)return;var n=this.$options[e];if(!n)return o('misspelled option "'+e+'"');if(n.forwardTo)return this[n.forwardTo]&&this[n.forwardTo].setOption(e,t);n.handlesSet||(this["$"+e]=t),n&&n.set&&n.set.call(this,t)},getOption:function(e){var t=this.$options[e];return t?t.forwardTo?this[t.forwardTo]&&this[t.forwardTo].getOption(e):t&&t.get?t.get.call(this):this["$"+e]:o('misspelled option "'+e+'"')}},a=function(){this.$defaultOptions={}};(function(){r.implement(this,i),this.defineOptions=function(e,t,n){return e.$options||(this.$defaultOptions[t]=e.$options={}),Object.keys(n).forEach(function(t){var r=n[t];typeof r=="string"&&(r={forwardTo:r}),r.name||(r.name=t),e.$options[r.name]=r,"initialValue"in r&&(e["$"+r.name]=r.initialValue)}),r.implement(e,s),this},this.resetOptions=function(e){Object.keys(e.$options).forEach(function(t){var n=e.$options[t];"value"in n&&e.setOption(t,n.value)})},this.setDefaultValue=function(e,t,n){if(!e){for(e in this.$defaultOptions)if(this.$defaultOptions[e][t])break;if(!this.$defaultOptions[e][t])return!1}var r=this.$defaultOptions[e]||(this.$defaultOptions[e]={});r[t]&&(r.forwardTo?this.setDefaultValue(r.forwardTo,t,n):r[t].value=n)},this.setDefaultValues=function(e,t){Object.keys(t).forEach(function(n){this.setDefaultValue(e,n,t[n])},this)},this.warn=o,this.reportError=u}).call(a.prototype),t.AppConfig=a}),ace.define("ace/config",["require","exports","module","ace/lib/lang","ace/lib/oop","ace/lib/net","ace/lib/app_config"],function(e,t,n){"no use strict";function l(r){if(!u||!u.document)return;a.packaged=r||e.packaged||n.packaged||u.define&&define.packaged;var i={},s="",o=document.currentScript||document._currentScript,f=o&&o.ownerDocument||document,l=f.getElementsByTagName("script");for(var h=0;h<l.length;h++){var p=l[h],d=p.src||p.getAttribute("src");if(!d)continue;var v=p.attributes;for(var m=0,g=v.length;m<g;m++){var y=v[m];y.name.indexOf("data-ace-")===0&&(i[c(y.name.replace(/^data-ace-/,""))]=y.value)}var b=d.match(/^(.*)\/ace(\-\w+)?\.js(\?|$)/);b&&(s=b[1])}s&&(i.base=i.base||s,i.packaged=!0),i.basePath=i.base,i.workerPath=i.workerPath||i.base,i.modePath=i.modePath||i.base,i.themePath=i.themePath||i.base,delete i.base;for(var w in i)typeof i[w]!="undefined"&&t.set(w,i[w])}function c(e){return e.replace(/-(.)/g,function(e,t){return t.toUpperCase()})}var r=e("./lib/lang"),i=e("./lib/oop"),s=e("./lib/net"),o=e("./lib/app_config").AppConfig;n.exports=t=new o;var u=function(){return this||typeof window!="undefined"&&window}(),a={packaged:!1,workerPath:null,modePath:null,themePath:null,basePath:"",suffix:".js",$moduleUrls:{},loadWorkerFromBlob:!0,sharedPopups:!1};t.get=function(e){if(!a.hasOwnProperty(e))throw new Error("Unknown config key: "+e);return a[e]},t.set=function(e,t){if(a.hasOwnProperty(e))a[e]=t;else if(this.setDefaultValue("",e,t)==0)throw new Error("Unknown config key: "+e)},t.all=function(){return r.copyObject(a)},t.$modes={},t.moduleUrl=function(e,t){if(a.$moduleUrls[e])return a.$moduleUrls[e];var n=e.split("/");t=t||n[n.length-2]||"";var r=t=="snippets"?"/":"-",i=n[n.length-1];if(t=="worker"&&r=="-"){var s=new RegExp("^"+t+"[\\-_]|[\\-_]"+t+"$","g");i=i.replace(s,"")}(!i||i==t)&&n.length>1&&(i=n[n.length-2]);var o=a[t+"Path"];return o==null?o=a.basePath:r=="/"&&(t=r=""),o&&o.slice(-1)!="/"&&(o+="/"),o+t+r+i+this.get("suffix")},t.setModuleUrl=function(e,t){return a.$moduleUrls[e]=t},t.$loading={},t.loadModule=function(n,r){var i,o;Array.isArray(n)&&(o=n[0],n=n[1]);try{i=e(n)}catch(u){}if(i&&!t.$loading[n])return r&&r(i);t.$loading[n]||(t.$loading[n]=[]),t.$loading[n].push(r);if(t.$loading[n].length>1)return;var a=function(){e([n],function(e){t._emit("load.module",{name:n,module:e});var r=t.$loading[n];t.$loading[n]=null,r.forEach(function(t){t&&t(e)})})};if(!t.get("packaged"))return a();s.loadScript(t.moduleUrl(n,o),a),f()};var f=function(){!a.basePath&&!a.workerPath&&!a.modePath&&!a.themePath&&!Object.keys(a.$moduleUrls).length&&(console.error("Unable to infer path to ace from script src,","use ace.config.set('basePath', 'path') to enable dynamic loading of modes and themes","or with webpack use ace/webpack-resolver"),f=function(){})};t.init=l,t.version="1.4.6"}),ace.define("ace/mouse/mouse_handler",["require","exports","module","ace/lib/event","ace/lib/useragent","ace/mouse/default_handlers","ace/mouse/default_gutter_handler","ace/mouse/mouse_event","ace/mouse/dragdrop_handler","ace/mouse/touch_handler","ace/config"],function(e,t,n){"use strict";var r=e("../lib/event"),i=e("../lib/useragent"),s=e("./default_handlers").DefaultHandlers,o=e("./default_gutter_handler").GutterHandler,u=e("./mouse_event").MouseEvent,a=e("./dragdrop_handler").DragdropHandler,f=e("./touch_handler").addTouchListeners,l=e("../config"),c=function(e){var t=this;this.editor=e,new s(this),new o(this),new a(this);var n=function(t){var n=!document.hasFocus||!document.hasFocus()||!e.isFocused()&&document.activeElement==(e.textInput&&e.textInput.getElement());n&&window.focus(),e.focus()},u=e.renderer.getMouseEventTarget();r.addListener(u,"click",this.onMouseEvent.bind(this,"click")),r.addListener(u,"mousemove",this.onMouseMove.bind(this,"mousemove")),r.addMultiMouseDownListener([u,e.renderer.scrollBarV&&e.renderer.scrollBarV.inner,e.renderer.scrollBarH&&e.renderer.scrollBarH.inner,e.textInput&&e.textInput.getElement()].filter(Boolean),[400,300,250],this,"onMouseEvent"),r.addMouseWheelListener(e.container,this.onMouseWheel.bind(this,"mousewheel")),f(e.container,e);var l=e.renderer.$gutter;r.addListener(l,"mousedown",this.onMouseEvent.bind(this,"guttermousedown")),r.addListener(l,"click",this.onMouseEvent.bind(this,"gutterclick")),r.addListener(l,"dblclick",this.onMouseEvent.bind(this,"gutterdblclick")),r.addListener(l,"mousemove",this.onMouseEvent.bind(this,"guttermousemove")),r.addListener(u,"mousedown",n),r.addListener(l,"mousedown",n),i.isIE&&e.renderer.scrollBarV&&(r.addListener(e.renderer.scrollBarV.element,"mousedown",n),r.addListener(e.renderer.scrollBarH.element,"mousedown",n)),e.on("mousemove",function(n){if(t.state||t.$dragDelay||!t.$dragEnabled)return;var r=e.renderer.screenToTextCoordinates(n.x,n.y),i=e.session.selection.getRange(),s=e.renderer;!i.isEmpty()&&i.insideStart(r.row,r.column)?s.setCursorStyle("default"):s.setCursorStyle("")})};(function(){this.onMouseEvent=function(e,t){this.editor._emit(e,new u(t,this.editor))},this.onMouseMove=function(e,t){var n=this.editor._eventRegistry&&this.editor._eventRegistry.mousemove;if(!n||!n.length)return;this.editor._emit(e,new u(t,this.editor))},this.onMouseWheel=function(e,t){var n=new u(t,this.editor);n.speed=this.$scrollSpeed*2,n.wheelX=t.wheelX,n.wheelY=t.wheelY,this.editor._emit(e,n)},this.setState=function(e){this.state=e},this.captureMouse=function(e,t){this.x=e.x,this.y=e.y,this.isMousePressed=!0;var n=this.editor,s=this.editor.renderer;s.$isMousePressed=!0;var o=this,a=function(e){if(!e)return;if(i.isWebKit&&!e.which&&o.releaseMouse)return o.releaseMouse();o.x=e.clientX,o.y=e.clientY,t&&t(e),o.mouseEvent=new u(e,o.editor),o.$mouseMoved=!0},f=function(e){n.off("beforeEndOperation",c),clearInterval(h),l(),o[o.state+"End"]&&o[o.state+"End"](e),o.state="",o.isMousePressed=s.$isMousePressed=!1,s.$keepTextAreaAtCursor&&s.$moveTextAreaToCursor(),o.$onCaptureMouseMove=o.releaseMouse=null,e&&o.onMouseEvent("mouseup",e),n.endOperation()},l=function(){o[o.state]&&o[o.state](),o.$mouseMoved=!1};if(i.isOldIE&&e.domEvent.type=="dblclick")return setTimeout(function(){f(e)});var c=function(e){if(!o.releaseMouse)return;n.curOp.command.name&&n.curOp.selectionChanged&&(o[o.state+"End"]&&o[o.state+"End"](),o.state="",o.releaseMouse())};n.on("beforeEndOperation",c),n.startOperation({command:{name:"mouse"}}),o.$onCaptureMouseMove=a,o.releaseMouse=r.capture(this.editor.container,a,f);var h=setInterval(l,20)},this.releaseMouse=null,this.cancelContextMenu=function(){var e=function(t){if(t&&t.domEvent&&t.domEvent.type!="contextmenu")return;this.editor.off("nativecontextmenu",e),t&&t.domEvent&&r.stopEvent(t.domEvent)}.bind(this);setTimeout(e,10),this.editor.on("nativecontextmenu",e)}}).call(c.prototype),l.defineOptions(c.prototype,"mouseHandler",{scrollSpeed:{initialValue:2},dragDelay:{initialValue:i.isMac?150:0},dragEnabled:{initialValue:!0},focusTimeout:{initialValue:0},tooltipFollowsMouse:{initialValue:!0}}),t.MouseHandler=c}),ace.define("ace/mouse/fold_handler",["require","exports","module","ace/lib/dom"],function(e,t,n){"use strict";function i(e){e.on("click",function(t){var n=t.getDocumentPosition(),i=e.session,s=i.getFoldAt(n.row,n.column,1);s&&(t.getAccelKey()?i.removeFold(s):i.expandFold(s),t.stop());var o=t.domEvent&&t.domEvent.target;o&&r.hasCssClass(o,"ace_inline_button")&&r.hasCssClass(o,"ace_toggle_wrap")&&(i.setOption("wrap",!i.getUseWrapMode()),e.renderer.scrollCursorIntoView())}),e.on("gutterclick",function(t){var n=e.renderer.$gutterLayer.getRegion(t);if(n=="foldWidgets"){var r=t.getDocumentPosition().row,i=e.session;i.foldWidgets&&i.foldWidgets[r]&&e.session.onFoldWidgetClick(r,t),e.isFocused()||e.focus(),t.stop()}}),e.on("gutterdblclick",function(t){var n=e.renderer.$gutterLayer.getRegion(t);if(n=="foldWidgets"){var r=t.getDocumentPosition().row,i=e.session,s=i.getParentFoldRangeData(r,!0),o=s.range||s.firstRange;if(o){r=o.start.row;var u=i.getFoldAt(r,i.getLine(r).length,1);u?i.removeFold(u):(i.addFold("...",o),e.renderer.scrollCursorIntoView({row:o.start.row,column:0}))}t.stop()}})}var r=e("../lib/dom");t.FoldHandler=i}),ace.define("ace/keyboard/keybinding",["require","exports","module","ace/lib/keys","ace/lib/event"],function(e,t,n){"use strict";var r=e("../lib/keys"),i=e("../lib/event"),s=function(e){this.$editor=e,this.$data={editor:e},this.$handlers=[],this.setDefaultHandler(e.commands)};(function(){this.setDefaultHandler=function(e){this.removeKeyboardHandler(this.$defaultHandler),this.$defaultHandler=e,this.addKeyboardHandler(e,0)},this.setKeyboardHandler=function(e){var t=this.$handlers;if(t[t.length-1]==e)return;while(t[t.length-1]&&t[t.length-1]!=this.$defaultHandler)this.removeKeyboardHandler(t[t.length-1]);this.addKeyboardHandler(e,1)},this.addKeyboardHandler=function(e,t){if(!e)return;typeof e=="function"&&!e.handleKeyboard&&(e.handleKeyboard=e);var n=this.$handlers.indexOf(e);n!=-1&&this.$handlers.splice(n,1),t==undefined?this.$handlers.push(e):this.$handlers.splice(t,0,e),n==-1&&e.attach&&e.attach(this.$editor)},this.removeKeyboardHandler=function(e){var t=this.$handlers.indexOf(e);return t==-1?!1:(this.$handlers.splice(t,1),e.detach&&e.detach(this.$editor),!0)},this.getKeyboardHandler=function(){return this.$handlers[this.$handlers.length-1]},this.getStatusText=function(){var e=this.$data,t=e.editor;return this.$handlers.map(function(n){return n.getStatusText&&n.getStatusText(t,e)||""}).filter(Boolean).join(" ")},this.$callKeyboardHandlers=function(e,t,n,r){var s,o=!1,u=this.$editor.commands;for(var a=this.$handlers.length;a--;){s=this.$handlers[a].handleKeyboard(this.$data,e,t,n,r);if(!s||!s.command)continue;s.command=="null"?o=!0:o=u.exec(s.command,this.$editor,s.args,r),o&&r&&e!=-1&&s.passEvent!=1&&s.command.passEvent!=1&&i.stopEvent(r);if(o)break}return!o&&e==-1&&(s={command:"insertstring"},o=u.exec("insertstring",this.$editor,t)),o&&this.$editor._signal&&this.$editor._signal("keyboardActivity",s),o},this.onCommandKey=function(e,t,n){var i=r.keyCodeToString(n);return this.$callKeyboardHandlers(t,i,n,e)},this.onTextInput=function(e){return this.$callKeyboardHandlers(-1,e)}}).call(s.prototype),t.KeyBinding=s}),ace.define("ace/lib/bidiutil",["require","exports","module"],function(e,t,n){"use strict";function F(e,t,n,r){var i=s?d:p,c=null,h=null,v=null,m=0,g=null,y=null,b=-1,w=null,E=null,T=[];if(!r)for(w=0,r=[];w<n;w++)r[w]=R(e[w]);o=s,u=!1,a=!1,f=!1,l=!1;for(E=0;E<n;E++){c=m,T[E]=h=q(e,r,T,E),m=i[c][h],g=m&240,m&=15,t[E]=v=i[m][5];if(g>0)if(g==16){for(w=b;w<E;w++)t[w]=1;b=-1}else b=-1;y=i[m][6];if(y)b==-1&&(b=E);else if(b>-1){for(w=b;w<E;w++)t[w]=v;b=-1}r[E]==S&&(t[E]=0),o|=v}if(l)for(w=0;w<n;w++)if(r[w]==x){t[w]=s;for(var C=w-1;C>=0;C--){if(r[C]!=N)break;t[C]=s}}}function I(e,t,n){if(o<e)return;if(e==1&&s==m&&!f){n.reverse();return}var r=n.length,i=0,u,a,l,c;while(i<r){if(t[i]>=e){u=i+1;while(u<r&&t[u]>=e)u++;for(a=i,l=u-1;a<l;a++,l--)c=n[a],n[a]=n[l],n[l]=c;i=u}i++}}function q(e,t,n,r){var i=t[r],o,c,h,p;switch(i){case g:case y:u=!1;case E:case w:return i;case b:return u?w:b;case T:return u=!0,a=!0,y;case N:return E;case C:if(r<1||r+1>=t.length||(o=n[r-1])!=b&&o!=w||(c=t[r+1])!=b&&c!=w)return E;return u&&(c=w),c==o?c:E;case k:o=r>0?n[r-1]:S;if(o==b&&r+1<t.length&&t[r+1]==b)return b;return E;case L:if(r>0&&n[r-1]==b)return b;if(u)return E;p=r+1,h=t.length;while(p<h&&t[p]==L)p++;if(p<h&&t[p]==b)return b;return E;case A:h=t.length,p=r+1;while(p<h&&t[p]==A)p++;if(p<h){var d=e[r],v=d>=1425&&d<=2303||d==64286;o=t[p];if(v&&(o==y||o==T))return y}if(r<1||(o=t[r-1])==S)return E;return n[r-1];case S:return u=!1,f=!0,s;case x:return l=!0,E;case O:case M:case D:case P:case _:u=!1;case H:return E}}function R(e){var t=e.charCodeAt(0),n=t>>8;return n==0?t>191?g:B[t]:n==5?/[\u0591-\u05f4]/.test(e)?y:g:n==6?/[\u0610-\u061a\u064b-\u065f\u06d6-\u06e4\u06e7-\u06ed]/.test(e)?A:/[\u0660-\u0669\u066b-\u066c]/.test(e)?w:t==1642?L:/[\u06f0-\u06f9]/.test(e)?b:T:n==32&&t<=8287?j[t&255]:n==254?t>=65136?T:E:E}function U(e){return e>="\u064b"&&e<="\u0655"}var r=["\u0621","\u0641"],i=["\u063a","\u064a"],s=0,o=0,u=!1,a=!1,f=!1,l=!1,c=!1,h=!1,p=[[0,3,0,1,0,0,0],[0,3,0,1,2,2,0],[0,3,0,17,2,0,1],[0,3,5,5,4,1,0],[0,3,21,21,4,0,1],[0,3,5,5,4,2,0]],d=[[2,0,1,1,0,1,0],[2,0,1,1,0,2,0],[2,0,2,1,3,2,0],[2,0,2,33,3,1,1]],v=0,m=1,g=0,y=1,b=2,w=3,E=4,S=5,x=6,T=7,N=8,C=9,k=10,L=11,A=12,O=13,M=14,_=15,D=16,P=17,H=18,B=[H,H,H,H,H,H,H,H,H,x,S,x,N,S,H,H,H,H,H,H,H,H,H,H,H,H,H,H,S,S,S,x,N,E,E,L,L,L,E,E,E,E,E,k,C,k,C,C,b,b,b,b,b,b,b,b,b,b,C,E,E,E,E,E,E,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,E,E,E,E,E,E,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,g,E,E,E,E,H,H,H,H,H,H,S,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,C,E,L,L,L,L,E,E,E,E,g,E,E,H,E,E,L,L,b,b,E,g,E,E,E,b,g,E,E,E,E,E],j=[N,N,N,N,N,N,N,N,N,N,N,H,H,H,g,y,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,N,S,O,M,_,D,P,C,L,L,L,L,L,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,C,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,E,N];t.L=g,t.R=y,t.EN=b,t.ON_R=3,t.AN=4,t.R_H=5,t.B=6,t.RLE=7,t.DOT="\u00b7",t.doBidiReorder=function(e,n,r){if(e.length<2)return{};var i=e.split(""),o=new Array(i.length),u=new Array(i.length),a=[];s=r?m:v,F(i,a,i.length,n);for(var f=0;f<o.length;o[f]=f,f++);I(2,a,o),I(1,a,o);for(var f=0;f<o.length-1;f++)n[f]===w?a[f]=t.AN:a[f]===y&&(n[f]>T&&n[f]<O||n[f]===E||n[f]===H)?a[f]=t.ON_R:f>0&&i[f-1]==="\u0644"&&/\u0622|\u0623|\u0625|\u0627/.test(i[f])&&(a[f-1]=a[f]=t.R_H,f++);i[i.length-1]===t.DOT&&(a[i.length-1]=t.B),i[0]==="\u202b"&&(a[0]=t.RLE);for(var f=0;f<o.length;f++)u[f]=a[o[f]];return{logicalFromVisual:o,bidiLevels:u}},t.hasBidiCharacters=function(e,t){var n=!1;for(var r=0;r<e.length;r++)t[r]=R(e.charAt(r)),!n&&(t[r]==y||t[r]==T||t[r]==w)&&(n=!0);return n},t.getVisualFromLogicalIdx=function(e,t){for(var n=0;n<t.logicalFromVisual.length;n++)if(t.logicalFromVisual[n]==e)return n;return 0}}),ace.define("ace/bidihandler",["require","exports","module","ace/lib/bidiutil","ace/lib/lang"],function(e,t,n){"use strict";var r=e("./lib/bidiutil"),i=e("./lib/lang"),s=/[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac\u202B]/,o=function(e){this.session=e,this.bidiMap={},this.currentRow=null,this.bidiUtil=r,this.charWidths=[],this.EOL="\u00ac",this.showInvisibles=!0,this.isRtlDir=!1,this.$isRtl=!1,this.line="",this.wrapIndent=0,this.EOF="\u00b6",this.RLE="\u202b",this.contentWidth=0,this.fontMetrics=null,this.rtlLineOffset=0,this.wrapOffset=0,this.isMoveLeftOperation=!1,this.seenBidi=s.test(e.getValue())};(function(){this.isBidiRow=function(e,t,n){return this.seenBidi?(e!==this.currentRow&&(this.currentRow=e,this.updateRowLine(t,n),this.updateBidiMap()),this.bidiMap.bidiLevels):!1},this.onChange=function(e){this.seenBidi?this.currentRow=null:e.action=="insert"&&s.test(e.lines.join("\n"))&&(this.seenBidi=!0,this.currentRow=null)},this.getDocumentRow=function(){var e=0,t=this.session.$screenRowCache;if(t.length){var n=this.session.$getRowCacheIndex(t,this.currentRow);n>=0&&(e=this.session.$docRowCache[n])}return e},this.getSplitIndex=function(){var e=0,t=this.session.$screenRowCache;if(t.length){var n,r=this.session.$getRowCacheIndex(t,this.currentRow);while(this.currentRow-e>0){n=this.session.$getRowCacheIndex(t,this.currentRow-e-1);if(n!==r)break;r=n,e++}}else e=this.currentRow;return e},this.updateRowLine=function(e,t){e===undefined&&(e=this.getDocumentRow());var n=e===this.session.getLength()-1,s=n?this.EOF:this.EOL;this.wrapIndent=0,this.line=this.session.getLine(e),this.isRtlDir=this.$isRtl||this.line.charAt(0)===this.RLE;if(this.session.$useWrapMode){var o=this.session.$wrapData[e];o&&(t===undefined&&(t=this.getSplitIndex()),t>0&&o.length?(this.wrapIndent=o.indent,this.wrapOffset=this.wrapIndent*this.charWidths[r.L],this.line=t<o.length?this.line.substring(o[t-1],o[t]):this.line.substring(o[o.length-1])):this.line=this.line.substring(0,o[t])),t==o.length&&(this.line+=this.showInvisibles?s:r.DOT)}else this.line+=this.showInvisibles?s:r.DOT;var u=this.session,a=0,f;this.line=this.line.replace(/\t|[\u1100-\u2029, \u202F-\uFFE6]/g,function(e,t){return e==="	"||u.isFullWidth(e.charCodeAt(0))?(f=e==="	"?u.getScreenTabSize(t+a):2,a+=f-1,i.stringRepeat(r.DOT,f)):e}),this.isRtlDir&&(this.fontMetrics.$main.textContent=this.line.charAt(this.line.length-1)==r.DOT?this.line.substr(0,this.line.length-1):this.line,this.rtlLineOffset=this.contentWidth-this.fontMetrics.$main.getBoundingClientRect().width)},this.updateBidiMap=function(){var e=[];r.hasBidiCharacters(this.line,e)||this.isRtlDir?this.bidiMap=r.doBidiReorder(this.line,e,this.isRtlDir):this.bidiMap={}},this.markAsDirty=function(){this.currentRow=null},this.updateCharacterWidths=function(e){if(this.characterWidth===e.$characterSize.width)return;this.fontMetrics=e;var t=this.characterWidth=e.$characterSize.width,n=e.$measureCharWidth("\u05d4");this.charWidths[r.L]=this.charWidths[r.EN]=this.charWidths[r.ON_R]=t,this.charWidths[r.R]=this.charWidths[r.AN]=n,this.charWidths[r.R_H]=n*.45,this.charWidths[r.B]=this.charWidths[r.RLE]=0,this.currentRow=null},this.setShowInvisibles=function(e){this.showInvisibles=e,this.currentRow=null},this.setEolChar=function(e){this.EOL=e},this.setContentWidth=function(e){this.contentWidth=e},this.isRtlLine=function(e){return this.$isRtl?!0:e!=undefined?this.session.getLine(e).charAt(0)==this.RLE:this.isRtlDir},this.setRtlDirection=function(e,t){var n=e.getCursorPosition();for(var r=e.selection.getSelectionAnchor().row;r<=n.row;r++)!t&&e.session.getLine(r).charAt(0)===e.session.$bidiHandler.RLE?e.session.doc.removeInLine(r,0,1):t&&e.session.getLine(r).charAt(0)!==e.session.$bidiHandler.RLE&&e.session.doc.insert({column:0,row:r},e.session.$bidiHandler.RLE)},this.getPosLeft=function(e){e-=this.wrapIndent;var t=this.line.charAt(0)===this.RLE?1:0,n=e>t?this.session.getOverwrite()?e:e-1:t,i=r.getVisualFromLogicalIdx(n,this.bidiMap),s=this.bidiMap.bidiLevels,o=0;!this.session.getOverwrite()&&e<=t&&s[i]%2!==0&&i++;for(var u=0;u<i;u++)o+=this.charWidths[s[u]];return!this.session.getOverwrite()&&e>t&&s[i]%2===0&&(o+=this.charWidths[s[i]]),this.wrapIndent&&(o+=this.isRtlDir?-1*this.wrapOffset:this.wrapOffset),this.isRtlDir&&(o+=this.rtlLineOffset),o},this.getSelections=function(e,t){var n=this.bidiMap,r=n.bidiLevels,i,s=[],o=0,u=Math.min(e,t)-this.wrapIndent,a=Math.max(e,t)-this.wrapIndent,f=!1,l=!1,c=0;this.wrapIndent&&(o+=this.isRtlDir?-1*this.wrapOffset:this.wrapOffset);for(var h,p=0;p<r.length;p++)h=n.logicalFromVisual[p],i=r[p],f=h>=u&&h<a,f&&!l?c=o:!f&&l&&s.push({left:c,width:o-c}),o+=this.charWidths[i],l=f;f&&p===r.length&&s.push({left:c,width:o-c});if(this.isRtlDir)for(var d=0;d<s.length;d++)s[d].left+=this.rtlLineOffset;return s},this.offsetToCol=function(e){this.isRtlDir&&(e-=this.rtlLineOffset);var t=0,e=Math.max(e,0),n=0,r=0,i=this.bidiMap.bidiLevels,s=this.charWidths[i[r]];this.wrapIndent&&(e-=this.isRtlDir?-1*this.wrapOffset:this.wrapOffset);while(e>n+s/2){n+=s;if(r===i.length-1){s=0;break}s=this.charWidths[i[++r]]}return r>0&&i[r-1]%2!==0&&i[r]%2===0?(e<n&&r--,t=this.bidiMap.logicalFromVisual[r]):r>0&&i[r-1]%2===0&&i[r]%2!==0?t=1+(e>n?this.bidiMap.logicalFromVisual[r]:this.bidiMap.logicalFromVisual[r-1]):this.isRtlDir&&r===i.length-1&&s===0&&i[r-1]%2===0||!this.isRtlDir&&r===0&&i[r]%2!==0?t=1+this.bidiMap.logicalFromVisual[r]:(r>0&&i[r-1]%2!==0&&s!==0&&r--,t=this.bidiMap.logicalFromVisual[r]),t===0&&this.isRtlDir&&t++,t+this.wrapIndent}}).call(o.prototype),t.BidiHandler=o}),ace.define("ace/selection",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/range"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./lib/lang"),s=e("./lib/event_emitter").EventEmitter,o=e("./range").Range,u=function(e){this.session=e,this.doc=e.getDocument(),this.clearSelection(),this.cursor=this.lead=this.doc.createAnchor(0,0),this.anchor=this.doc.createAnchor(0,0),this.$silent=!1;var t=this;this.cursor.on("change",function(e){t.$cursorChanged=!0,t.$silent||t._emit("changeCursor"),!t.$isEmpty&&!t.$silent&&t._emit("changeSelection"),!t.$keepDesiredColumnOnChange&&e.old.column!=e.value.column&&(t.$desiredColumn=null)}),this.anchor.on("change",function(){t.$anchorChanged=!0,!t.$isEmpty&&!t.$silent&&t._emit("changeSelection")})};(function(){r.implement(this,s),this.isEmpty=function(){return this.$isEmpty||this.anchor.row==this.lead.row&&this.anchor.column==this.lead.column},this.isMultiLine=function(){return!this.$isEmpty&&this.anchor.row!=this.cursor.row},this.getCursor=function(){return this.lead.getPosition()},this.setSelectionAnchor=function(e,t){this.$isEmpty=!1,this.anchor.setPosition(e,t)},this.getAnchor=this.getSelectionAnchor=function(){return this.$isEmpty?this.getSelectionLead():this.anchor.getPosition()},this.getSelectionLead=function(){return this.lead.getPosition()},this.isBackwards=function(){var e=this.anchor,t=this.lead;return e.row>t.row||e.row==t.row&&e.column>t.column},this.getRange=function(){var e=this.anchor,t=this.lead;return this.$isEmpty?o.fromPoints(t,t):this.isBackwards()?o.fromPoints(t,e):o.fromPoints(e,t)},this.clearSelection=function(){this.$isEmpty||(this.$isEmpty=!0,this._emit("changeSelection"))},this.selectAll=function(){this.$setSelection(0,0,Number.MAX_VALUE,Number.MAX_VALUE)},this.setRange=this.setSelectionRange=function(e,t){var n=t?e.end:e.start,r=t?e.start:e.end;this.$setSelection(n.row,n.column,r.row,r.column)},this.$setSelection=function(e,t,n,r){var i=this.$isEmpty,s=this.inMultiSelectMode;this.$silent=!0,this.$cursorChanged=this.$anchorChanged=!1,this.anchor.setPosition(e,t),this.cursor.setPosition(n,r),this.$isEmpty=!o.comparePoints(this.anchor,this.cursor),this.$silent=!1,this.$cursorChanged&&this._emit("changeCursor"),(this.$cursorChanged||this.$anchorChanged||i!=this.$isEmpty||s)&&this._emit("changeSelection")},this.$moveSelection=function(e){var t=this.lead;this.$isEmpty&&this.setSelectionAnchor(t.row,t.column),e.call(this)},this.selectTo=function(e,t){this.$moveSelection(function(){this.moveCursorTo(e,t)})},this.selectToPosition=function(e){this.$moveSelection(function(){this.moveCursorToPosition(e)})},this.moveTo=function(e,t){this.clearSelection(),this.moveCursorTo(e,t)},this.moveToPosition=function(e){this.clearSelection(),this.moveCursorToPosition(e)},this.selectUp=function(){this.$moveSelection(this.moveCursorUp)},this.selectDown=function(){this.$moveSelection(this.moveCursorDown)},this.selectRight=function(){this.$moveSelection(this.moveCursorRight)},this.selectLeft=function(){this.$moveSelection(this.moveCursorLeft)},this.selectLineStart=function(){this.$moveSelection(this.moveCursorLineStart)},this.selectLineEnd=function(){this.$moveSelection(this.moveCursorLineEnd)},this.selectFileEnd=function(){this.$moveSelection(this.moveCursorFileEnd)},this.selectFileStart=function(){this.$moveSelection(this.moveCursorFileStart)},this.selectWordRight=function(){this.$moveSelection(this.moveCursorWordRight)},this.selectWordLeft=function(){this.$moveSelection(this.moveCursorWordLeft)},this.getWordRange=function(e,t){if(typeof t=="undefined"){var n=e||this.lead;e=n.row,t=n.column}return this.session.getWordRange(e,t)},this.selectWord=function(){this.setSelectionRange(this.getWordRange())},this.selectAWord=function(){var e=this.getCursor(),t=this.session.getAWordRange(e.row,e.column);this.setSelectionRange(t)},this.getLineRange=function(e,t){var n=typeof e=="number"?e:this.lead.row,r,i=this.session.getFoldLine(n);return i?(n=i.start.row,r=i.end.row):r=n,t===!0?new o(n,0,r,this.session.getLine(r).length):new o(n,0,r+1,0)},this.selectLine=function(){this.setSelectionRange(this.getLineRange())},this.moveCursorUp=function(){this.moveCursorBy(-1,0)},this.moveCursorDown=function(){this.moveCursorBy(1,0)},this.wouldMoveIntoSoftTab=function(e,t,n){var r=e.column,i=e.column+t;return n<0&&(r=e.column-t,i=e.column),this.session.isTabStop(e)&&this.doc.getLine(e.row).slice(r,i).split(" ").length-1==t},this.moveCursorLeft=function(){var e=this.lead.getPosition(),t;if(t=this.session.getFoldAt(e.row,e.column,-1))this.moveCursorTo(t.start.row,t.start.column);else if(e.column===0)e.row>0&&this.moveCursorTo(e.row-1,this.doc.getLine(e.row-1).length);else{var n=this.session.getTabSize();this.wouldMoveIntoSoftTab(e,n,-1)&&!this.session.getNavigateWithinSoftTabs()?this.moveCursorBy(0,-n):this.moveCursorBy(0,-1)}},this.moveCursorRight=function(){var e=this.lead.getPosition(),t;if(t=this.session.getFoldAt(e.row,e.column,1))this.moveCursorTo(t.end.row,t.end.column);else if(this.lead.column==this.doc.getLine(this.lead.row).length)this.lead.row<this.doc.getLength()-1&&this.moveCursorTo(this.lead.row+1,0);else{var n=this.session.getTabSize(),e=this.lead;this.wouldMoveIntoSoftTab(e,n,1)&&!this.session.getNavigateWithinSoftTabs()?this.moveCursorBy(0,n):this.moveCursorBy(0,1)}},this.moveCursorLineStart=function(){var e=this.lead.row,t=this.lead.column,n=this.session.documentToScreenRow(e,t),r=this.session.screenToDocumentPosition(n,0),i=this.session.getDisplayLine(e,null,r.row,r.column),s=i.match(/^\s*/);s[0].length!=t&&!this.session.$useEmacsStyleLineStart&&(r.column+=s[0].length),this.moveCursorToPosition(r)},this.moveCursorLineEnd=function(){var e=this.lead,t=this.session.getDocumentLastRowColumnPosition(e.row,e.column);if(this.lead.column==t.column){var n=this.session.getLine(t.row);if(t.column==n.length){var r=n.search(/\s+$/);r>0&&(t.column=r)}}this.moveCursorTo(t.row,t.column)},this.moveCursorFileEnd=function(){var e=this.doc.getLength()-1,t=this.doc.getLine(e).length;this.moveCursorTo(e,t)},this.moveCursorFileStart=function(){this.moveCursorTo(0,0)},this.moveCursorLongWordRight=function(){var e=this.lead.row,t=this.lead.column,n=this.doc.getLine(e),r=n.substring(t);this.session.nonTokenRe.lastIndex=0,this.session.tokenRe.lastIndex=0;var i=this.session.getFoldAt(e,t,1);if(i){this.moveCursorTo(i.end.row,i.end.column);return}this.session.nonTokenRe.exec(r)&&(t+=this.session.nonTokenRe.lastIndex,this.session.nonTokenRe.lastIndex=0,r=n.substring(t));if(t>=n.length){this.moveCursorTo(e,n.length),this.moveCursorRight(),e<this.doc.getLength()-1&&this.moveCursorWordRight();return}this.session.tokenRe.exec(r)&&(t+=this.session.tokenRe.lastIndex,this.session.tokenRe.lastIndex=0),this.moveCursorTo(e,t)},this.moveCursorLongWordLeft=function(){var e=this.lead.row,t=this.lead.column,n;if(n=this.session.getFoldAt(e,t,-1)){this.moveCursorTo(n.start.row,n.start.column);return}var r=this.session.getFoldStringAt(e,t,-1);r==null&&(r=this.doc.getLine(e).substring(0,t));var s=i.stringReverse(r);this.session.nonTokenRe.lastIndex=0,this.session.tokenRe.lastIndex=0,this.session.nonTokenRe.exec(s)&&(t-=this.session.nonTokenRe.lastIndex,s=s.slice(this.session.nonTokenRe.lastIndex),this.session.nonTokenRe.lastIndex=0);if(t<=0){this.moveCursorTo(e,0),this.moveCursorLeft(),e>0&&this.moveCursorWordLeft();return}this.session.tokenRe.exec(s)&&(t-=this.session.tokenRe.lastIndex,this.session.tokenRe.lastIndex=0),this.moveCursorTo(e,t)},this.$shortWordEndIndex=function(e){var t=0,n,r=/\s/,i=this.session.tokenRe;i.lastIndex=0;if(this.session.tokenRe.exec(e))t=this.session.tokenRe.lastIndex;else{while((n=e[t])&&r.test(n))t++;if(t<1){i.lastIndex=0;while((n=e[t])&&!i.test(n)){i.lastIndex=0,t++;if(r.test(n)){if(t>2){t--;break}while((n=e[t])&&r.test(n))t++;if(t>2)break}}}}return i.lastIndex=0,t},this.moveCursorShortWordRight=function(){var e=this.lead.row,t=this.lead.column,n=this.doc.getLine(e),r=n.substring(t),i=this.session.getFoldAt(e,t,1);if(i)return this.moveCursorTo(i.end.row,i.end.column);if(t==n.length){var s=this.doc.getLength();do e++,r=this.doc.getLine(e);while(e<s&&/^\s*$/.test(r));/^\s+/.test(r)||(r=""),t=0}var o=this.$shortWordEndIndex(r);this.moveCursorTo(e,t+o)},this.moveCursorShortWordLeft=function(){var e=this.lead.row,t=this.lead.column,n;if(n=this.session.getFoldAt(e,t,-1))return this.moveCursorTo(n.start.row,n.start.column);var r=this.session.getLine(e).substring(0,t);if(t===0){do e--,r=this.doc.getLine(e);while(e>0&&/^\s*$/.test(r));t=r.length,/\s+$/.test(r)||(r="")}var s=i.stringReverse(r),o=this.$shortWordEndIndex(s);return this.moveCursorTo(e,t-o)},this.moveCursorWordRight=function(){this.session.$selectLongWords?this.moveCursorLongWordRight():this.moveCursorShortWordRight()},this.moveCursorWordLeft=function(){this.session.$selectLongWords?this.moveCursorLongWordLeft():this.moveCursorShortWordLeft()},this.moveCursorBy=function(e,t){var n=this.session.documentToScreenPosition(this.lead.row,this.lead.column),r;t===0&&(e!==0&&(this.session.$bidiHandler.isBidiRow(n.row,this.lead.row)?(r=this.session.$bidiHandler.getPosLeft(n.column),n.column=Math.round(r/this.session.$bidiHandler.charWidths[0])):r=n.column*this.session.$bidiHandler.charWidths[0]),this.$desiredColumn?n.column=this.$desiredColumn:this.$desiredColumn=n.column);var i=this.session.screenToDocumentPosition(n.row+e,n.column,r);e!==0&&t===0&&i.row===this.lead.row&&i.column===this.lead.column&&this.session.lineWidgets&&this.session.lineWidgets[i.row]&&(i.row>0||e>0)&&i.row++,this.moveCursorTo(i.row,i.column+t,t===0)},this.moveCursorToPosition=function(e){this.moveCursorTo(e.row,e.column)},this.moveCursorTo=function(e,t,n){var r=this.session.getFoldAt(e,t,1);r&&(e=r.start.row,t=r.start.column),this.$keepDesiredColumnOnChange=!0;var i=this.session.getLine(e);/[\uDC00-\uDFFF]/.test(i.charAt(t))&&i.charAt(t-1)&&(this.lead.row==e&&this.lead.column==t+1?t-=1:t+=1),this.lead.setPosition(e,t),this.$keepDesiredColumnOnChange=!1,n||(this.$desiredColumn=null)},this.moveCursorToScreen=function(e,t,n){var r=this.session.screenToDocumentPosition(e,t);this.moveCursorTo(r.row,r.column,n)},this.detach=function(){this.lead.detach(),this.anchor.detach(),this.session=this.doc=null},this.fromOrientedRange=function(e){this.setSelectionRange(e,e.cursor==e.start),this.$desiredColumn=e.desiredColumn||this.$desiredColumn},this.toOrientedRange=function(e){var t=this.getRange();return e?(e.start.column=t.start.column,e.start.row=t.start.row,e.end.column=t.end.column,e.end.row=t.end.row):e=t,e.cursor=this.isBackwards()?e.start:e.end,e.desiredColumn=this.$desiredColumn,e},this.getRangeOfMovements=function(e){var t=this.getCursor();try{e(this);var n=this.getCursor();return o.fromPoints(t,n)}catch(r){return o.fromPoints(t,t)}finally{this.moveCursorToPosition(t)}},this.toJSON=function(){if(this.rangeCount)var e=this.ranges.map(function(e){var t=e.clone();return t.isBackwards=e.cursor==e.start,t});else{var e=this.getRange();e.isBackwards=this.isBackwards()}return e},this.fromJSON=function(e){if(e.start==undefined){if(this.rangeList&&e.length>1){this.toSingleRange(e[0]);for(var t=e.length;t--;){var n=o.fromPoints(e[t].start,e[t].end);e[t].isBackwards&&(n.cursor=n.start),this.addRange(n,!0)}return}e=e[0]}this.rangeList&&this.toSingleRange(e),this.setSelectionRange(e,e.isBackwards)},this.isEqual=function(e){if((e.length||this.rangeCount)&&e.length!=this.rangeCount)return!1;if(!e.length||!this.ranges)return this.getRange().isEqual(e);for(var t=this.ranges.length;t--;)if(!this.ranges[t].isEqual(e[t]))return!1;return!0}}).call(u.prototype),t.Selection=u}),ace.define("ace/tokenizer",["require","exports","module","ace/config"],function(e,t,n){"use strict";var r=e("./config"),i=2e3,s=function(e){this.states=e,this.regExps={},this.matchMappings={};for(var t in this.states){var n=this.states[t],r=[],i=0,s=this.matchMappings[t]={defaultToken:"text"},o="g",u=[];for(var a=0;a<n.length;a++){var f=n[a];f.defaultToken&&(s.defaultToken=f.defaultToken),f.caseInsensitive&&(o="gi");if(f.regex==null)continue;f.regex instanceof RegExp&&(f.regex=f.regex.toString().slice(1,-1));var l=f.regex,c=(new RegExp("(?:("+l+")|(.))")).exec("a").length-2;Array.isArray(f.token)?f.token.length==1||c==1?f.token=f.token[0]:c-1!=f.token.length?(this.reportError("number of classes and regexp groups doesn't match",{rule:f,groupCount:c-1}),f.token=f.token[0]):(f.tokenArray=f.token,f.token=null,f.onMatch=this.$arrayTokens):typeof f.token=="function"&&!f.onMatch&&(c>1?f.onMatch=this.$applyToken:f.onMatch=f.token),c>1&&(/\\\d/.test(f.regex)?l=f.regex.replace(/\\([0-9]+)/g,function(e,t){return"\\"+(parseInt(t,10)+i+1)}):(c=1,l=this.removeCapturingGroups(f.regex)),!f.splitRegex&&typeof f.token!="string"&&u.push(f)),s[i]=a,i+=c,r.push(l),f.onMatch||(f.onMatch=null)}r.length||(s[0]=0,r.push("$")),u.forEach(function(e){e.splitRegex=this.createSplitterRegexp(e.regex,o)},this),this.regExps[t]=new RegExp("("+r.join(")|(")+")|($)",o)}};(function(){this.$setMaxTokenCount=function(e){i=e|0},this.$applyToken=function(e){var t=this.splitRegex.exec(e).slice(1),n=this.token.apply(this,t);if(typeof n=="string")return[{type:n,value:e}];var r=[];for(var i=0,s=n.length;i<s;i++)t[i]&&(r[r.length]={type:n[i],value:t[i]});return r},this.$arrayTokens=function(e){if(!e)return[];var t=this.splitRegex.exec(e);if(!t)return"text";var n=[],r=this.tokenArray;for(var i=0,s=r.length;i<s;i++)t[i+1]&&(n[n.length]={type:r[i],value:t[i+1]});return n},this.removeCapturingGroups=function(e){var t=e.replace(/\\.|\[(?:\\.|[^\\\]])*|\(\?[:=!]|(\()/g,function(e,t){return t?"(?:":e});return t},this.createSplitterRegexp=function(e,t){if(e.indexOf("(?=")!=-1){var n=0,r=!1,i={};e.replace(/(\\.)|(\((?:\?[=!])?)|(\))|([\[\]])/g,function(e,t,s,o,u,a){return r?r=u!="]":u?r=!0:o?(n==i.stack&&(i.end=a+1,i.stack=-1),n--):s&&(n++,s.length!=1&&(i.stack=n,i.start=a)),e}),i.end!=null&&/^\)*$/.test(e.substr(i.end))&&(e=e.substring(0,i.start)+e.substr(i.end))}return e.charAt(0)!="^"&&(e="^"+e),e.charAt(e.length-1)!="$"&&(e+="$"),new RegExp(e,(t||"").replace("g",""))},this.getLineTokens=function(e,t){if(t&&typeof t!="string"){var n=t.slice(0);t=n[0],t==="#tmp"&&(n.shift(),t=n.shift())}else var n=[];var r=t||"start",s=this.states[r];s||(r="start",s=this.states[r]);var o=this.matchMappings[r],u=this.regExps[r];u.lastIndex=0;var a,f=[],l=0,c=0,h={type:null,value:""};while(a=u.exec(e)){var p=o.defaultToken,d=null,v=a[0],m=u.lastIndex;if(m-v.length>l){var g=e.substring(l,m-v.length);h.type==p?h.value+=g:(h.type&&f.push(h),h={type:p,value:g})}for(var y=0;y<a.length-2;y++){if(a[y+1]===undefined)continue;d=s[o[y]],d.onMatch?p=d.onMatch(v,r,n,e):p=d.token,d.next&&(typeof d.next=="string"?r=d.next:r=d.next(r,n),s=this.states[r],s||(this.reportError("state doesn't exist",r),r="start",s=this.states[r]),o=this.matchMappings[r],l=m,u=this.regExps[r],u.lastIndex=m),d.consumeLineEnd&&(l=m);break}if(v)if(typeof p=="string")!!d&&d.merge===!1||h.type!==p?(h.type&&f.push(h),h={type:p,value:v}):h.value+=v;else if(p){h.type&&f.push(h),h={type:null,value:""};for(var y=0;y<p.length;y++)f.push(p[y])}if(l==e.length)break;l=m;if(c++>i){c>2*e.length&&this.reportError("infinite loop with in ace tokenizer",{startState:t,line:e});while(l<e.length)h.type&&f.push(h),h={value:e.substring(l,l+=500),type:"overflow"};r="start",n=[];break}}return h.type&&f.push(h),n.length>1&&n[0]!==r&&n.unshift("#tmp",r),{tokens:f,state:n.length?n:r}},this.reportError=r.reportError}).call(s.prototype),t.Tokenizer=s}),ace.define("ace/mode/text_highlight_rules",["require","exports","module","ace/lib/lang"],function(e,t,n){"use strict";var r=e("../lib/lang"),i=function(){this.$rules={start:[{token:"empty_line",regex:"^$"},{defaultToken:"text"}]}};(function(){this.addRules=function(e,t){if(!t){for(var n in e)this.$rules[n]=e[n];return}for(var n in e){var r=e[n];for(var i=0;i<r.length;i++){var s=r[i];if(s.next||s.onMatch)typeof s.next=="string"&&s.next.indexOf(t)!==0&&(s.next=t+s.next),s.nextState&&s.nextState.indexOf(t)!==0&&(s.nextState=t+s.nextState)}this.$rules[t+n]=r}},this.getRules=function(){return this.$rules},this.embedRules=function(e,t,n,i,s){var o=typeof e=="function"?(new e).getRules():e;if(i)for(var u=0;u<i.length;u++)i[u]=t+i[u];else{i=[];for(var a in o)i.push(t+a)}this.addRules(o,t);if(n){var f=Array.prototype[s?"push":"unshift"];for(var u=0;u<i.length;u++)f.apply(this.$rules[i[u]],r.deepCopy(n))}this.$embeds||(this.$embeds=[]),this.$embeds.push(t)},this.getEmbeds=function(){return this.$embeds};var e=function(e,t){return(e!="start"||t.length)&&t.unshift(this.nextState,e),this.nextState},t=function(e,t){return t.shift(),t.shift()||"start"};this.normalizeRules=function(){function i(s){var o=r[s];o.processed=!0;for(var u=0;u<o.length;u++){var a=o[u],f=null;Array.isArray(a)&&(f=a,a={}),!a.regex&&a.start&&(a.regex=a.start,a.next||(a.next=[]),a.next.push({defaultToken:a.token},{token:a.token+".end",regex:a.end||a.start,next:"pop"}),a.token=a.token+".start",a.push=!0);var l=a.next||a.push;if(l&&Array.isArray(l)){var c=a.stateName;c||(c=a.token,typeof c!="string"&&(c=c[0]||""),r[c]&&(c+=n++)),r[c]=l,a.next=c,i(c)}else l=="pop"&&(a.next=t);a.push&&(a.nextState=a.next||a.push,a.next=e,delete a.push);if(a.rules)for(var h in a.rules)r[h]?r[h].push&&r[h].push.apply(r[h],a.rules[h]):r[h]=a.rules[h];var p=typeof a=="string"?a:a.include;p&&(Array.isArray(p)?f=p.map(function(e){return r[e]}):f=r[p]);if(f){var d=[u,1].concat(f);a.noEscape&&(d=d.filter(function(e){return!e.next})),o.splice.apply(o,d),u--}a.keywordMap&&(a.token=this.createKeywordMapper(a.keywordMap,a.defaultToken||"text",a.caseInsensitive),delete a.defaultToken)}}var n=0,r=this.$rules;Object.keys(r).forEach(i,this)},this.createKeywordMapper=function(e,t,n,r){var i=Object.create(null);return Object.keys(e).forEach(function(t){var s=e[t];n&&(s=s.toLowerCase());var o=s.split(r||"|");for(var u=o.length;u--;)i[o[u]]=t}),Object.getPrototypeOf(i)&&(i.__proto__=null),this.$keywordList=Object.keys(i),e=null,n?function(e){return i[e.toLowerCase()]||t}:function(e){return i[e]||t}},this.getKeywords=function(){return this.$keywords}}).call(i.prototype),t.TextHighlightRules=i}),ace.define("ace/mode/behaviour",["require","exports","module"],function(e,t,n){"use strict";var r=function(){this.$behaviours={}};(function(){this.add=function(e,t,n){switch(undefined){case this.$behaviours:this.$behaviours={};case this.$behaviours[e]:this.$behaviours[e]={}}this.$behaviours[e][t]=n},this.addBehaviours=function(e){for(var t in e)for(var n in e[t])this.add(t,n,e[t][n])},this.remove=function(e){this.$behaviours&&this.$behaviours[e]&&delete this.$behaviours[e]},this.inherit=function(e,t){if(typeof e=="function")var n=(new e).getBehaviours(t);else var n=e.getBehaviours(t);this.addBehaviours(n)},this.getBehaviours=function(e){if(!e)return this.$behaviours;var t={};for(var n=0;n<e.length;n++)this.$behaviours[e[n]]&&(t[e[n]]=this.$behaviours[e[n]]);return t}}).call(r.prototype),t.Behaviour=r}),ace.define("ace/token_iterator",["require","exports","module","ace/range"],function(e,t,n){"use strict";var r=e("./range").Range,i=function(e,t,n){this.$session=e,this.$row=t,this.$rowTokens=e.getTokens(t);var r=e.getTokenAt(t,n);this.$tokenIndex=r?r.index:-1};(function(){this.stepBackward=function(){this.$tokenIndex-=1;while(this.$tokenIndex<0){this.$row-=1;if(this.$row<0)return this.$row=0,null;this.$rowTokens=this.$session.getTokens(this.$row),this.$tokenIndex=this.$rowTokens.length-1}return this.$rowTokens[this.$tokenIndex]},this.stepForward=function(){this.$tokenIndex+=1;var e;while(this.$tokenIndex>=this.$rowTokens.length){this.$row+=1,e||(e=this.$session.getLength());if(this.$row>=e)return this.$row=e-1,null;this.$rowTokens=this.$session.getTokens(this.$row),this.$tokenIndex=0}return this.$rowTokens[this.$tokenIndex]},this.getCurrentToken=function(){return this.$rowTokens[this.$tokenIndex]},this.getCurrentTokenRow=function(){return this.$row},this.getCurrentTokenColumn=function(){var e=this.$rowTokens,t=this.$tokenIndex,n=e[t].start;if(n!==undefined)return n;n=0;while(t>0)t-=1,n+=e[t].value.length;return n},this.getCurrentTokenPosition=function(){return{row:this.$row,column:this.getCurrentTokenColumn()}},this.getCurrentTokenRange=function(){var e=this.$rowTokens[this.$tokenIndex],t=this.getCurrentTokenColumn();return new r(this.$row,t,this.$row,t+e.value.length)}}).call(i.prototype),t.TokenIterator=i}),ace.define("ace/mode/behaviour/cstyle",["require","exports","module","ace/lib/oop","ace/mode/behaviour","ace/token_iterator","ace/lib/lang"],function(e,t,n){"use strict";var r=e("../../lib/oop"),i=e("../behaviour").Behaviour,s=e("../../token_iterator").TokenIterator,o=e("../../lib/lang"),u=["text","paren.rparen","rparen","paren","punctuation.operator"],a=["text","paren.rparen","rparen","paren","punctuation.operator","comment"],f,l={},c={'"':'"',"'":"'"},h=function(e){var t=-1;e.multiSelect&&(t=e.selection.index,l.rangeCount!=e.multiSelect.rangeCount&&(l={rangeCount:e.multiSelect.rangeCount}));if(l[t])return f=l[t];f=l[t]={autoInsertedBrackets:0,autoInsertedRow:-1,autoInsertedLineEnd:"",maybeInsertedBrackets:0,maybeInsertedRow:-1,maybeInsertedLineStart:"",maybeInsertedLineEnd:""}},p=function(e,t,n,r){var i=e.end.row-e.start.row;return{text:n+t+r,selection:[0,e.start.column+1,i,e.end.column+(i?0:1)]}},d=function(e){this.add("braces","insertion",function(t,n,r,i,s){var u=r.getCursorPosition(),a=i.doc.getLine(u.row);if(s=="{"){h(r);var l=r.getSelectionRange(),c=i.doc.getTextRange(l);if(c!==""&&c!=="{"&&r.getWrapBehavioursEnabled())return p(l,c,"{","}");if(d.isSaneInsertion(r,i))return/[\]\}\)]/.test(a[u.column])||r.inMultiSelectMode||e&&e.braces?(d.recordAutoInsert(r,i,"}"),{text:"{}",selection:[1,1]}):(d.recordMaybeInsert(r,i,"{"),{text:"{",selection:[1,1]})}else if(s=="}"){h(r);var v=a.substring(u.column,u.column+1);if(v=="}"){var m=i.$findOpeningBracket("}",{column:u.column+1,row:u.row});if(m!==null&&d.isAutoInsertedClosing(u,a,s))return d.popAutoInsertedClosing(),{text:"",selection:[1,1]}}}else{if(s=="\n"||s=="\r\n"){h(r);var g="";d.isMaybeInsertedClosing(u,a)&&(g=o.stringRepeat("}",f.maybeInsertedBrackets),d.clearMaybeInsertedClosing());var v=a.substring(u.column,u.column+1);if(v==="}"){var y=i.findMatchingBracket({row:u.row,column:u.column+1},"}");if(!y)return null;var b=this.$getIndent(i.getLine(y.row))}else{if(!g){d.clearMaybeInsertedClosing();return}var b=this.$getIndent(a)}var w=b+i.getTabString();return{text:"\n"+w+"\n"+b+g,selection:[1,w.length,1,w.length]}}d.clearMaybeInsertedClosing()}}),this.add("braces","deletion",function(e,t,n,r,i){var s=r.doc.getTextRange(i);if(!i.isMultiLine()&&s=="{"){h(n);var o=r.doc.getLine(i.start.row),u=o.substring(i.end.column,i.end.column+1);if(u=="}")return i.end.column++,i;f.maybeInsertedBrackets--}}),this.add("parens","insertion",function(e,t,n,r,i){if(i=="("){h(n);var s=n.getSelectionRange(),o=r.doc.getTextRange(s);if(o!==""&&n.getWrapBehavioursEnabled())return p(s,o,"(",")");if(d.isSaneInsertion(n,r))return d.recordAutoInsert(n,r,")"),{text:"()",selection:[1,1]}}else if(i==")"){h(n);var u=n.getCursorPosition(),a=r.doc.getLine(u.row),f=a.substring(u.column,u.column+1);if(f==")"){var l=r.$findOpeningBracket(")",{column:u.column+1,row:u.row});if(l!==null&&d.isAutoInsertedClosing(u,a,i))return d.popAutoInsertedClosing(),{text:"",selection:[1,1]}}}}),this.add("parens","deletion",function(e,t,n,r,i){var s=r.doc.getTextRange(i);if(!i.isMultiLine()&&s=="("){h(n);var o=r.doc.getLine(i.start.row),u=o.substring(i.start.column+1,i.start.column+2);if(u==")")return i.end.column++,i}}),this.add("brackets","insertion",function(e,t,n,r,i){if(i=="["){h(n);var s=n.getSelectionRange(),o=r.doc.getTextRange(s);if(o!==""&&n.getWrapBehavioursEnabled())return p(s,o,"[","]");if(d.isSaneInsertion(n,r))return d.recordAutoInsert(n,r,"]"),{text:"[]",selection:[1,1]}}else if(i=="]"){h(n);var u=n.getCursorPosition(),a=r.doc.getLine(u.row),f=a.substring(u.column,u.column+1);if(f=="]"){var l=r.$findOpeningBracket("]",{column:u.column+1,row:u.row});if(l!==null&&d.isAutoInsertedClosing(u,a,i))return d.popAutoInsertedClosing(),{text:"",selection:[1,1]}}}}),this.add("brackets","deletion",function(e,t,n,r,i){var s=r.doc.getTextRange(i);if(!i.isMultiLine()&&s=="["){h(n);var o=r.doc.getLine(i.start.row),u=o.substring(i.start.column+1,i.start.column+2);if(u=="]")return i.end.column++,i}}),this.add("string_dquotes","insertion",function(e,t,n,r,i){var s=r.$mode.$quotes||c;if(i.length==1&&s[i]){if(this.lineCommentStart&&this.lineCommentStart.indexOf(i)!=-1)return;h(n);var o=i,u=n.getSelectionRange(),a=r.doc.getTextRange(u);if(a!==""&&(a.length!=1||!s[a])&&n.getWrapBehavioursEnabled())return p(u,a,o,o);if(!a){var f=n.getCursorPosition(),l=r.doc.getLine(f.row),d=l.substring(f.column-1,f.column),v=l.substring(f.column,f.column+1),m=r.getTokenAt(f.row,f.column),g=r.getTokenAt(f.row,f.column+1);if(d=="\\"&&m&&/escape/.test(m.type))return null;var y=m&&/string|escape/.test(m.type),b=!g||/string|escape/.test(g.type),w;if(v==o)w=y!==b,w&&/string\.end/.test(g.type)&&(w=!1);else{if(y&&!b)return null;if(y&&b)return null;var E=r.$mode.tokenRe;E.lastIndex=0;var S=E.test(d);E.lastIndex=0;var x=E.test(d);if(S||x)return null;if(v&&!/[\s;,.})\]\\]/.test(v))return null;var T=l[f.column-2];if(!(d!=o||T!=o&&!E.test(T)))return null;w=!0}return{text:w?o+o:"",selection:[1,1]}}}}),this.add("string_dquotes","deletion",function(e,t,n,r,i){var s=r.$mode.$quotes||c,o=r.doc.getTextRange(i);if(!i.isMultiLine()&&s.hasOwnProperty(o)){h(n);var u=r.doc.getLine(i.start.row),a=u.substring(i.start.column+1,i.start.column+2);if(a==o)return i.end.column++,i}})};d.isSaneInsertion=function(e,t){var n=e.getCursorPosition(),r=new s(t,n.row,n.column);if(!this.$matchTokenType(r.getCurrentToken()||"text",u)){if(/[)}\]]/.test(e.session.getLine(n.row)[n.column]))return!0;var i=new s(t,n.row,n.column+1);if(!this.$matchTokenType(i.getCurrentToken()||"text",u))return!1}return r.stepForward(),r.getCurrentTokenRow()!==n.row||this.$matchTokenType(r.getCurrentToken()||"text",a)},d.$matchTokenType=function(e,t){return t.indexOf(e.type||e)>-1},d.recordAutoInsert=function(e,t,n){var r=e.getCursorPosition(),i=t.doc.getLine(r.row);this.isAutoInsertedClosing(r,i,f.autoInsertedLineEnd[0])||(f.autoInsertedBrackets=0),f.autoInsertedRow=r.row,f.autoInsertedLineEnd=n+i.substr(r.column),f.autoInsertedBrackets++},d.recordMaybeInsert=function(e,t,n){var r=e.getCursorPosition(),i=t.doc.getLine(r.row);this.isMaybeInsertedClosing(r,i)||(f.maybeInsertedBrackets=0),f.maybeInsertedRow=r.row,f.maybeInsertedLineStart=i.substr(0,r.column)+n,f.maybeInsertedLineEnd=i.substr(r.column),f.maybeInsertedBrackets++},d.isAutoInsertedClosing=function(e,t,n){return f.autoInsertedBrackets>0&&e.row===f.autoInsertedRow&&n===f.autoInsertedLineEnd[0]&&t.substr(e.column)===f.autoInsertedLineEnd},d.isMaybeInsertedClosing=function(e,t){return f.maybeInsertedBrackets>0&&e.row===f.maybeInsertedRow&&t.substr(e.column)===f.maybeInsertedLineEnd&&t.substr(0,e.column)==f.maybeInsertedLineStart},d.popAutoInsertedClosing=function(){f.autoInsertedLineEnd=f.autoInsertedLineEnd.substr(1),f.autoInsertedBrackets--},d.clearMaybeInsertedClosing=function(){f&&(f.maybeInsertedBrackets=0,f.maybeInsertedRow=-1)},r.inherits(d,i),t.CstyleBehaviour=d}),ace.define("ace/unicode",["require","exports","module"],function(e,t,n){"use strict";var r=[48,9,8,25,5,0,2,25,48,0,11,0,5,0,6,22,2,30,2,457,5,11,15,4,8,0,2,0,18,116,2,1,3,3,9,0,2,2,2,0,2,19,2,82,2,138,2,4,3,155,12,37,3,0,8,38,10,44,2,0,2,1,2,1,2,0,9,26,6,2,30,10,7,61,2,9,5,101,2,7,3,9,2,18,3,0,17,58,3,100,15,53,5,0,6,45,211,57,3,18,2,5,3,11,3,9,2,1,7,6,2,2,2,7,3,1,3,21,2,6,2,0,4,3,3,8,3,1,3,3,9,0,5,1,2,4,3,11,16,2,2,5,5,1,3,21,2,6,2,1,2,1,2,1,3,0,2,4,5,1,3,2,4,0,8,3,2,0,8,15,12,2,2,8,2,2,2,21,2,6,2,1,2,4,3,9,2,2,2,2,3,0,16,3,3,9,18,2,2,7,3,1,3,21,2,6,2,1,2,4,3,8,3,1,3,2,9,1,5,1,2,4,3,9,2,0,17,1,2,5,4,2,2,3,4,1,2,0,2,1,4,1,4,2,4,11,5,4,4,2,2,3,3,0,7,0,15,9,18,2,2,7,2,2,2,22,2,9,2,4,4,7,2,2,2,3,8,1,2,1,7,3,3,9,19,1,2,7,2,2,2,22,2,9,2,4,3,8,2,2,2,3,8,1,8,0,2,3,3,9,19,1,2,7,2,2,2,22,2,15,4,7,2,2,2,3,10,0,9,3,3,9,11,5,3,1,2,17,4,23,2,8,2,0,3,6,4,0,5,5,2,0,2,7,19,1,14,57,6,14,2,9,40,1,2,0,3,1,2,0,3,0,7,3,2,6,2,2,2,0,2,0,3,1,2,12,2,2,3,4,2,0,2,5,3,9,3,1,35,0,24,1,7,9,12,0,2,0,2,0,5,9,2,35,5,19,2,5,5,7,2,35,10,0,58,73,7,77,3,37,11,42,2,0,4,328,2,3,3,6,2,0,2,3,3,40,2,3,3,32,2,3,3,6,2,0,2,3,3,14,2,56,2,3,3,66,5,0,33,15,17,84,13,619,3,16,2,25,6,74,22,12,2,6,12,20,12,19,13,12,2,2,2,1,13,51,3,29,4,0,5,1,3,9,34,2,3,9,7,87,9,42,6,69,11,28,4,11,5,11,11,39,3,4,12,43,5,25,7,10,38,27,5,62,2,28,3,10,7,9,14,0,89,75,5,9,18,8,13,42,4,11,71,55,9,9,4,48,83,2,2,30,14,230,23,280,3,5,3,37,3,5,3,7,2,0,2,0,2,0,2,30,3,52,2,6,2,0,4,2,2,6,4,3,3,5,5,12,6,2,2,6,67,1,20,0,29,0,14,0,17,4,60,12,5,0,4,11,18,0,5,0,3,9,2,0,4,4,7,0,2,0,2,0,2,3,2,10,3,3,6,4,5,0,53,1,2684,46,2,46,2,132,7,6,15,37,11,53,10,0,17,22,10,6,2,6,2,6,2,6,2,6,2,6,2,6,2,6,2,31,48,0,470,1,36,5,2,4,6,1,5,85,3,1,3,2,2,89,2,3,6,40,4,93,18,23,57,15,513,6581,75,20939,53,1164,68,45,3,268,4,27,21,31,3,13,13,1,2,24,9,69,11,1,38,8,3,102,3,1,111,44,25,51,13,68,12,9,7,23,4,0,5,45,3,35,13,28,4,64,15,10,39,54,10,13,3,9,7,22,4,1,5,66,25,2,227,42,2,1,3,9,7,11171,13,22,5,48,8453,301,3,61,3,105,39,6,13,4,6,11,2,12,2,4,2,0,2,1,2,1,2,107,34,362,19,63,3,53,41,11,5,15,17,6,13,1,25,2,33,4,2,134,20,9,8,25,5,0,2,25,12,88,4,5,3,5,3,5,3,2],i=0,s=[];for(var o=0;o<r.length;o+=2)s.push(i+=r[o]),r[o+1]&&s.push(45,i+=r[o+1]);t.wordChars=String.fromCharCode.apply(null,s)}),ace.define("ace/mode/text",["require","exports","module","ace/config","ace/tokenizer","ace/mode/text_highlight_rules","ace/mode/behaviour/cstyle","ace/unicode","ace/lib/lang","ace/token_iterator","ace/range"],function(e,t,n){"use strict";var r=e("../config"),i=e("../tokenizer").Tokenizer,s=e("./text_highlight_rules").TextHighlightRules,o=e("./behaviour/cstyle").CstyleBehaviour,u=e("../unicode"),a=e("../lib/lang"),f=e("../token_iterator").TokenIterator,l=e("../range").Range,c=function(){this.HighlightRules=s};(function(){this.$defaultBehaviour=new o,this.tokenRe=new RegExp("^["+u.wordChars+"\\$_]+","g"),this.nonTokenRe=new RegExp("^(?:[^"+u.wordChars+"\\$_]|\\s])+","g"),this.getTokenizer=function(){return this.$tokenizer||(this.$highlightRules=this.$highlightRules||new this.HighlightRules(this.$highlightRuleConfig),this.$tokenizer=new i(this.$highlightRules.getRules())),this.$tokenizer},this.lineCommentStart="",this.blockComment="",this.toggleCommentLines=function(e,t,n,r){function w(e){for(var t=n;t<=r;t++)e(i.getLine(t),t)}var i=t.doc,s=!0,o=!0,u=Infinity,f=t.getTabSize(),l=!1;if(!this.lineCommentStart){if(!this.blockComment)return!1;var c=this.blockComment.start,h=this.blockComment.end,p=new RegExp("^(\\s*)(?:"+a.escapeRegExp(c)+")"),d=new RegExp("(?:"+a.escapeRegExp(h)+")\\s*$"),v=function(e,t){if(g(e,t))return;if(!s||/\S/.test(e))i.insertInLine({row:t,column:e.length},h),i.insertInLine({row:t,column:u},c)},m=function(e,t){var n;(n=e.match(d))&&i.removeInLine(t,e.length-n[0].length,e.length),(n=e.match(p))&&i.removeInLine(t,n[1].length,n[0].length)},g=function(e,n){if(p.test(e))return!0;var r=t.getTokens(n);for(var i=0;i<r.length;i++)if(r[i].type==="comment")return!0}}else{if(Array.isArray(this.lineCommentStart))var p=this.lineCommentStart.map(a.escapeRegExp).join("|"),c=this.lineCommentStart[0];else var p=a.escapeRegExp(this.lineCommentStart),c=this.lineCommentStart;p=new RegExp("^(\\s*)(?:"+p+") ?"),l=t.getUseSoftTabs();var m=function(e,t){var n=e.match(p);if(!n)return;var r=n[1].length,s=n[0].length;!b(e,r,s)&&n[0][s-1]==" "&&s--,i.removeInLine(t,r,s)},y=c+" ",v=function(e,t){if(!s||/\S/.test(e))b(e,u,u)?i.insertInLine({row:t,column:u},y):i.insertInLine({row:t,column:u},c)},g=function(e,t){return p.test(e)},b=function(e,t,n){var r=0;while(t--&&e.charAt(t)==" ")r++;if(r%f!=0)return!1;var r=0;while(e.charAt(n++)==" ")r++;return f>2?r%f!=f-1:r%f==0}}var E=Infinity;w(function(e,t){var n=e.search(/\S/);n!==-1?(n<u&&(u=n),o&&!g(e,t)&&(o=!1)):E>e.length&&(E=e.length)}),u==Infinity&&(u=E,s=!1,o=!1),l&&u%f!=0&&(u=Math.floor(u/f)*f),w(o?m:v)},this.toggleBlockComment=function(e,t,n,r){var i=this.blockComment;if(!i)return;!i.start&&i[0]&&(i=i[0]);var s=new f(t,r.row,r.column),o=s.getCurrentToken(),u=t.selection,a=t.selection.toOrientedRange(),c,h;if(o&&/comment/.test(o.type)){var p,d;while(o&&/comment/.test(o.type)){var v=o.value.indexOf(i.start);if(v!=-1){var m=s.getCurrentTokenRow(),g=s.getCurrentTokenColumn()+v;p=new l(m,g,m,g+i.start.length);break}o=s.stepBackward()}var s=new f(t,r.row,r.column),o=s.getCurrentToken();while(o&&/comment/.test(o.type)){var v=o.value.indexOf(i.end);if(v!=-1){var m=s.getCurrentTokenRow(),g=s.getCurrentTokenColumn()+v;d=new l(m,g,m,g+i.end.length);break}o=s.stepForward()}d&&t.remove(d),p&&(t.remove(p),c=p.start.row,h=-i.start.length)}else h=i.start.length,c=n.start.row,t.insert(n.end,i.end),t.insert(n.start,i.start);a.start.row==c&&(a.start.column+=h),a.end.row==c&&(a.end.column+=h),t.selection.fromOrientedRange(a)},this.getNextLineIndent=function(e,t,n){return this.$getIndent(t)},this.checkOutdent=function(e,t,n){return!1},this.autoOutdent=function(e,t,n){},this.$getIndent=function(e){return e.match(/^\s*/)[0]},this.createWorker=function(e){return null},this.createModeDelegates=function(e){this.$embeds=[],this.$modes={};for(var t in e)if(e[t]){var n=e[t],i=n.prototype.$id,s=r.$modes[i];s||(r.$modes[i]=s=new n),r.$modes[t]||(r.$modes[t]=s),this.$embeds.push(t),this.$modes[t]=s}var o=["toggleBlockComment","toggleCommentLines","getNextLineIndent","checkOutdent","autoOutdent","transformAction","getCompletions"];for(var t=0;t<o.length;t++)(function(e){var n=o[t],r=e[n];e[o[t]]=function(){return this.$delegator(n,arguments,r)}})(this)},this.$delegator=function(e,t,n){var r=t[0]||"start";if(typeof r!="string"){if(Array.isArray(r[2])){var i=r[2][r[2].length-1],s=this.$modes[i];if(s)return s[e].apply(s,[r[1]].concat([].slice.call(t,1)))}r=r[0]||"start"}for(var o=0;o<this.$embeds.length;o++){if(!this.$modes[this.$embeds[o]])continue;var u=r.split(this.$embeds[o]);if(!u[0]&&u[1]){t[0]=u[1];var s=this.$modes[this.$embeds[o]];return s[e].apply(s,t)}}var a=n.apply(this,t);return n?a:undefined},this.transformAction=function(e,t,n,r,i){if(this.$behaviour){var s=this.$behaviour.getBehaviours();for(var o in s)if(s[o][t]){var u=s[o][t].apply(this,arguments);if(u)return u}}},this.getKeywords=function(e){if(!this.completionKeywords){var t=this.$tokenizer.rules,n=[];for(var r in t){var i=t[r];for(var s=0,o=i.length;s<o;s++)if(typeof i[s].token=="string")/keyword|support|storage/.test(i[s].token)&&n.push(i[s].regex);else if(typeof i[s].token=="object")for(var u=0,a=i[s].token.length;u<a;u++)if(/keyword|support|storage/.test(i[s].token[u])){var r=i[s].regex.match(/\(.+?\)/g)[u];n.push(r.substr(1,r.length-2))}}this.completionKeywords=n}return e?n.concat(this.$keywordList||[]):this.$keywordList},this.$createKeywordList=function(){return this.$highlightRules||this.getTokenizer(),this.$keywordList=this.$highlightRules.$keywordList||[]},this.getCompletions=function(e,t,n,r){var i=this.$keywordList||this.$createKeywordList();return i.map(function(e){return{name:e,value:e,score:0,meta:"keyword"}})},this.$id="ace/mode/text"}).call(c.prototype),t.Mode=c}),ace.define("ace/apply_delta",["require","exports","module"],function(e,t,n){"use strict";function r(e,t){throw console.log("Invalid Delta:",e),"Invalid Delta: "+t}function i(e,t){return t.row>=0&&t.row<e.length&&t.column>=0&&t.column<=e[t.row].length}function s(e,t){t.action!="insert"&&t.action!="remove"&&r(t,"delta.action must be 'insert' or 'remove'"),t.lines instanceof Array||r(t,"delta.lines must be an Array"),(!t.start||!t.end)&&r(t,"delta.start/end must be an present");var n=t.start;i(e,t.start)||r(t,"delta.start must be contained in document");var s=t.end;t.action=="remove"&&!i(e,s)&&r(t,"delta.end must contained in document for 'remove' actions");var o=s.row-n.row,u=s.column-(o==0?n.column:0);(o!=t.lines.length-1||t.lines[o].length!=u)&&r(t,"delta.range must match delta lines")}t.applyDelta=function(e,t,n){var r=t.start.row,i=t.start.column,s=e[r]||"";switch(t.action){case"insert":var o=t.lines;if(o.length===1)e[r]=s.substring(0,i)+t.lines[0]+s.substring(i);else{var u=[r,1].concat(t.lines);e.splice.apply(e,u),e[r]=s.substring(0,i)+e[r],e[r+t.lines.length-1]+=s.substring(i)}break;case"remove":var a=t.end.column,f=t.end.row;r===f?e[r]=s.substring(0,i)+s.substring(a):e.splice(r,f-r+1,s.substring(0,i)+e[f].substring(a))}}}),ace.define("ace/anchor",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./lib/event_emitter").EventEmitter,s=t.Anchor=function(e,t,n){this.$onChange=this.onChange.bind(this),this.attach(e),typeof n=="undefined"?this.setPosition(t.row,t.column):this.setPosition(t,n)};(function(){function e(e,t,n){var r=n?e.column<=t.column:e.column<t.column;return e.row<t.row||e.row==t.row&&r}function t(t,n,r){var i=t.action=="insert",s=(i?1:-1)*(t.end.row-t.start.row),o=(i?1:-1)*(t.end.column-t.start.column),u=t.start,a=i?u:t.end;return e(n,u,r)?{row:n.row,column:n.column}:e(a,n,!r)?{row:n.row+s,column:n.column+(n.row==a.row?o:0)}:{row:u.row,column:u.column}}r.implement(this,i),this.getPosition=function(){return this.$clipPositionToDocument(this.row,this.column)},this.getDocument=function(){return this.document},this.$insertRight=!1,this.onChange=function(e){if(e.start.row==e.end.row&&e.start.row!=this.row)return;if(e.start.row>this.row)return;var n=t(e,{row:this.row,column:this.column},this.$insertRight);this.setPosition(n.row,n.column,!0)},this.setPosition=function(e,t,n){var r;n?r={row:e,column:t}:r=this.$clipPositionToDocument(e,t);if(this.row==r.row&&this.column==r.column)return;var i={row:this.row,column:this.column};this.row=r.row,this.column=r.column,this._signal("change",{old:i,value:r})},this.detach=function(){this.document.removeEventListener("change",this.$onChange)},this.attach=function(e){this.document=e||this.document,this.document.on("change",this.$onChange)},this.$clipPositionToDocument=function(e,t){var n={};return e>=this.document.getLength()?(n.row=Math.max(0,this.document.getLength()-1),n.column=this.document.getLine(n.row).length):e<0?(n.row=0,n.column=0):(n.row=e,n.column=Math.min(this.document.getLine(n.row).length,Math.max(0,t))),t<0&&(n.column=0),n}}).call(s.prototype)}),ace.define("ace/document",["require","exports","module","ace/lib/oop","ace/apply_delta","ace/lib/event_emitter","ace/range","ace/anchor"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./apply_delta").applyDelta,s=e("./lib/event_emitter").EventEmitter,o=e("./range").Range,u=e("./anchor").Anchor,a=function(e){this.$lines=[""],e.length===0?this.$lines=[""]:Array.isArray(e)?this.insertMergedLines({row:0,column:0},e):this.insert({row:0,column:0},e)};(function(){r.implement(this,s),this.setValue=function(e){var t=this.getLength()-1;this.remove(new o(0,0,t,this.getLine(t).length)),this.insert({row:0,column:0},e)},this.getValue=function(){return this.getAllLines().join(this.getNewLineCharacter())},this.createAnchor=function(e,t){return new u(this,e,t)},"aaa".split(/a/).length===0?this.$split=function(e){return e.replace(/\r\n|\r/g,"\n").split("\n")}:this.$split=function(e){return e.split(/\r\n|\r|\n/)},this.$detectNewLine=function(e){var t=e.match(/^.*?(\r\n|\r|\n)/m);this.$autoNewLine=t?t[1]:"\n",this._signal("changeNewLineMode")},this.getNewLineCharacter=function(){switch(this.$newLineMode){case"windows":return"\r\n";case"unix":return"\n";default:return this.$autoNewLine||"\n"}},this.$autoNewLine="",this.$newLineMode="auto",this.setNewLineMode=function(e){if(this.$newLineMode===e)return;this.$newLineMode=e,this._signal("changeNewLineMode")},this.getNewLineMode=function(){return this.$newLineMode},this.isNewLine=function(e){return e=="\r\n"||e=="\r"||e=="\n"},this.getLine=function(e){return this.$lines[e]||""},this.getLines=function(e,t){return this.$lines.slice(e,t+1)},this.getAllLines=function(){return this.getLines(0,this.getLength())},this.getLength=function(){return this.$lines.length},this.getTextRange=function(e){return this.getLinesForRange(e).join(this.getNewLineCharacter())},this.getLinesForRange=function(e){var t;if(e.start.row===e.end.row)t=[this.getLine(e.start.row).substring(e.start.column,e.end.column)];else{t=this.getLines(e.start.row,e.end.row),t[0]=(t[0]||"").substring(e.start.column);var n=t.length-1;e.end.row-e.start.row==n&&(t[n]=t[n].substring(0,e.end.column))}return t},this.insertLines=function(e,t){return console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead."),this.insertFullLines(e,t)},this.removeLines=function(e,t){return console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead."),this.removeFullLines(e,t)},this.insertNewLine=function(e){return console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead."),this.insertMergedLines(e,["",""])},this.insert=function(e,t){return this.getLength()<=1&&this.$detectNewLine(t),this.insertMergedLines(e,this.$split(t))},this.insertInLine=function(e,t){var n=this.clippedPos(e.row,e.column),r=this.pos(e.row,e.column+t.length);return this.applyDelta({start:n,end:r,action:"insert",lines:[t]},!0),this.clonePos(r)},this.clippedPos=function(e,t){var n=this.getLength();e===undefined?e=n:e<0?e=0:e>=n&&(e=n-1,t=undefined);var r=this.getLine(e);return t==undefined&&(t=r.length),t=Math.min(Math.max(t,0),r.length),{row:e,column:t}},this.clonePos=function(e){return{row:e.row,column:e.column}},this.pos=function(e,t){return{row:e,column:t}},this.$clipPosition=function(e){var t=this.getLength();return e.row>=t?(e.row=Math.max(0,t-1),e.column=this.getLine(t-1).length):(e.row=Math.max(0,e.row),e.column=Math.min(Math.max(e.column,0),this.getLine(e.row).length)),e},this.insertFullLines=function(e,t){e=Math.min(Math.max(e,0),this.getLength());var n=0;e<this.getLength()?(t=t.concat([""]),n=0):(t=[""].concat(t),e--,n=this.$lines[e].length),this.insertMergedLines({row:e,column:n},t)},this.insertMergedLines=function(e,t){var n=this.clippedPos(e.row,e.column),r={row:n.row+t.length-1,column:(t.length==1?n.column:0)+t[t.length-1].length};return this.applyDelta({start:n,end:r,action:"insert",lines:t}),this.clonePos(r)},this.remove=function(e){var t=this.clippedPos(e.start.row,e.start.column),n=this.clippedPos(e.end.row,e.end.column);return this.applyDelta({start:t,end:n,action:"remove",lines:this.getLinesForRange({start:t,end:n})}),this.clonePos(t)},this.removeInLine=function(e,t,n){var r=this.clippedPos(e,t),i=this.clippedPos(e,n);return this.applyDelta({start:r,end:i,action:"remove",lines:this.getLinesForRange({start:r,end:i})},!0),this.clonePos(r)},this.removeFullLines=function(e,t){e=Math.min(Math.max(0,e),this.getLength()-1),t=Math.min(Math.max(0,t),this.getLength()-1);var n=t==this.getLength()-1&&e>0,r=t<this.getLength()-1,i=n?e-1:e,s=n?this.getLine(i).length:0,u=r?t+1:t,a=r?0:this.getLine(u).length,f=new o(i,s,u,a),l=this.$lines.slice(e,t+1);return this.applyDelta({start:f.start,end:f.end,action:"remove",lines:this.getLinesForRange(f)}),l},this.removeNewLine=function(e){e<this.getLength()-1&&e>=0&&this.applyDelta({start:this.pos(e,this.getLine(e).length),end:this.pos(e+1,0),action:"remove",lines:["",""]})},this.replace=function(e,t){e instanceof o||(e=o.fromPoints(e.start,e.end));if(t.length===0&&e.isEmpty())return e.start;if(t==this.getTextRange(e))return e.end;this.remove(e);var n;return t?n=this.insert(e.start,t):n=e.start,n},this.applyDeltas=function(e){for(var t=0;t<e.length;t++)this.applyDelta(e[t])},this.revertDeltas=function(e){for(var t=e.length-1;t>=0;t--)this.revertDelta(e[t])},this.applyDelta=function(e,t){var n=e.action=="insert";if(n?e.lines.length<=1&&!e.lines[0]:!o.comparePoints(e.start,e.end))return;n&&e.lines.length>2e4?this.$splitAndapplyLargeDelta(e,2e4):(i(this.$lines,e,t),this._signal("change",e))},this.$splitAndapplyLargeDelta=function(e,t){var n=e.lines,r=n.length-t+1,i=e.start.row,s=e.start.column;for(var o=0,u=0;o<r;o=u){u+=t-1;var a=n.slice(o,u);a.push(""),this.applyDelta({start:this.pos(i+o,s),end:this.pos(i+u,s=0),action:e.action,lines:a},!0)}e.lines=n.slice(o),e.start.row=i+o,e.start.column=s,this.applyDelta(e,!0)},this.revertDelta=function(e){this.applyDelta({start:this.clonePos(e.start),end:this.clonePos(e.end),action:e.action=="insert"?"remove":"insert",lines:e.lines.slice()})},this.indexToPosition=function(e,t){var n=this.$lines||this.getAllLines(),r=this.getNewLineCharacter().length;for(var i=t||0,s=n.length;i<s;i++){e-=n[i].length+r;if(e<0)return{row:i,column:e+n[i].length+r}}return{row:s-1,column:e+n[s-1].length+r}},this.positionToIndex=function(e,t){var n=this.$lines||this.getAllLines(),r=this.getNewLineCharacter().length,i=0,s=Math.min(e.row,n.length);for(var o=t||0;o<s;++o)i+=n[o].length+r;return i+e.column}}).call(a.prototype),t.Document=a}),ace.define("ace/background_tokenizer",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./lib/event_emitter").EventEmitter,s=function(e,t){this.running=!1,this.lines=[],this.states=[],this.currentLine=0,this.tokenizer=e;var n=this;this.$worker=function(){if(!n.running)return;var e=new Date,t=n.currentLine,r=-1,i=n.doc,s=t;while(n.lines[t])t++;var o=i.getLength(),u=0;n.running=!1;while(t<o){n.$tokenizeRow(t),r=t;do t++;while(n.lines[t]);u++;if(u%5===0&&new Date-e>20){n.running=setTimeout(n.$worker,20);break}}n.currentLine=t,r==-1&&(r=t),s<=r&&n.fireUpdateEvent(s,r)}};(function(){r.implement(this,i),this.setTokenizer=function(e){this.tokenizer=e,this.lines=[],this.states=[],this.start(0)},this.setDocument=function(e){this.doc=e,this.lines=[],this.states=[],this.stop()},this.fireUpdateEvent=function(e,t){var n={first:e,last:t};this._signal("update",{data:n})},this.start=function(e){this.currentLine=Math.min(e||0,this.currentLine,this.doc.getLength()),this.lines.splice(this.currentLine,this.lines.length),this.states.splice(this.currentLine,this.states.length),this.stop(),this.running=setTimeout(this.$worker,700)},this.scheduleStart=function(){this.running||(this.running=setTimeout(this.$worker,700))},this.$updateOnChange=function(e){var t=e.start.row,n=e.end.row-t;if(n===0)this.lines[t]=null;else if(e.action=="remove")this.lines.splice(t,n+1,null),this.states.splice(t,n+1,null);else{var r=Array(n+1);r.unshift(t,1),this.lines.splice.apply(this.lines,r),this.states.splice.apply(this.states,r)}this.currentLine=Math.min(t,this.currentLine,this.doc.getLength()),this.stop()},this.stop=function(){this.running&&clearTimeout(this.running),this.running=!1},this.getTokens=function(e){return this.lines[e]||this.$tokenizeRow(e)},this.getState=function(e){return this.currentLine==e&&this.$tokenizeRow(e),this.states[e]||"start"},this.$tokenizeRow=function(e){var t=this.doc.getLine(e),n=this.states[e-1],r=this.tokenizer.getLineTokens(t,n,e);return this.states[e]+""!=r.state+""?(this.states[e]=r.state,this.lines[e+1]=null,this.currentLine>e+1&&(this.currentLine=e+1)):this.currentLine==e&&(this.currentLine=e+1),this.lines[e]=r.tokens}}).call(s.prototype),t.BackgroundTokenizer=s}),ace.define("ace/search_highlight",["require","exports","module","ace/lib/lang","ace/lib/oop","ace/range"],function(e,t,n){"use strict";var r=e("./lib/lang"),i=e("./lib/oop"),s=e("./range").Range,o=function(e,t,n){this.setRegexp(e),this.clazz=t,this.type=n||"text"};(function(){this.MAX_RANGES=500,this.setRegexp=function(e){if(this.regExp+""==e+"")return;this.regExp=e,this.cache=[]},this.update=function(e,t,n,i){if(!this.regExp)return;var o=i.firstRow,u=i.lastRow;for(var a=o;a<=u;a++){var f=this.cache[a];f==null&&(f=r.getMatchOffsets(n.getLine(a),this.regExp),f.length>this.MAX_RANGES&&(f=f.slice(0,this.MAX_RANGES)),f=f.map(function(e){return new s(a,e.offset,a,e.offset+e.length)}),this.cache[a]=f.length?f:"");for(var l=f.length;l--;)t.drawSingleLineMarker(e,f[l].toScreenRange(n),this.clazz,i)}}}).call(o.prototype),t.SearchHighlight=o}),ace.define("ace/edit_session/fold_line",["require","exports","module","ace/range"],function(e,t,n){"use strict";function i(e,t){this.foldData=e,Array.isArray(t)?this.folds=t:t=this.folds=[t];var n=t[t.length-1];this.range=new r(t[0].start.row,t[0].start.column,n.end.row,n.end.column),this.start=this.range.start,this.end=this.range.end,this.folds.forEach(function(e){e.setFoldLine(this)},this)}var r=e("../range").Range;(function(){this.shiftRow=function(e){this.start.row+=e,this.end.row+=e,this.folds.forEach(function(t){t.start.row+=e,t.end.row+=e})},this.addFold=function(e){if(e.sameRow){if(e.start.row<this.startRow||e.endRow>this.endRow)throw new Error("Can't add a fold to this FoldLine as it has no connection");this.folds.push(e),this.folds.sort(function(e,t){return-e.range.compareEnd(t.start.row,t.start.column)}),this.range.compareEnd(e.start.row,e.start.column)>0?(this.end.row=e.end.row,this.end.column=e.end.column):this.range.compareStart(e.end.row,e.end.column)<0&&(this.start.row=e.start.row,this.start.column=e.start.column)}else if(e.start.row==this.end.row)this.folds.push(e),this.end.row=e.end.row,this.end.column=e.end.column;else{if(e.end.row!=this.start.row)throw new Error("Trying to add fold to FoldRow that doesn't have a matching row");this.folds.unshift(e),this.start.row=e.start.row,this.start.column=e.start.column}e.foldLine=this},this.containsRow=function(e){return e>=this.start.row&&e<=this.end.row},this.walk=function(e,t,n){var r=0,i=this.folds,s,o,u,a=!0;t==null&&(t=this.end.row,n=this.end.column);for(var f=0;f<i.length;f++){s=i[f],o=s.range.compareStart(t,n);if(o==-1){e(null,t,n,r,a);return}u=e(null,s.start.row,s.start.column,r,a),u=!u&&e(s.placeholder,s.start.row,s.start.column,r);if(u||o===0)return;a=!s.sameRow,r=s.end.column}e(null,t,n,r,a)},this.getNextFoldTo=function(e,t){var n,r;for(var i=0;i<this.folds.length;i++){n=this.folds[i],r=n.range.compareEnd(e,t);if(r==-1)return{fold:n,kind:"after"};if(r===0)return{fold:n,kind:"inside"}}return null},this.addRemoveChars=function(e,t,n){var r=this.getNextFoldTo(e,t),i,s;if(r){i=r.fold;if(r.kind=="inside"&&i.start.column!=t&&i.start.row!=e)window.console&&window.console.log(e,t,i);else if(i.start.row==e){s=this.folds;var o=s.indexOf(i);o===0&&(this.start.column+=n);for(o;o<s.length;o++){i=s[o],i.start.column+=n;if(!i.sameRow)return;i.end.column+=n}this.end.column+=n}}},this.split=function(e,t){var n=this.getNextFoldTo(e,t);if(!n||n.kind=="inside")return null;var r=n.fold,s=this.folds,o=this.foldData,u=s.indexOf(r),a=s[u-1];this.end.row=a.end.row,this.end.column=a.end.column,s=s.splice(u,s.length-u);var f=new i(o,s);return o.splice(o.indexOf(this)+1,0,f),f},this.merge=function(e){var t=e.folds;for(var n=0;n<t.length;n++)this.addFold(t[n]);var r=this.foldData;r.splice(r.indexOf(e),1)},this.toString=function(){var e=[this.range.toString()+": ["];return this.folds.forEach(function(t){e.push("  "+t.toString())}),e.push("]"),e.join("\n")},this.idxToPosition=function(e){var t=0;for(var n=0;n<this.folds.length;n++){var r=this.folds[n];e-=r.start.column-t;if(e<0)return{row:r.start.row,column:r.start.column+e};e-=r.placeholder.length;if(e<0)return r.start;t=r.end.column}return{row:this.end.row,column:this.end.column+e}}}).call(i.prototype),t.FoldLine=i}),ace.define("ace/range_list",["require","exports","module","ace/range"],function(e,t,n){"use strict";var r=e("./range").Range,i=r.comparePoints,s=function(){this.ranges=[],this.$bias=1};(function(){this.comparePoints=i,this.pointIndex=function(e,t,n){var r=this.ranges;for(var s=n||0;s<r.length;s++){var o=r[s],u=i(e,o.end);if(u>0)continue;var a=i(e,o.start);return u===0?t&&a!==0?-s-2:s:a>0||a===0&&!t?s:-s-1}return-s-1},this.add=function(e){var t=!e.isEmpty(),n=this.pointIndex(e.start,t);n<0&&(n=-n-1);var r=this.pointIndex(e.end,t,n);return r<0?r=-r-1:r++,this.ranges.splice(n,r-n,e)},this.addList=function(e){var t=[];for(var n=e.length;n--;)t.push.apply(t,this.add(e[n]));return t},this.substractPoint=function(e){var t=this.pointIndex(e);if(t>=0)return this.ranges.splice(t,1)},this.merge=function(){var e=[],t=this.ranges;t=t.sort(function(e,t){return i(e.start,t.start)});var n=t[0],r;for(var s=1;s<t.length;s++){r=n,n=t[s];var o=i(r.end,n.start);if(o<0)continue;if(o==0&&!r.isEmpty()&&!n.isEmpty())continue;i(r.end,n.end)<0&&(r.end.row=n.end.row,r.end.column=n.end.column),t.splice(s,1),e.push(n),n=r,s--}return this.ranges=t,e},this.contains=function(e,t){return this.pointIndex({row:e,column:t})>=0},this.containsPoint=function(e){return this.pointIndex(e)>=0},this.rangeAtPoint=function(e){var t=this.pointIndex(e);if(t>=0)return this.ranges[t]},this.clipRows=function(e,t){var n=this.ranges;if(n[0].start.row>t||n[n.length-1].start.row<e)return[];var r=this.pointIndex({row:e,column:0});r<0&&(r=-r-1);var i=this.pointIndex({row:t,column:0},r);i<0&&(i=-i-1);var s=[];for(var o=r;o<i;o++)s.push(n[o]);return s},this.removeAll=function(){return this.ranges.splice(0,this.ranges.length)},this.attach=function(e){this.session&&this.detach(),this.session=e,this.onChange=this.$onChange.bind(this),this.session.on("change",this.onChange)},this.detach=function(){if(!this.session)return;this.session.removeListener("change",this.onChange),this.session=null},this.$onChange=function(e){var t=e.start,n=e.end,r=t.row,i=n.row,s=this.ranges;for(var o=0,u=s.length;o<u;o++){var a=s[o];if(a.end.row>=r)break}if(e.action=="insert"){var f=i-r,l=-t.column+n.column;for(;o<u;o++){var a=s[o];if(a.start.row>r)break;a.start.row==r&&a.start.column>=t.column&&(a.start.column==t.column&&this.$bias<=0||(a.start.column+=l,a.start.row+=f));if(a.end.row==r&&a.end.column>=t.column){if(a.end.column==t.column&&this.$bias<0)continue;a.end.column==t.column&&l>0&&o<u-1&&a.end.column>a.start.column&&a.end.column==s[o+1].start.column&&(a.end.column-=l),a.end.column+=l,a.end.row+=f}}}else{var f=r-i,l=t.column-n.column;for(;o<u;o++){var a=s[o];if(a.start.row>i)break;if(a.end.row<i&&(r<a.end.row||r==a.end.row&&t.column<a.end.column))a.end.row=r,a.end.column=t.column;else if(a.end.row==i)if(a.end.column<=n.column){if(f||a.end.column>t.column)a.end.column=t.column,a.end.row=t.row}else a.end.column+=l,a.end.row+=f;else a.end.row>i&&(a.end.row+=f);if(a.start.row<i&&(r<a.start.row||r==a.start.row&&t.column<a.start.column))a.start.row=r,a.start.column=t.column;else if(a.start.row==i)if(a.start.column<=n.column){if(f||a.start.column>t.column)a.start.column=t.column,a.start.row=t.row}else a.start.column+=l,a.start.row+=f;else a.start.row>i&&(a.start.row+=f)}}if(f!=0&&o<u)for(;o<u;o++){var a=s[o];a.start.row+=f,a.end.row+=f}}}).call(s.prototype),t.RangeList=s}),ace.define("ace/edit_session/fold",["require","exports","module","ace/range_list","ace/lib/oop"],function(e,t,n){"use strict";function o(e,t){e.row-=t.row,e.row==0&&(e.column-=t.column)}function u(e,t){o(e.start,t),o(e.end,t)}function a(e,t){e.row==0&&(e.column+=t.column),e.row+=t.row}function f(e,t){a(e.start,t),a(e.end,t)}var r=e("../range_list").RangeList,i=e("../lib/oop"),s=t.Fold=function(e,t){this.foldLine=null,this.placeholder=t,this.range=e,this.start=e.start,this.end=e.end,this.sameRow=e.start.row==e.end.row,this.subFolds=this.ranges=[]};i.inherits(s,r),function(){this.toString=function(){return'"'+this.placeholder+'" '+this.range.toString()},this.setFoldLine=function(e){this.foldLine=e,this.subFolds.forEach(function(t){t.setFoldLine(e)})},this.clone=function(){var e=this.range.clone(),t=new s(e,this.placeholder);return this.subFolds.forEach(function(e){t.subFolds.push(e.clone())}),t.collapseChildren=this.collapseChildren,t},this.addSubFold=function(e){if(this.range.isEqual(e))return;u(e,this.start);var t=e.start.row,n=e.start.column;for(var r=0,i=-1;r<this.subFolds.length;r++){i=this.subFolds[r].range.compare(t,n);if(i!=1)break}var s=this.subFolds[r],o=0;if(i==0){if(s.range.containsRange(e))return s.addSubFold(e);o=1}var t=e.range.end.row,n=e.range.end.column;for(var a=r,i=-1;a<this.subFolds.length;a++){i=this.subFolds[a].range.compare(t,n);if(i!=1)break}i==0&&a++;var f=this.subFolds.splice(r,a-r,e),l=i==0?f.length-1:f.length;for(var c=o;c<l;c++)e.addSubFold(f[c]);return e.setFoldLine(this.foldLine),e},this.restoreRange=function(e){return f(e,this.start)}}.call(s.prototype)}),ace.define("ace/edit_session/folding",["require","exports","module","ace/range","ace/edit_session/fold_line","ace/edit_session/fold","ace/token_iterator"],function(e,t,n){"use strict";function u(){this.getFoldAt=function(e,t,n){var r=this.getFoldLine(e);if(!r)return null;var i=r.folds;for(var s=0;s<i.length;s++){var o=i[s].range;if(o.contains(e,t)){if(n==1&&o.isEnd(e,t)&&!o.isEmpty())continue;if(n==-1&&o.isStart(e,t)&&!o.isEmpty())continue;return i[s]}}},this.getFoldsInRange=function(e){var t=e.start,n=e.end,r=this.$foldData,i=[];t.column+=1,n.column-=1;for(var s=0;s<r.length;s++){var o=r[s].range.compareRange(e);if(o==2)continue;if(o==-2)break;var u=r[s].folds;for(var a=0;a<u.length;a++){var f=u[a];o=f.range.compareRange(e);if(o==-2)break;if(o==2)continue;if(o==42)break;i.push(f)}}return t.column-=1,n.column+=1,i},this.getFoldsInRangeList=function(e){if(Array.isArray(e)){var t=[];e.forEach(function(e){t=t.concat(this.getFoldsInRange(e))},this)}else var t=this.getFoldsInRange(e);return t},this.getAllFolds=function(){var e=[],t=this.$foldData;for(var n=0;n<t.length;n++)for(var r=0;r<t[n].folds.length;r++)e.push(t[n].folds[r]);return e},this.getFoldStringAt=function(e,t,n,r){r=r||this.getFoldLine(e);if(!r)return null;var i={end:{column:0}},s,o;for(var u=0;u<r.folds.length;u++){o=r.folds[u];var a=o.range.compareEnd(e,t);if(a==-1){s=this.getLine(o.start.row).substring(i.end.column,o.start.column);break}if(a===0)return null;i=o}return s||(s=this.getLine(o.start.row).substring(i.end.column)),n==-1?s.substring(0,t-i.end.column):n==1?s.substring(t-i.end.column):s},this.getFoldLine=function(e,t){var n=this.$foldData,r=0;t&&(r=n.indexOf(t)),r==-1&&(r=0);for(r;r<n.length;r++){var i=n[r];if(i.start.row<=e&&i.end.row>=e)return i;if(i.end.row>e)return null}return null},this.getNextFoldLine=function(e,t){var n=this.$foldData,r=0;t&&(r=n.indexOf(t)),r==-1&&(r=0);for(r;r<n.length;r++){var i=n[r];if(i.end.row>=e)return i}return null},this.getFoldedRowCount=function(e,t){var n=this.$foldData,r=t-e+1;for(var i=0;i<n.length;i++){var s=n[i],o=s.end.row,u=s.start.row;if(o>=t){u<t&&(u>=e?r-=t-u:r=0);break}o>=e&&(u>=e?r-=o-u:r-=o-e+1)}return r},this.$addFoldLine=function(e){return this.$foldData.push(e),this.$foldData.sort(function(e,t){return e.start.row-t.start.row}),e},this.addFold=function(e,t){var n=this.$foldData,r=!1,o;e instanceof s?o=e:(o=new s(t,e),o.collapseChildren=t.collapseChildren),this.$clipRangeToDocument(o.range);var u=o.start.row,a=o.start.column,f=o.end.row,l=o.end.column,c=this.getFoldAt(u,a,1),h=this.getFoldAt(f,l,-1);if(c&&h==c)return c.addSubFold(o);c&&!c.range.isStart(u,a)&&this.removeFold(c),h&&!h.range.isEnd(f,l)&&this.removeFold(h);var p=this.getFoldsInRange(o.range);p.length>0&&(this.removeFolds(p),p.forEach(function(e){o.addSubFold(e)}));for(var d=0;d<n.length;d++){var v=n[d];if(f==v.start.row){v.addFold(o),r=!0;break}if(u==v.end.row){v.addFold(o),r=!0;if(!o.sameRow){var m=n[d+1];if(m&&m.start.row==f){v.merge(m);break}}break}if(f<=v.start.row)break}return r||(v=this.$addFoldLine(new i(this.$foldData,o))),this.$useWrapMode?this.$updateWrapData(v.start.row,v.start.row):this.$updateRowLengthCache(v.start.row,v.start.row),this.$modified=!0,this._signal("changeFold",{data:o,action:"add"}),o},this.addFolds=function(e){e.forEach(function(e){this.addFold(e)},this)},this.removeFold=function(e){var t=e.foldLine,n=t.start.row,r=t.end.row,i=this.$foldData,s=t.folds;if(s.length==1)i.splice(i.indexOf(t),1);else if(t.range.isEnd(e.end.row,e.end.column))s.pop(),t.end.row=s[s.length-1].end.row,t.end.column=s[s.length-1].end.column;else if(t.range.isStart(e.start.row,e.start.column))s.shift(),t.start.row=s[0].start.row,t.start.column=s[0].start.column;else if(e.sameRow)s.splice(s.indexOf(e),1);else{var o=t.split(e.start.row,e.start.column);s=o.folds,s.shift(),o.start.row=s[0].start.row,o.start.column=s[0].start.column}this.$updating||(this.$useWrapMode?this.$updateWrapData(n,r):this.$updateRowLengthCache(n,r)),this.$modified=!0,this._signal("changeFold",{data:e,action:"remove"})},this.removeFolds=function(e){var t=[];for(var n=0;n<e.length;n++)t.push(e[n]);t.forEach(function(e){this.removeFold(e)},this),this.$modified=!0},this.expandFold=function(e){this.removeFold(e),e.subFolds.forEach(function(t){e.restoreRange(t),this.addFold(t)},this),e.collapseChildren>0&&this.foldAll(e.start.row+1,e.end.row,e.collapseChildren-1),e.subFolds=[]},this.expandFolds=function(e){e.forEach(function(e){this.expandFold(e)},this)},this.unfold=function(e,t){var n,i;e==null?(n=new r(0,0,this.getLength(),0),t=!0):typeof e=="number"?n=new r(e,0,e,this.getLine(e).length):"row"in e?n=r.fromPoints(e,e):n=e,i=this.getFoldsInRangeList(n);if(t)this.removeFolds(i);else{var s=i;while(s.length)this.expandFolds(s),s=this.getFoldsInRangeList(n)}if(i.length)return i},this.isRowFolded=function(e,t){return!!this.getFoldLine(e,t)},this.getRowFoldEnd=function(e,t){var n=this.getFoldLine(e,t);return n?n.end.row:e},this.getRowFoldStart=function(e,t){var n=this.getFoldLine(e,t);return n?n.start.row:e},this.getFoldDisplayLine=function(e,t,n,r,i){r==null&&(r=e.start.row),i==null&&(i=0),t==null&&(t=e.end.row),n==null&&(n=this.getLine(t).length);var s=this.doc,o="";return e.walk(function(e,t,n,u){if(t<r)return;if(t==r){if(n<i)return;u=Math.max(i,u)}e!=null?o+=e:o+=s.getLine(t).substring(u,n)},t,n),o},this.getDisplayLine=function(e,t,n,r){var i=this.getFoldLine(e);if(!i){var s;return s=this.doc.getLine(e),s.substring(r||0,t||s.length)}return this.getFoldDisplayLine(i,e,t,n,r)},this.$cloneFoldData=function(){var e=[];return e=this.$foldData.map(function(t){var n=t.folds.map(function(e){return e.clone()});return new i(e,n)}),e},this.toggleFold=function(e){var t=this.selection,n=t.getRange(),r,i;if(n.isEmpty()){var s=n.start;r=this.getFoldAt(s.row,s.column);if(r){this.expandFold(r);return}(i=this.findMatchingBracket(s))?n.comparePoint(i)==1?n.end=i:(n.start=i,n.start.column++,n.end.column--):(i=this.findMatchingBracket({row:s.row,column:s.column+1}))?(n.comparePoint(i)==1?n.end=i:n.start=i,n.start.column++):n=this.getCommentFoldRange(s.row,s.column)||n}else{var o=this.getFoldsInRange(n);if(e&&o.length){this.expandFolds(o);return}o.length==1&&(r=o[0])}r||(r=this.getFoldAt(n.start.row,n.start.column));if(r&&r.range.toString()==n.toString()){this.expandFold(r);return}var u="...";if(!n.isMultiLine()){u=this.getTextRange(n);if(u.length<4)return;u=u.trim().substring(0,2)+".."}this.addFold(u,n)},this.getCommentFoldRange=function(e,t,n){var i=new o(this,e,t),s=i.getCurrentToken(),u=s.type;if(s&&/^comment|string/.test(u)){u=u.match(/comment|string/)[0],u=="comment"&&(u+="|doc-start");var a=new RegExp(u),f=new r;if(n!=1){do s=i.stepBackward();while(s&&a.test(s.type));i.stepForward()}f.start.row=i.getCurrentTokenRow(),f.start.column=i.getCurrentTokenColumn()+2,i=new o(this,e,t);if(n!=-1){var l=-1;do{s=i.stepForward();if(l==-1){var c=this.getState(i.$row);a.test(c)||(l=i.$row)}else if(i.$row>l)break}while(s&&a.test(s.type));s=i.stepBackward()}else s=i.getCurrentToken();return f.end.row=i.getCurrentTokenRow(),f.end.column=i.getCurrentTokenColumn()+s.value.length-2,f}},this.foldAll=function(e,t,n){n==undefined&&(n=1e5);var r=this.foldWidgets;if(!r)return;t=t||this.getLength(),e=e||0;for(var i=e;i<t;i++){r[i]==null&&(r[i]=this.getFoldWidget(i));if(r[i]!="start")continue;var s=this.getFoldWidgetRange(i);if(s&&s.isMultiLine()&&s.end.row<=t&&s.start.row>=e){i=s.end.row;try{var o=this.addFold("...",s);o&&(o.collapseChildren=n)}catch(u){}}}},this.$foldStyles={manual:1,markbegin:1,markbeginend:1},this.$foldStyle="markbegin",this.setFoldStyle=function(e){if(!this.$foldStyles[e])throw new Error("invalid fold style: "+e+"["+Object.keys(this.$foldStyles).join(", ")+"]");if(this.$foldStyle==e)return;this.$foldStyle=e,e=="manual"&&this.unfold();var t=this.$foldMode;this.$setFolding(null),this.$setFolding(t)},this.$setFolding=function(e){if(this.$foldMode==e)return;this.$foldMode=e,this.off("change",this.$updateFoldWidgets),this.off("tokenizerUpdate",this.$tokenizerUpdateFoldWidgets),this._signal("changeAnnotation");if(!e||this.$foldStyle=="manual"){this.foldWidgets=null;return}this.foldWidgets=[],this.getFoldWidget=e.getFoldWidget.bind(e,this,this.$foldStyle),this.getFoldWidgetRange=e.getFoldWidgetRange.bind(e,this,this.$foldStyle),this.$updateFoldWidgets=this.updateFoldWidgets.bind(this),this.$tokenizerUpdateFoldWidgets=this.tokenizerUpdateFoldWidgets.bind(this),this.on("change",this.$updateFoldWidgets),this.on("tokenizerUpdate",this.$tokenizerUpdateFoldWidgets)},this.getParentFoldRangeData=function(e,t){var n=this.foldWidgets;if(!n||t&&n[e])return{};var r=e-1,i;while(r>=0){var s=n[r];s==null&&(s=n[r]=this.getFoldWidget(r));if(s=="start"){var o=this.getFoldWidgetRange(r);i||(i=o);if(o&&o.end.row>=e)break}r--}return{range:r!==-1&&o,firstRange:i}},this.onFoldWidgetClick=function(e,t){t=t.domEvent;var n={children:t.shiftKey,all:t.ctrlKey||t.metaKey,siblings:t.altKey},r=this.$toggleFoldWidget(e,n);if(!r){var i=t.target||t.srcElement;i&&/ace_fold-widget/.test(i.className)&&(i.className+=" ace_invalid")}},this.$toggleFoldWidget=function(e,t){if(!this.getFoldWidget)return;var n=this.getFoldWidget(e),r=this.getLine(e),i=n==="end"?-1:1,s=this.getFoldAt(e,i===-1?0:r.length,i);if(s)return t.children||t.all?this.removeFold(s):this.expandFold(s),s;var o=this.getFoldWidgetRange(e,!0);if(o&&!o.isMultiLine()){s=this.getFoldAt(o.start.row,o.start.column,1);if(s&&o.isEqual(s.range))return this.removeFold(s),s}if(t.siblings){var u=this.getParentFoldRangeData(e);if(u.range)var a=u.range.start.row+1,f=u.range.end.row;this.foldAll(a,f,t.all?1e4:0)}else t.children?(f=o?o.end.row:this.getLength(),this.foldAll(e+1,f,t.all?1e4:0)):o&&(t.all&&(o.collapseChildren=1e4),this.addFold("...",o));return o},this.toggleFoldWidget=function(e){var t=this.selection.getCursor().row;t=this.getRowFoldStart(t);var n=this.$toggleFoldWidget(t,{});if(n)return;var r=this.getParentFoldRangeData(t,!0);n=r.range||r.firstRange;if(n){t=n.start.row;var i=this.getFoldAt(t,this.getLine(t).length,1);i?this.removeFold(i):this.addFold("...",n)}},this.updateFoldWidgets=function(e){var t=e.start.row,n=e.end.row-t;if(n===0)this.foldWidgets[t]=null;else if(e.action=="remove")this.foldWidgets.splice(t,n+1,null);else{var r=Array(n+1);r.unshift(t,1),this.foldWidgets.splice.apply(this.foldWidgets,r)}},this.tokenizerUpdateFoldWidgets=function(e){var t=e.data;t.first!=t.last&&this.foldWidgets.length>t.first&&this.foldWidgets.splice(t.first,this.foldWidgets.length)}}var r=e("../range").Range,i=e("./fold_line").FoldLine,s=e("./fold").Fold,o=e("../token_iterator").TokenIterator;t.Folding=u}),ace.define("ace/edit_session/bracket_match",["require","exports","module","ace/token_iterator","ace/range"],function(e,t,n){"use strict";function s(){this.findMatchingBracket=function(e,t){if(e.column==0)return null;var n=t||this.getLine(e.row).charAt(e.column-1);if(n=="")return null;var r=n.match(/([\(\[\{])|([\)\]\}])/);return r?r[1]?this.$findClosingBracket(r[1],e):this.$findOpeningBracket(r[2],e):null},this.getBracketRange=function(e){var t=this.getLine(e.row),n=!0,r,s=t.charAt(e.column-1),o=s&&s.match(/([\(\[\{])|([\)\]\}])/);o||(s=t.charAt(e.column),e={row:e.row,column:e.column+1},o=s&&s.match(/([\(\[\{])|([\)\]\}])/),n=!1);if(!o)return null;if(o[1]){var u=this.$findClosingBracket(o[1],e);if(!u)return null;r=i.fromPoints(e,u),n||(r.end.column++,r.start.column--),r.cursor=r.end}else{var u=this.$findOpeningBracket(o[2],e);if(!u)return null;r=i.fromPoints(u,e),n||(r.start.column++,r.end.column--),r.cursor=r.start}return r},this.$brackets={")":"(","(":")","]":"[","[":"]","{":"}","}":"{","<":">",">":"<"},this.$findOpeningBracket=function(e,t,n){var i=this.$brackets[e],s=1,o=new r(this,t.row,t.column),u=o.getCurrentToken();u||(u=o.stepForward());if(!u)return;n||(n=new RegExp("(\\.?"+u.type.replace(".","\\.").replace("rparen",".paren").replace(/\b(?:end)\b/,"(?:start|begin|end)")+")+"));var a=t.column-o.getCurrentTokenColumn()-2,f=u.value;for(;;){while(a>=0){var l=f.charAt(a);if(l==i){s-=1;if(s==0)return{row:o.getCurrentTokenRow(),column:a+o.getCurrentTokenColumn()}}else l==e&&(s+=1);a-=1}do u=o.stepBackward();while(u&&!n.test(u.type));if(u==null)break;f=u.value,a=f.length-1}return null},this.$findClosingBracket=function(e,t,n){var i=this.$brackets[e],s=1,o=new r(this,t.row,t.column),u=o.getCurrentToken();u||(u=o.stepForward());if(!u)return;n||(n=new RegExp("(\\.?"+u.type.replace(".","\\.").replace("lparen",".paren").replace(/\b(?:start|begin)\b/,"(?:start|begin|end)")+")+"));var a=t.column-o.getCurrentTokenColumn();for(;;){var f=u.value,l=f.length;while(a<l){var c=f.charAt(a);if(c==i){s-=1;if(s==0)return{row:o.getCurrentTokenRow(),column:a+o.getCurrentTokenColumn()}}else c==e&&(s+=1);a+=1}do u=o.stepForward();while(u&&!n.test(u.type));if(u==null)break;a=0}return null}}var r=e("../token_iterator").TokenIterator,i=e("../range").Range;t.BracketMatch=s}),ace.define("ace/edit_session",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/bidihandler","ace/config","ace/lib/event_emitter","ace/selection","ace/mode/text","ace/range","ace/document","ace/background_tokenizer","ace/search_highlight","ace/edit_session/folding","ace/edit_session/bracket_match"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./lib/lang"),s=e("./bidihandler").BidiHandler,o=e("./config"),u=e("./lib/event_emitter").EventEmitter,a=e("./selection").Selection,f=e("./mode/text").Mode,l=e("./range").Range,c=e("./document").Document,h=e("./background_tokenizer").BackgroundTokenizer,p=e("./search_highlight").SearchHighlight,d=function(e,t){this.$breakpoints=[],this.$decorations=[],this.$frontMarkers={},this.$backMarkers={},this.$markerId=1,this.$undoSelect=!0,this.$foldData=[],this.id="session"+ ++d.$uid,this.$foldData.toString=function(){return this.join("\n")},this.on("changeFold",this.onChangeFold.bind(this)),this.$onChange=this.onChange.bind(this);if(typeof e!="object"||!e.getLine)e=new c(e);this.setDocument(e),this.selection=new a(this),this.$bidiHandler=new s(this),o.resetOptions(this),this.setMode(t),o._signal("session",this)};d.$uid=0,function(){function m(e){return e<4352?!1:e>=4352&&e<=4447||e>=4515&&e<=4519||e>=4602&&e<=4607||e>=9001&&e<=9002||e>=11904&&e<=11929||e>=11931&&e<=12019||e>=12032&&e<=12245||e>=12272&&e<=12283||e>=12288&&e<=12350||e>=12353&&e<=12438||e>=12441&&e<=12543||e>=12549&&e<=12589||e>=12593&&e<=12686||e>=12688&&e<=12730||e>=12736&&e<=12771||e>=12784&&e<=12830||e>=12832&&e<=12871||e>=12880&&e<=13054||e>=13056&&e<=19903||e>=19968&&e<=42124||e>=42128&&e<=42182||e>=43360&&e<=43388||e>=44032&&e<=55203||e>=55216&&e<=55238||e>=55243&&e<=55291||e>=63744&&e<=64255||e>=65040&&e<=65049||e>=65072&&e<=65106||e>=65108&&e<=65126||e>=65128&&e<=65131||e>=65281&&e<=65376||e>=65504&&e<=65510}r.implement(this,u),this.setDocument=function(e){this.doc&&this.doc.removeListener("change",this.$onChange),this.doc=e,e.on("change",this.$onChange),this.bgTokenizer&&this.bgTokenizer.setDocument(this.getDocument()),this.resetCaches()},this.getDocument=function(){return this.doc},this.$resetRowCache=function(e){if(!e){this.$docRowCache=[],this.$screenRowCache=[];return}var t=this.$docRowCache.length,n=this.$getRowCacheIndex(this.$docRowCache,e)+1;t>n&&(this.$docRowCache.splice(n,t),this.$screenRowCache.splice(n,t))},this.$getRowCacheIndex=function(e,t){var n=0,r=e.length-1;while(n<=r){var i=n+r>>1,s=e[i];if(t>s)n=i+1;else{if(!(t<s))return i;r=i-1}}return n-1},this.resetCaches=function(){this.$modified=!0,this.$wrapData=[],this.$rowLengthCache=[],this.$resetRowCache(0),this.bgTokenizer&&this.bgTokenizer.start(0)},this.onChangeFold=function(e){var t=e.data;this.$resetRowCache(t.start.row)},this.onChange=function(e){this.$modified=!0,this.$bidiHandler.onChange(e),this.$resetRowCache(e.start.row);var t=this.$updateInternalDataOnChange(e);!this.$fromUndo&&this.$undoManager&&(t&&t.length&&(this.$undoManager.add({action:"removeFolds",folds:t},this.mergeUndoDeltas),this.mergeUndoDeltas=!0),this.$undoManager.add(e,this.mergeUndoDeltas),this.mergeUndoDeltas=!0,this.$informUndoManager.schedule()),this.bgTokenizer&&this.bgTokenizer.$updateOnChange(e),this._signal("change",e)},this.setValue=function(e){this.doc.setValue(e),this.selection.moveTo(0,0),this.$resetRowCache(0),this.setUndoManager(this.$undoManager),this.getUndoManager().reset()},this.getValue=this.toString=function(){return this.doc.getValue()},this.getSelection=function(){return this.selection},this.getState=function(e){return this.bgTokenizer.getState(e)},this.getTokens=function(e){return this.bgTokenizer.getTokens(e)},this.getTokenAt=function(e,t){var n=this.bgTokenizer.getTokens(e),r,i=0;if(t==null){var s=n.length-1;i=this.getLine(e).length}else for(var s=0;s<n.length;s++){i+=n[s].value.length;if(i>=t)break}return r=n[s],r?(r.index=s,r.start=i-r.value.length,r):null},this.setUndoManager=function(e){this.$undoManager=e,this.$informUndoManager&&this.$informUndoManager.cancel();if(e){var t=this;e.addSession(this),this.$syncInformUndoManager=function(){t.$informUndoManager.cancel(),t.mergeUndoDeltas=!1},this.$informUndoManager=i.delayedCall(this.$syncInformUndoManager)}else this.$syncInformUndoManager=function(){}},this.markUndoGroup=function(){this.$syncInformUndoManager&&this.$syncInformUndoManager()},this.$defaultUndoManager={undo:function(){},redo:function(){},hasUndo:function(){},hasRedo:function(){},reset:function(){},add:function(){},addSelection:function(){},startNewGroup:function(){},addSession:function(){}},this.getUndoManager=function(){return this.$undoManager||this.$defaultUndoManager},this.getTabString=function(){return this.getUseSoftTabs()?i.stringRepeat(" ",this.getTabSize()):"	"},this.setUseSoftTabs=function(e){this.setOption("useSoftTabs",e)},this.getUseSoftTabs=function(){return this.$useSoftTabs&&!this.$mode.$indentWithTabs},this.setTabSize=function(e){this.setOption("tabSize",e)},this.getTabSize=function(){return this.$tabSize},this.isTabStop=function(e){return this.$useSoftTabs&&e.column%this.$tabSize===0},this.setNavigateWithinSoftTabs=function(e){this.setOption("navigateWithinSoftTabs",e)},this.getNavigateWithinSoftTabs=function(){return this.$navigateWithinSoftTabs},this.$overwrite=!1,this.setOverwrite=function(e){this.setOption("overwrite",e)},this.getOverwrite=function(){return this.$overwrite},this.toggleOverwrite=function(){this.setOverwrite(!this.$overwrite)},this.addGutterDecoration=function(e,t){this.$decorations[e]||(this.$decorations[e]=""),this.$decorations[e]+=" "+t,this._signal("changeBreakpoint",{})},this.removeGutterDecoration=function(e,t){this.$decorations[e]=(this.$decorations[e]||"").replace(" "+t,""),this._signal("changeBreakpoint",{})},this.getBreakpoints=function(){return this.$breakpoints},this.setBreakpoints=function(e){this.$breakpoints=[];for(var t=0;t<e.length;t++)this.$breakpoints[e[t]]="ace_breakpoint";this._signal("changeBreakpoint",{})},this.clearBreakpoints=function(){this.$breakpoints=[],this._signal("changeBreakpoint",{})},this.setBreakpoint=function(e,t){t===undefined&&(t="ace_breakpoint"),t?this.$breakpoints[e]=t:delete this.$breakpoints[e],this._signal("changeBreakpoint",{})},this.clearBreakpoint=function(e){delete this.$breakpoints[e],this._signal("changeBreakpoint",{})},this.addMarker=function(e,t,n,r){var i=this.$markerId++,s={range:e,type:n||"line",renderer:typeof n=="function"?n:null,clazz:t,inFront:!!r,id:i};return r?(this.$frontMarkers[i]=s,this._signal("changeFrontMarker")):(this.$backMarkers[i]=s,this._signal("changeBackMarker")),i},this.addDynamicMarker=function(e,t){if(!e.update)return;var n=this.$markerId++;return e.id=n,e.inFront=!!t,t?(this.$frontMarkers[n]=e,this._signal("changeFrontMarker")):(this.$backMarkers[n]=e,this._signal("changeBackMarker")),e},this.removeMarker=function(e){var t=this.$frontMarkers[e]||this.$backMarkers[e];if(!t)return;var n=t.inFront?this.$frontMarkers:this.$backMarkers;delete n[e],this._signal(t.inFront?"changeFrontMarker":"changeBackMarker")},this.getMarkers=function(e){return e?this.$frontMarkers:this.$backMarkers},this.highlight=function(e){if(!this.$searchHighlight){var t=new p(null,"ace_selected-word","text");this.$searchHighlight=this.addDynamicMarker(t)}this.$searchHighlight.setRegexp(e)},this.highlightLines=function(e,t,n,r){typeof t!="number"&&(n=t,t=e),n||(n="ace_step");var i=new l(e,0,t,Infinity);return i.id=this.addMarker(i,n,"fullLine",r),i},this.setAnnotations=function(e){this.$annotations=e,this._signal("changeAnnotation",{})},this.getAnnotations=function(){return this.$annotations||[]},this.clearAnnotations=function(){this.setAnnotations([])},this.$detectNewLine=function(e){var t=e.match(/^.*?(\r?\n)/m);t?this.$autoNewLine=t[1]:this.$autoNewLine="\n"},this.getWordRange=function(e,t){var n=this.getLine(e),r=!1;t>0&&(r=!!n.charAt(t-1).match(this.tokenRe)),r||(r=!!n.charAt(t).match(this.tokenRe));if(r)var i=this.tokenRe;else if(/^\s+$/.test(n.slice(t-1,t+1)))var i=/\s/;else var i=this.nonTokenRe;var s=t;if(s>0){do s--;while(s>=0&&n.charAt(s).match(i));s++}var o=t;while(o<n.length&&n.charAt(o).match(i))o++;return new l(e,s,e,o)},this.getAWordRange=function(e,t){var n=this.getWordRange(e,t),r=this.getLine(n.end.row);while(r.charAt(n.end.column).match(/[ \t]/))n.end.column+=1;return n},this.setNewLineMode=function(e){this.doc.setNewLineMode(e)},this.getNewLineMode=function(){return this.doc.getNewLineMode()},this.setUseWorker=function(e){this.setOption("useWorker",e)},this.getUseWorker=function(){return this.$useWorker},this.onReloadTokenizer=function(e){var t=e.data;this.bgTokenizer.start(t.first),this._signal("tokenizerUpdate",e)},this.$modes=o.$modes,this.$mode=null,this.$modeId=null,this.setMode=function(e,t){if(e&&typeof e=="object"){if(e.getTokenizer)return this.$onChangeMode(e);var n=e,r=n.path}else r=e||"ace/mode/text";this.$modes["ace/mode/text"]||(this.$modes["ace/mode/text"]=new f);if(this.$modes[r]&&!n){this.$onChangeMode(this.$modes[r]),t&&t();return}this.$modeId=r,o.loadModule(["mode",r],function(e){if(this.$modeId!==r)return t&&t();this.$modes[r]&&!n?this.$onChangeMode(this.$modes[r]):e&&e.Mode&&(e=new e.Mode(n),n||(this.$modes[r]=e,e.$id=r),this.$onChangeMode(e)),t&&t()}.bind(this)),this.$mode||this.$onChangeMode(this.$modes["ace/mode/text"],!0)},this.$onChangeMode=function(e,t){t||(this.$modeId=e.$id);if(this.$mode===e)return;this.$mode=e,this.$stopWorker(),this.$useWorker&&this.$startWorker();var n=e.getTokenizer();if(n.addEventListener!==undefined){var r=this.onReloadTokenizer.bind(this);n.addEventListener("update",r)}if(!this.bgTokenizer){this.bgTokenizer=new h(n);var i=this;this.bgTokenizer.addEventListener("update",function(e){i._signal("tokenizerUpdate",e)})}else this.bgTokenizer.setTokenizer(n);this.bgTokenizer.setDocument(this.getDocument()),this.tokenRe=e.tokenRe,this.nonTokenRe=e.nonTokenRe,t||(e.attachToSession&&e.attachToSession(this),this.$options.wrapMethod.set.call(this,this.$wrapMethod),this.$setFolding(e.foldingRules),this.bgTokenizer.start(0),this._emit("changeMode"))},this.$stopWorker=function(){this.$worker&&(this.$worker.terminate(),this.$worker=null)},this.$startWorker=function(){try{this.$worker=this.$mode.createWorker(this)}catch(e){o.warn("Could not load worker",e),this.$worker=null}},this.getMode=function(){return this.$mode},this.$scrollTop=0,this.setScrollTop=function(e){if(this.$scrollTop===e||isNaN(e))return;this.$scrollTop=e,this._signal("changeScrollTop",e)},this.getScrollTop=function(){return this.$scrollTop},this.$scrollLeft=0,this.setScrollLeft=function(e){if(this.$scrollLeft===e||isNaN(e))return;this.$scrollLeft=e,this._signal("changeScrollLeft",e)},this.getScrollLeft=function(){return this.$scrollLeft},this.getScreenWidth=function(){return this.$computeWidth(),this.lineWidgets?Math.max(this.getLineWidgetMaxWidth(),this.screenWidth):this.screenWidth},this.getLineWidgetMaxWidth=function(){if(this.lineWidgetsWidth!=null)return this.lineWidgetsWidth;var e=0;return this.lineWidgets.forEach(function(t){t&&t.screenWidth>e&&(e=t.screenWidth)}),this.lineWidgetWidth=e},this.$computeWidth=function(e){if(this.$modified||e){this.$modified=!1;if(this.$useWrapMode)return this.screenWidth=this.$wrapLimit;var t=this.doc.getAllLines(),n=this.$rowLengthCache,r=0,i=0,s=this.$foldData[i],o=s?s.start.row:Infinity,u=t.length;for(var a=0;a<u;a++){if(a>o){a=s.end.row+1;if(a>=u)break;s=this.$foldData[i++],o=s?s.start.row:Infinity}n[a]==null&&(n[a]=this.$getStringScreenWidth(t[a])[0]),n[a]>r&&(r=n[a])}this.screenWidth=r}},this.getLine=function(e){return this.doc.getLine(e)},this.getLines=function(e,t){return this.doc.getLines(e,t)},this.getLength=function(){return this.doc.getLength()},this.getTextRange=function(e){return this.doc.getTextRange(e||this.selection.getRange())},this.insert=function(e,t){return this.doc.insert(e,t)},this.remove=function(e){return this.doc.remove(e)},this.removeFullLines=function(e,t){return this.doc.removeFullLines(e,t)},this.undoChanges=function(e,t){if(!e.length)return;this.$fromUndo=!0;for(var n=e.length-1;n!=-1;n--){var r=e[n];r.action=="insert"||r.action=="remove"?this.doc.revertDelta(r):r.folds&&this.addFolds(r.folds)}!t&&this.$undoSelect&&(e.selectionBefore?this.selection.fromJSON(e.selectionBefore):this.selection.setRange(this.$getUndoSelection(e,!0))),this.$fromUndo=!1},this.redoChanges=function(e,t){if(!e.length)return;this.$fromUndo=!0;for(var n=0;n<e.length;n++){var r=e[n];(r.action=="insert"||r.action=="remove")&&this.doc.applyDelta(r)}!t&&this.$undoSelect&&(e.selectionAfter?this.selection.fromJSON(e.selectionAfter):this.selection.setRange(this.$getUndoSelection(e,!1))),this.$fromUndo=!1},this.setUndoSelect=function(e){this.$undoSelect=e},this.$getUndoSelection=function(e,t){function n(e){return t?e.action!=="insert":e.action==="insert"}var r,i,s;for(var o=0;o<e.length;o++){var u=e[o];if(!u.start)continue;if(!r){n(u)?(r=l.fromPoints(u.start,u.end),s=!0):(r=l.fromPoints(u.start,u.start),s=!1);continue}n(u)?(i=u.start,r.compare(i.row,i.column)==-1&&r.setStart(i),i=u.end,r.compare(i.row,i.column)==1&&r.setEnd(i),s=!0):(i=u.start,r.compare(i.row,i.column)==-1&&(r=l.fromPoints(u.start,u.start)),s=!1)}return r},this.replace=function(e,t){return this.doc.replace(e,t)},this.moveText=function(e,t,n){var r=this.getTextRange(e),i=this.getFoldsInRange(e),s=l.fromPoints(t,t);if(!n){this.remove(e);var o=e.start.row-e.end.row,u=o?-e.end.column:e.start.column-e.end.column;u&&(s.start.row==e.end.row&&s.start.column>e.end.column&&(s.start.column+=u),s.end.row==e.end.row&&s.end.column>e.end.column&&(s.end.column+=u)),o&&s.start.row>=e.end.row&&(s.start.row+=o,s.end.row+=o)}s.end=this.insert(s.start,r);if(i.length){var a=e.start,f=s.start,o=f.row-a.row,u=f.column-a.column;this.addFolds(i.map(function(e){return e=e.clone(),e.start.row==a.row&&(e.start.column+=u),e.end.row==a.row&&(e.end.column+=u),e.start.row+=o,e.end.row+=o,e}))}return s},this.indentRows=function(e,t,n){n=n.replace(/\t/g,this.getTabString());for(var r=e;r<=t;r++)this.doc.insertInLine({row:r,column:0},n)},this.outdentRows=function(e){var t=e.collapseRows(),n=new l(0,0,0,0),r=this.getTabSize();for(var i=t.start.row;i<=t.end.row;++i){var s=this.getLine(i);n.start.row=i,n.end.row=i;for(var o=0;o<r;++o)if(s.charAt(o)!=" ")break;o<r&&s.charAt(o)=="	"?(n.start.column=o,n.end.column=o+1):(n.start.column=0,n.end.column=o),this.remove(n)}},this.$moveLines=function(e,t,n){e=this.getRowFoldStart(e),t=this.getRowFoldEnd(t);if(n<0){var r=this.getRowFoldStart(e+n);if(r<0)return 0;var i=r-e}else if(n>0){var r=this.getRowFoldEnd(t+n);if(r>this.doc.getLength()-1)return 0;var i=r-t}else{e=this.$clipRowToDocument(e),t=this.$clipRowToDocument(t);var i=t-e+1}var s=new l(e,0,t,Number.MAX_VALUE),o=this.getFoldsInRange(s).map(function(e){return e=e.clone(),e.start.row+=i,e.end.row+=i,e}),u=n==0?this.doc.getLines(e,t):this.doc.removeFullLines(e,t);return this.doc.insertFullLines(e+i,u),o.length&&this.addFolds(o),i},this.moveLinesUp=function(e,t){return this.$moveLines(e,t,-1)},this.moveLinesDown=function(e,t){return this.$moveLines(e,t,1)},this.duplicateLines=function(e,t){return this.$moveLines(e,t,0)},this.$clipRowToDocument=function(e){return Math.max(0,Math.min(e,this.doc.getLength()-1))},this.$clipColumnToRow=function(e,t){return t<0?0:Math.min(this.doc.getLine(e).length,t)},this.$clipPositionToDocument=function(e,t){t=Math.max(0,t);if(e<0)e=0,t=0;else{var n=this.doc.getLength();e>=n?(e=n-1,t=this.doc.getLine(n-1).length):t=Math.min(this.doc.getLine(e).length,t)}return{row:e,column:t}},this.$clipRangeToDocument=function(e){e.start.row<0?(e.start.row=0,e.start.column=0):e.start.column=this.$clipColumnToRow(e.start.row,e.start.column);var t=this.doc.getLength()-1;return e.end.row>t?(e.end.row=t,e.end.column=this.doc.getLine(t).length):e.end.column=this.$clipColumnToRow(e.end.row,e.end.column),e},this.$wrapLimit=80,this.$useWrapMode=!1,this.$wrapLimitRange={min:null,max:null},this.setUseWrapMode=function(e){if(e!=this.$useWrapMode){this.$useWrapMode=e,this.$modified=!0,this.$resetRowCache(0);if(e){var t=this.getLength();this.$wrapData=Array(t),this.$updateWrapData(0,t-1)}this._signal("changeWrapMode")}},this.getUseWrapMode=function(){return this.$useWrapMode},this.setWrapLimitRange=function(e,t){if(this.$wrapLimitRange.min!==e||this.$wrapLimitRange.max!==t)this.$wrapLimitRange={min:e,max:t},this.$modified=!0,this.$bidiHandler.markAsDirty(),this.$useWrapMode&&this._signal("changeWrapMode")},this.adjustWrapLimit=function(e,t){var n=this.$wrapLimitRange;n.max<0&&(n={min:t,max:t});var r=this.$constrainWrapLimit(e,n.min,n.max);return r!=this.$wrapLimit&&r>1?(this.$wrapLimit=r,this.$modified=!0,this.$useWrapMode&&(this.$updateWrapData(0,this.getLength()-1),this.$resetRowCache(0),this._signal("changeWrapLimit")),!0):!1},this.$constrainWrapLimit=function(e,t,n){return t&&(e=Math.max(t,e)),n&&(e=Math.min(n,e)),e},this.getWrapLimit=function(){return this.$wrapLimit},this.setWrapLimit=function(e){this.setWrapLimitRange(e,e)},this.getWrapLimitRange=function(){return{min:this.$wrapLimitRange.min,max:this.$wrapLimitRange.max}},this.$updateInternalDataOnChange=function(e){var t=this.$useWrapMode,n=e.action,r=e.start,i=e.end,s=r.row,o=i.row,u=o-s,a=null;this.$updating=!0;if(u!=0)if(n==="remove"){this[t?"$wrapData":"$rowLengthCache"].splice(s,u);var f=this.$foldData;a=this.getFoldsInRange(e),this.removeFolds(a);var l=this.getFoldLine(i.row),c=0;if(l){l.addRemoveChars(i.row,i.column,r.column-i.column),l.shiftRow(-u);var h=this.getFoldLine(s);h&&h!==l&&(h.merge(l),l=h),c=f.indexOf(l)+1}for(c;c<f.length;c++){var l=f[c];l.start.row>=i.row&&l.shiftRow(-u)}o=s}else{var p=Array(u);p.unshift(s,0);var d=t?this.$wrapData:this.$rowLengthCache;d.splice.apply(d,p);var f=this.$foldData,l=this.getFoldLine(s),c=0;if(l){var v=l.range.compareInside(r.row,r.column);v==0?(l=l.split(r.row,r.column),l&&(l.shiftRow(u),l.addRemoveChars(o,0,i.column-r.column))):v==-1&&(l.addRemoveChars(s,0,i.column-r.column),l.shiftRow(u)),c=f.indexOf(l)+1}for(c;c<f.length;c++){var l=f[c];l.start.row>=s&&l.shiftRow(u)}}else{u=Math.abs(e.start.column-e.end.column),n==="remove"&&(a=this.getFoldsInRange(e),this.removeFolds(a),u=-u);var l=this.getFoldLine(s);l&&l.addRemoveChars(s,r.column,u)}return t&&this.$wrapData.length!=this.doc.getLength()&&console.error("doc.getLength() and $wrapData.length have to be the same!"),this.$updating=!1,t?this.$updateWrapData(s,o):this.$updateRowLengthCache(s,o),a},this.$updateRowLengthCache=function(e,t,n){this.$rowLengthCache[e]=null,this.$rowLengthCache[t]=null},this.$updateWrapData=function(e,t){var r=this.doc.getAllLines(),i=this.getTabSize(),o=this.$wrapData,u=this.$wrapLimit,a,f,l=e;t=Math.min(t,r.length-1);while(l<=t)f=this.getFoldLine(l,f),f?(a=[],f.walk(function(e,t,i,o){var u;if(e!=null){u=this.$getDisplayTokens(e,a.length),u[0]=n;for(var f=1;f<u.length;f++)u[f]=s}else u=this.$getDisplayTokens(r[t].substring(o,i),a.length);a=a.concat(u)}.bind(this),f.end.row,r[f.end.row].length+1),o[f.start.row]=this.$computeWrapSplits(a,u,i),l=f.end.row+1):(a=this.$getDisplayTokens(r[l]),o[l]=this.$computeWrapSplits(a,u,i),l++)};var e=1,t=2,n=3,s=4,a=9,c=10,d=11,v=12;this.$computeWrapSplits=function(e,r,i){function g(){var t=0;if(m===0)return t;if(p)for(var n=0;n<e.length;n++){var r=e[n];if(r==c)t+=1;else{if(r!=d){if(r==v)continue;break}t+=i}}return h&&p!==!1&&(t+=i),Math.min(t,m)}function y(t){var n=t-f;for(var r=f;r<t;r++){var i=e[r];if(i===12||i===2)n-=1}o.length||(b=g(),o.indent=b),l+=n,o.push(l),f=t}if(e.length==0)return[];var o=[],u=e.length,f=0,l=0,h=this.$wrapAsCode,p=this.$indentedSoftWrap,m=r<=Math.max(2*i,8)||p===!1?0:Math.floor(r/2),b=0;while(u-f>r-b){var w=f+r-b;if(e[w-1]>=c&&e[w]>=c){y(w);continue}if(e[w]==n||e[w]==s){for(w;w!=f-1;w--)if(e[w]==n)break;if(w>f){y(w);continue}w=f+r;for(w;w<e.length;w++)if(e[w]!=s)break;if(w==e.length)break;y(w);continue}var E=Math.max(w-(r-(r>>2)),f-1);while(w>E&&e[w]<n)w--;if(h){while(w>E&&e[w]<n)w--;while(w>E&&e[w]==a)w--}else while(w>E&&e[w]<c)w--;if(w>E){y(++w);continue}w=f+r,e[w]==t&&w--,y(w-b)}return o},this.$getDisplayTokens=function(n,r){var i=[],s;r=r||0;for(var o=0;o<n.length;o++){var u=n.charCodeAt(o);if(u==9){s=this.getScreenTabSize(i.length+r),i.push(d);for(var f=1;f<s;f++)i.push(v)}else u==32?i.push(c):u>39&&u<48||u>57&&u<64?i.push(a):u>=4352&&m(u)?i.push(e,t):i.push(e)}return i},this.$getStringScreenWidth=function(e,t,n){if(t==0)return[0,0];t==null&&(t=Infinity),n=n||0;var r,i;for(i=0;i<e.length;i++){r=e.charCodeAt(i),r==9?n+=this.getScreenTabSize(n):r>=4352&&m(r)?n+=2:n+=1;if(n>t)break}return[n,i]},this.lineWidgets=null,this.getRowLength=function(e){if(this.lineWidgets)var t=this.lineWidgets[e]&&this.lineWidgets[e].rowCount||0;else t=0;return!this.$useWrapMode||!this.$wrapData[e]?1+t:this.$wrapData[e].length+1+t},this.getRowLineCount=function(e){return!this.$useWrapMode||!this.$wrapData[e]?1:this.$wrapData[e].length+1},this.getRowWrapIndent=function(e){if(this.$useWrapMode){var t=this.screenToDocumentPosition(e,Number.MAX_VALUE),n=this.$wrapData[t.row];return n.length&&n[0]<t.column?n.indent:0}return 0},this.getScreenLastRowColumn=function(e){var t=this.screenToDocumentPosition(e,Number.MAX_VALUE);return this.documentToScreenColumn(t.row,t.column)},this.getDocumentLastRowColumn=function(e,t){var n=this.documentToScreenRow(e,t);return this.getScreenLastRowColumn(n)},this.getDocumentLastRowColumnPosition=function(e,t){var n=this.documentToScreenRow(e,t);return this.screenToDocumentPosition(n,Number.MAX_VALUE/10)},this.getRowSplitData=function(e){return this.$useWrapMode?this.$wrapData[e]:undefined},this.getScreenTabSize=function(e){return this.$tabSize-(e%this.$tabSize|0)},this.screenToDocumentRow=function(e,t){return this.screenToDocumentPosition(e,t).row},this.screenToDocumentColumn=function(e,t){return this.screenToDocumentPosition(e,t).column},this.screenToDocumentPosition=function(e,t,n){if(e<0)return{row:0,column:0};var r,i=0,s=0,o,u=0,a=0,f=this.$screenRowCache,l=this.$getRowCacheIndex(f,e),c=f.length;if(c&&l>=0)var u=f[l],i=this.$docRowCache[l],h=e>f[c-1];else var h=!c;var p=this.getLength()-1,d=this.getNextFoldLine(i),v=d?d.start.row:Infinity;while(u<=e){a=this.getRowLength(i);if(u+a>e||i>=p)break;u+=a,i++,i>v&&(i=d.end.row+1,d=this.getNextFoldLine(i,d),v=d?d.start.row:Infinity),h&&(this.$docRowCache.push(i),this.$screenRowCache.push(u))}if(d&&d.start.row<=i)r=this.getFoldDisplayLine(d),i=d.start.row;else{if(u+a<=e||i>p)return{row:p,column:this.getLine(p).length};r=this.getLine(i),d=null}var m=0,g=Math.floor(e-u);if(this.$useWrapMode){var y=this.$wrapData[i];y&&(o=y[g],g>0&&y.length&&(m=y.indent,s=y[g-1]||y[y.length-1],r=r.substring(s)))}return n!==undefined&&this.$bidiHandler.isBidiRow(u+g,i,g)&&(t=this.$bidiHandler.offsetToCol(n)),s+=this.$getStringScreenWidth(r,t-m)[1],this.$useWrapMode&&s>=o&&(s=o-1),d?d.idxToPosition(s):{row:i,column:s}},this.documentToScreenPosition=function(e,t){if(typeof t=="undefined")var n=this.$clipPositionToDocument(e.row,e.column);else n=this.$clipPositionToDocument(e,t);e=n.row,t=n.column;var r=0,i=null,s=null;s=this.getFoldAt(e,t,1),s&&(e=s.start.row,t=s.start.column);var o,u=0,a=this.$docRowCache,f=this.$getRowCacheIndex(a,e),l=a.length;if(l&&f>=0)var u=a[f],r=this.$screenRowCache[f],c=e>a[l-1];else var c=!l;var h=this.getNextFoldLine(u),p=h?h.start.row:Infinity;while(u<e){if(u>=p){o=h.end.row+1;if(o>e)break;h=this.getNextFoldLine(o,h),p=h?h.start.row:Infinity}else o=u+1;r+=this.getRowLength(u),u=o,c&&(this.$docRowCache.push(u),this.$screenRowCache.push(r))}var d="";h&&u>=p?(d=this.getFoldDisplayLine(h,e,t),i=h.start.row):(d=this.getLine(e).substring(0,t),i=e);var v=0;if(this.$useWrapMode){var m=this.$wrapData[i];if(m){var g=0;while(d.length>=m[g])r++,g++;d=d.substring(m[g-1]||0,d.length),v=g>0?m.indent:0}}return{row:r,column:v+this.$getStringScreenWidth(d)[0]}},this.documentToScreenColumn=function(e,t){return this.documentToScreenPosition(e,t).column},this.documentToScreenRow=function(e,t){return this.documentToScreenPosition(e,t).row},this.getScreenLength=function(){var e=0,t=null;if(!this.$useWrapMode){e=this.getLength();var n=this.$foldData;for(var r=0;r<n.length;r++)t=n[r],e-=t.end.row-t.start.row}else{var i=this.$wrapData.length,s=0,r=0,t=this.$foldData[r++],o=t?t.start.row:Infinity;while(s<i){var u=this.$wrapData[s];e+=u?u.length+1:1,s++,s>o&&(s=t.end.row+1,t=this.$foldData[r++],o=t?t.start.row:Infinity)}}return this.lineWidgets&&(e+=this.$getWidgetScreenLength()),e},this.$setFontMetrics=function(e){if(!this.$enableVarChar)return;this.$getStringScreenWidth=function(t,n,r){if(n===0)return[0,0];n||(n=Infinity),r=r||0;var i,s;for(s=0;s<t.length;s++){i=t.charAt(s),i==="	"?r+=this.getScreenTabSize(r):r+=e.getCharacterWidth(i);if(r>n)break}return[r,s]}},this.destroy=function(){this.bgTokenizer&&(this.bgTokenizer.setDocument(null),this.bgTokenizer=null),this.$stopWorker()},this.isFullWidth=m}.call(d.prototype),e("./edit_session/folding").Folding.call(d.prototype),e("./edit_session/bracket_match").BracketMatch.call(d.prototype),o.defineOptions(d.prototype,"session",{wrap:{set:function(e){!e||e=="off"?e=!1:e=="free"?e=!0:e=="printMargin"?e=-1:typeof e=="string"&&(e=parseInt(e,10)||!1);if(this.$wrap==e)return;this.$wrap=e;if(!e)this.setUseWrapMode(!1);else{var t=typeof e=="number"?e:null;this.setWrapLimitRange(t,t),this.setUseWrapMode(!0)}},get:function(){return this.getUseWrapMode()?this.$wrap==-1?"printMargin":this.getWrapLimitRange().min?this.$wrap:"free":"off"},handlesSet:!0},wrapMethod:{set:function(e){e=e=="auto"?this.$mode.type!="text":e!="text",e!=this.$wrapAsCode&&(this.$wrapAsCode=e,this.$useWrapMode&&(this.$useWrapMode=!1,this.setUseWrapMode(!0)))},initialValue:"auto"},indentedSoftWrap:{set:function(){this.$useWrapMode&&(this.$useWrapMode=!1,this.setUseWrapMode(!0))},initialValue:!0},firstLineNumber:{set:function(){this._signal("changeBreakpoint")},initialValue:1},useWorker:{set:function(e){this.$useWorker=e,this.$stopWorker(),e&&this.$startWorker()},initialValue:!0},useSoftTabs:{initialValue:!0},tabSize:{set:function(e){e=parseInt(e),e>0&&this.$tabSize!==e&&(this.$modified=!0,this.$rowLengthCache=[],this.$tabSize=e,this._signal("changeTabSize"))},initialValue:4,handlesSet:!0},navigateWithinSoftTabs:{initialValue:!1},foldStyle:{set:function(e){this.setFoldStyle(e)},handlesSet:!0},overwrite:{set:function(e){this._signal("changeOverwrite")},initialValue:!1},newLineMode:{set:function(e){this.doc.setNewLineMode(e)},get:function(){return this.doc.getNewLineMode()},handlesSet:!0},mode:{set:function(e){this.setMode(e)},get:function(){return this.$modeId},handlesSet:!0}}),t.EditSession=d}),ace.define("ace/search",["require","exports","module","ace/lib/lang","ace/lib/oop","ace/range"],function(e,t,n){"use strict";function u(e,t){function n(e){return/\w/.test(e)||t.regExp?"\\b":""}return n(e[0])+e+n(e[e.length-1])}var r=e("./lib/lang"),i=e("./lib/oop"),s=e("./range").Range,o=function(){this.$options={}};(function(){this.set=function(e){return i.mixin(this.$options,e),this},this.getOptions=function(){return r.copyObject(this.$options)},this.setOptions=function(e){this.$options=e},this.find=function(e){var t=this.$options,n=this.$matchIterator(e,t);if(!n)return!1;var r=null;return n.forEach(function(e,n,i,o){return r=new s(e,n,i,o),n==o&&t.start&&t.start.start&&t.skipCurrent!=0&&r.isEqual(t.start)?(r=null,!1):!0}),r},this.findAll=function(e){var t=this.$options;if(!t.needle)return[];this.$assembleRegExp(t);var n=t.range,i=n?e.getLines(n.start.row,n.end.row):e.doc.getAllLines(),o=[],u=t.re;if(t.$isMultiLine){var a=u.length,f=i.length-a,l;e:for(var c=u.offset||0;c<=f;c++){for(var h=0;h<a;h++)if(i[c+h].search(u[h])==-1)continue e;var p=i[c],d=i[c+a-1],v=p.length-p.match(u[0])[0].length,m=d.match(u[a-1])[0].length;if(l&&l.end.row===c&&l.end.column>v)continue;o.push(l=new s(c,v,c+a-1,m)),a>2&&(c=c+a-2)}}else for(var g=0;g<i.length;g++){var y=r.getMatchOffsets(i[g],u);for(var h=0;h<y.length;h++){var b=y[h];o.push(new s(g,b.offset,g,b.offset+b.length))}}if(n){var w=n.start.column,E=n.start.column,g=0,h=o.length-1;while(g<h&&o[g].start.column<w&&o[g].start.row==n.start.row)g++;while(g<h&&o[h].end.column>E&&o[h].end.row==n.end.row)h--;o=o.slice(g,h+1);for(g=0,h=o.length;g<h;g++)o[g].start.row+=n.start.row,o[g].end.row+=n.start.row}return o},this.replace=function(e,t){var n=this.$options,r=this.$assembleRegExp(n);if(n.$isMultiLine)return t;if(!r)return;var i=r.exec(e);if(!i||i[0].length!=e.length)return null;t=e.replace(r,t);if(n.preserveCase){t=t.split("");for(var s=Math.min(e.length,e.length);s--;){var o=e[s];o&&o.toLowerCase()!=o?t[s]=t[s].toUpperCase():t[s]=t[s].toLowerCase()}t=t.join("")}return t},this.$assembleRegExp=function(e,t){if(e.needle instanceof RegExp)return e.re=e.needle;var n=e.needle;if(!e.needle)return e.re=!1;e.regExp||(n=r.escapeRegExp(n)),e.wholeWord&&(n=u(n,e));var i=e.caseSensitive?"gm":"gmi";e.$isMultiLine=!t&&/[\n\r]/.test(n);if(e.$isMultiLine)return e.re=this.$assembleMultilineRegExp(n,i);try{var s=new RegExp(n,i)}catch(o){s=!1}return e.re=s},this.$assembleMultilineRegExp=function(e,t){var n=e.replace(/\r\n|\r|\n/g,"$\n^").split("\n"),r=[];for(var i=0;i<n.length;i++)try{r.push(new RegExp(n[i],t))}catch(s){return!1}return r},this.$matchIterator=function(e,t){var n=this.$assembleRegExp(t);if(!n)return!1;var r=t.backwards==1,i=t.skipCurrent!=0,s=t.range,o=t.start;o||(o=s?s[r?"end":"start"]:e.selection.getRange()),o.start&&(o=o[i!=r?"end":"start"]);var u=s?s.start.row:0,a=s?s.end.row:e.getLength()-1;if(r)var f=function(e){var n=o.row;if(c(n,o.column,e))return;for(n--;n>=u;n--)if(c(n,Number.MAX_VALUE,e))return;if(t.wrap==0)return;for(n=a,u=o.row;n>=u;n--)if(c(n,Number.MAX_VALUE,e))return};else var f=function(e){var n=o.row;if(c(n,o.column,e))return;for(n+=1;n<=a;n++)if(c(n,0,e))return;if(t.wrap==0)return;for(n=u,a=o.row;n<=a;n++)if(c(n,0,e))return};if(t.$isMultiLine)var l=n.length,c=function(t,i,s){var o=r?t-l+1:t;if(o<0)return;var u=e.getLine(o),a=u.search(n[0]);if(!r&&a<i||a===-1)return;for(var f=1;f<l;f++){u=e.getLine(o+f);if(u.search(n[f])==-1)return}var c=u.match(n[l-1])[0].length;if(r&&c>i)return;if(s(o,a,o+l-1,c))return!0};else if(r)var c=function(t,r,i){var s=e.getLine(t),o=[],u,a=0;n.lastIndex=0;while(u=n.exec(s)){var f=u[0].length;a=u.index;if(!f){if(a>=s.length)break;n.lastIndex=a+=1}if(u.index+f>r)break;o.push(u.index,f)}for(var l=o.length-1;l>=0;l-=2){var c=o[l-1],f=o[l];if(i(t,c,t,c+f))return!0}};else var c=function(t,r,i){var s=e.getLine(t),o,u;n.lastIndex=r;while(u=n.exec(s)){var a=u[0].length;o=u.index;if(i(t,o,t,o+a))return!0;if(!a){n.lastIndex=o+=1;if(o>=s.length)return!1}}};return{forEach:f}}}).call(o.prototype),t.Search=o}),ace.define("ace/keyboard/hash_handler",["require","exports","module","ace/lib/keys","ace/lib/useragent"],function(e,t,n){"use strict";function o(e,t){this.platform=t||(i.isMac?"mac":"win"),this.commands={},this.commandKeyBinding={},this.addCommands(e),this.$singleCommand=!0}function u(e,t){o.call(this,e,t),this.$singleCommand=!1}var r=e("../lib/keys"),i=e("../lib/useragent"),s=r.KEY_MODS;u.prototype=o.prototype,function(){function e(e){return typeof e=="object"&&e.bindKey&&e.bindKey.position||(e.isDefault?-100:0)}this.addCommand=function(e){this.commands[e.name]&&this.removeCommand(e),this.commands[e.name]=e,e.bindKey&&this._buildKeyHash(e)},this.removeCommand=function(e,t){var n=e&&(typeof e=="string"?e:e.name);e=this.commands[n],t||delete this.commands[n];var r=this.commandKeyBinding;for(var i in r){var s=r[i];if(s==e)delete r[i];else if(Array.isArray(s)){var o=s.indexOf(e);o!=-1&&(s.splice(o,1),s.length==1&&(r[i]=s[0]))}}},this.bindKey=function(e,t,n){typeof e=="object"&&e&&(n==undefined&&(n=e.position),e=e[this.platform]);if(!e)return;if(typeof t=="function")return this.addCommand({exec:t,bindKey:e,name:t.name||e});e.split("|").forEach(function(e){var r="";if(e.indexOf(" ")!=-1){var i=e.split(/\s+/);e=i.pop(),i.forEach(function(e){var t=this.parseKeys(e),n=s[t.hashId]+t.key;r+=(r?" ":"")+n,this._addCommandToBinding(r,"chainKeys")},this),r+=" "}var o=this.parseKeys(e),u=s[o.hashId]+o.key;this._addCommandToBinding(r+u,t,n)},this)},this._addCommandToBinding=function(t,n,r){var i=this.commandKeyBinding,s;if(!n)delete i[t];else if(!i[t]||this.$singleCommand)i[t]=n;else{Array.isArray(i[t])?(s=i[t].indexOf(n))!=-1&&i[t].splice(s,1):i[t]=[i[t]],typeof r!="number"&&(r=e(n));var o=i[t];for(s=0;s<o.length;s++){var u=o[s],a=e(u);if(a>r)break}o.splice(s,0,n)}},this.addCommands=function(e){e&&Object.keys(e).forEach(function(t){var n=e[t];if(!n)return;if(typeof n=="string")return this.bindKey(n,t);typeof n=="function"&&(n={exec:n});if(typeof n!="object")return;n.name||(n.name=t),this.addCommand(n)},this)},this.removeCommands=function(e){Object.keys(e).forEach(function(t){this.removeCommand(e[t])},this)},this.bindKeys=function(e){Object.keys(e).forEach(function(t){this.bindKey(t,e[t])},this)},this._buildKeyHash=function(e){this.bindKey(e.bindKey,e)},this.parseKeys=function(e){var t=e.toLowerCase().split(/[\-\+]([\-\+])?/).filter(function(e){return e}),n=t.pop(),i=r[n];if(r.FUNCTION_KEYS[i])n=r.FUNCTION_KEYS[i].toLowerCase();else{if(!t.length)return{key:n,hashId:-1};if(t.length==1&&t[0]=="shift")return{key:n.toUpperCase(),hashId:-1}}var s=0;for(var o=t.length;o--;){var u=r.KEY_MODS[t[o]];if(u==null)return typeof console!="undefined"&&console.error("invalid modifier "+t[o]+" in "+e),!1;s|=u}return{key:n,hashId:s}},this.findKeyCommand=function(t,n){var r=s[t]+n;return this.commandKeyBinding[r]},this.handleKeyboard=function(e,t,n,r){if(r<0)return;var i=s[t]+n,o=this.commandKeyBinding[i];e.$keyChain&&(e.$keyChain+=" "+i,o=this.commandKeyBinding[e.$keyChain]||o);if(o)if(o=="chainKeys"||o[o.length-1]=="chainKeys")return e.$keyChain=e.$keyChain||i,{command:"null"};if(e.$keyChain)if(!!t&&t!=4||n.length!=1){if(t==-1||r>0)e.$keyChain=""}else e.$keyChain=e.$keyChain.slice(0,-i.length-1);return{command:o}},this.getStatusText=function(e,t){return t.$keyChain||""}}.call(o.prototype),t.HashHandler=o,t.MultiHashHandler=u}),ace.define("ace/commands/command_manager",["require","exports","module","ace/lib/oop","ace/keyboard/hash_handler","ace/lib/event_emitter"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("../keyboard/hash_handler").MultiHashHandler,s=e("../lib/event_emitter").EventEmitter,o=function(e,t){i.call(this,t,e),this.byName=this.commands,this.setDefaultHandler("exec",function(e){return e.command.exec(e.editor,e.args||{})})};r.inherits(o,i),function(){r.implement(this,s),this.exec=function(e,t,n){if(Array.isArray(e)){for(var r=e.length;r--;)if(this.exec(e[r],t,n))return!0;return!1}typeof e=="string"&&(e=this.commands[e]);if(!e)return!1;if(t&&t.$readOnly&&!e.readOnly)return!1;if(this.$checkCommandState!=0&&e.isAvailable&&!e.isAvailable(t))return!1;var i={editor:t,command:e,args:n};return i.returnValue=this._emit("exec",i),this._signal("afterExec",i),i.returnValue===!1?!1:!0},this.toggleRecording=function(e){if(this.$inReplay)return;return e&&e._emit("changeStatus"),this.recording?(this.macro.pop(),this.removeEventListener("exec",this.$addCommandToMacro),this.macro.length||(this.macro=this.oldMacro),this.recording=!1):(this.$addCommandToMacro||(this.$addCommandToMacro=function(e){this.macro.push([e.command,e.args])}.bind(this)),this.oldMacro=this.macro,this.macro=[],this.on("exec",this.$addCommandToMacro),this.recording=!0)},this.replay=function(e){if(this.$inReplay||!this.macro)return;if(this.recording)return this.toggleRecording(e);try{this.$inReplay=!0,this.macro.forEach(function(t){typeof t=="string"?this.exec(t,e):this.exec(t[0],e,t[1])},this)}finally{this.$inReplay=!1}},this.trimMacro=function(e){return e.map(function(e){return typeof e[0]!="string"&&(e[0]=e[0].name),e[1]||(e=e[0]),e})}}.call(o.prototype),t.CommandManager=o}),ace.define("ace/commands/default_commands",["require","exports","module","ace/lib/lang","ace/config","ace/range"],function(e,t,n){"use strict";function o(e,t){return{win:e,mac:t}}var r=e("../lib/lang"),i=e("../config"),s=e("../range").Range;t.commands=[{name:"showSettingsMenu",bindKey:o("Ctrl-,","Command-,"),exec:function(e){i.loadModule("ace/ext/settings_menu",function(t){t.init(e),e.showSettingsMenu()})},readOnly:!0},{name:"goToNextError",bindKey:o("Alt-E","F4"),exec:function(e){i.loadModule("./ext/error_marker",function(t){t.showErrorMarker(e,1)})},scrollIntoView:"animate",readOnly:!0},{name:"goToPreviousError",bindKey:o("Alt-Shift-E","Shift-F4"),exec:function(e){i.loadModule("./ext/error_marker",function(t){t.showErrorMarker(e,-1)})},scrollIntoView:"animate",readOnly:!0},{name:"selectall",description:"Select all",bindKey:o("Ctrl-A","Command-A"),exec:function(e){e.selectAll()},readOnly:!0},{name:"centerselection",description:"Center selection",bindKey:o(null,"Ctrl-L"),exec:function(e){e.centerSelection()},readOnly:!0},{name:"gotoline",description:"Go to line...",bindKey:o("Ctrl-L","Command-L"),exec:function(e,t){typeof t=="number"&&!isNaN(t)&&e.gotoLine(t),e.prompt({$type:"gotoLine"})},readOnly:!0},{name:"fold",bindKey:o("Alt-L|Ctrl-F1","Command-Alt-L|Command-F1"),exec:function(e){e.session.toggleFold(!1)},multiSelectAction:"forEach",scrollIntoView:"center",readOnly:!0},{name:"unfold",bindKey:o("Alt-Shift-L|Ctrl-Shift-F1","Command-Alt-Shift-L|Command-Shift-F1"),exec:function(e){e.session.toggleFold(!0)},multiSelectAction:"forEach",scrollIntoView:"center",readOnly:!0},{name:"toggleFoldWidget",bindKey:o("F2","F2"),exec:function(e){e.session.toggleFoldWidget()},multiSelectAction:"forEach",scrollIntoView:"center",readOnly:!0},{name:"toggleParentFoldWidget",bindKey:o("Alt-F2","Alt-F2"),exec:function(e){e.session.toggleFoldWidget(!0)},multiSelectAction:"forEach",scrollIntoView:"center",readOnly:!0},{name:"foldall",description:"Fold all",bindKey:o(null,"Ctrl-Command-Option-0"),exec:function(e){e.session.foldAll()},scrollIntoView:"center",readOnly:!0},{name:"foldOther",description:"Fold other",bindKey:o("Alt-0","Command-Option-0"),exec:function(e){e.session.foldAll(),e.session.unfold(e.selection.getAllRanges())},scrollIntoView:"center",readOnly:!0},{name:"unfoldall",description:"Unfold all",bindKey:o("Alt-Shift-0","Command-Option-Shift-0"),exec:function(e){e.session.unfold()},scrollIntoView:"center",readOnly:!0},{name:"findnext",description:"Find next",bindKey:o("Ctrl-K","Command-G"),exec:function(e){e.findNext()},multiSelectAction:"forEach",scrollIntoView:"center",readOnly:!0},{name:"findprevious",description:"Find previous",bindKey:o("Ctrl-Shift-K","Command-Shift-G"),exec:function(e){e.findPrevious()},multiSelectAction:"forEach",scrollIntoView:"center",readOnly:!0},{name:"selectOrFindNext",description:"Select or find next",bindKey:o("Alt-K","Ctrl-G"),exec:function(e){e.selection.isEmpty()?e.selection.selectWord():e.findNext()},readOnly:!0},{name:"selectOrFindPrevious",description:"Select or find previous",bindKey:o("Alt-Shift-K","Ctrl-Shift-G"),exec:function(e){e.selection.isEmpty()?e.selection.selectWord():e.findPrevious()},readOnly:!0},{name:"find",description:"Find",bindKey:o("Ctrl-F","Command-F"),exec:function(e){i.loadModule("ace/ext/searchbox",function(t){t.Search(e)})},readOnly:!0},{name:"overwrite",description:"Overwrite",bindKey:"Insert",exec:function(e){e.toggleOverwrite()},readOnly:!0},{name:"selecttostart",description:"Select to start",bindKey:o("Ctrl-Shift-Home","Command-Shift-Home|Command-Shift-Up"),exec:function(e){e.getSelection().selectFileStart()},multiSelectAction:"forEach",readOnly:!0,scrollIntoView:"animate",aceCommandGroup:"fileJump"},{name:"gotostart",description:"Go to start",bindKey:o("Ctrl-Home","Command-Home|Command-Up"),exec:function(e){e.navigateFileStart()},multiSelectAction:"forEach",readOnly:!0,scrollIntoView:"animate",aceCommandGroup:"fileJump"},{name:"selectup",description:"Select up",bindKey:o("Shift-Up","Shift-Up|Ctrl-Shift-P"),exec:function(e){e.getSelection().selectUp()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"golineup",description:"Go line up",bindKey:o("Up","Up|Ctrl-P"),exec:function(e,t){e.navigateUp(t.times)},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selecttoend",description:"Select to end",bindKey:o("Ctrl-Shift-End","Command-Shift-End|Command-Shift-Down"),exec:function(e){e.getSelection().selectFileEnd()},multiSelectAction:"forEach",readOnly:!0,scrollIntoView:"animate",aceCommandGroup:"fileJump"},{name:"gotoend",description:"Go to end",bindKey:o("Ctrl-End","Command-End|Command-Down"),exec:function(e){e.navigateFileEnd()},multiSelectAction:"forEach",readOnly:!0,scrollIntoView:"animate",aceCommandGroup:"fileJump"},{name:"selectdown",description:"Select down",bindKey:o("Shift-Down","Shift-Down|Ctrl-Shift-N"),exec:function(e){e.getSelection().selectDown()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"golinedown",description:"Go line down",bindKey:o("Down","Down|Ctrl-N"),exec:function(e,t){e.navigateDown(t.times)},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selectwordleft",description:"Select word left",bindKey:o("Ctrl-Shift-Left","Option-Shift-Left"),exec:function(e){e.getSelection().selectWordLeft()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"gotowordleft",description:"Go to word left",bindKey:o("Ctrl-Left","Option-Left"),exec:function(e){e.navigateWordLeft()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selecttolinestart",description:"Select to line start",bindKey:o("Alt-Shift-Left","Command-Shift-Left|Ctrl-Shift-A"),exec:function(e){e.getSelection().selectLineStart()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"gotolinestart",description:"Go to line start",bindKey:o("Alt-Left|Home","Command-Left|Home|Ctrl-A"),exec:function(e){e.navigateLineStart()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selectleft",description:"Select left",bindKey:o("Shift-Left","Shift-Left|Ctrl-Shift-B"),exec:function(e){e.getSelection().selectLeft()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"gotoleft",description:"Go to left",bindKey:o("Left","Left|Ctrl-B"),exec:function(e,t){e.navigateLeft(t.times)},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selectwordright",description:"Select word right",bindKey:o("Ctrl-Shift-Right","Option-Shift-Right"),exec:function(e){e.getSelection().selectWordRight()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"gotowordright",description:"Go to word right",bindKey:o("Ctrl-Right","Option-Right"),exec:function(e){e.navigateWordRight()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selecttolineend",description:"Select to line end",bindKey:o("Alt-Shift-Right","Command-Shift-Right|Shift-End|Ctrl-Shift-E"),exec:function(e){e.getSelection().selectLineEnd()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"gotolineend",description:"Go to line end",bindKey:o("Alt-Right|End","Command-Right|End|Ctrl-E"),exec:function(e){e.navigateLineEnd()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selectright",description:"Select right",bindKey:o("Shift-Right","Shift-Right"),exec:function(e){e.getSelection().selectRight()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"gotoright",description:"Go to right",bindKey:o("Right","Right|Ctrl-F"),exec:function(e,t){e.navigateRight(t.times)},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selectpagedown",description:"Select page down",bindKey:"Shift-PageDown",exec:function(e){e.selectPageDown()},readOnly:!0},{name:"pagedown",description:"Page down",bindKey:o(null,"Option-PageDown"),exec:function(e){e.scrollPageDown()},readOnly:!0},{name:"gotopagedown",description:"Go to page down",bindKey:o("PageDown","PageDown|Ctrl-V"),exec:function(e){e.gotoPageDown()},readOnly:!0},{name:"selectpageup",description:"Select page up",bindKey:"Shift-PageUp",exec:function(e){e.selectPageUp()},readOnly:!0},{name:"pageup",description:"Page up",bindKey:o(null,"Option-PageUp"),exec:function(e){e.scrollPageUp()},readOnly:!0},{name:"gotopageup",description:"Go to page up",bindKey:"PageUp",exec:function(e){e.gotoPageUp()},readOnly:!0},{name:"scrollup",description:"Scroll up",bindKey:o("Ctrl-Up",null),exec:function(e){e.renderer.scrollBy(0,-2*e.renderer.layerConfig.lineHeight)},readOnly:!0},{name:"scrolldown",description:"Scroll down",bindKey:o("Ctrl-Down",null),exec:function(e){e.renderer.scrollBy(0,2*e.renderer.layerConfig.lineHeight)},readOnly:!0},{name:"selectlinestart",description:"Select line start",bindKey:"Shift-Home",exec:function(e){e.getSelection().selectLineStart()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"selectlineend",description:"Select line end",bindKey:"Shift-End",exec:function(e){e.getSelection().selectLineEnd()},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"togglerecording",description:"Toggle recording",bindKey:o("Ctrl-Alt-E","Command-Option-E"),exec:function(e){e.commands.toggleRecording(e)},readOnly:!0},{name:"replaymacro",description:"Replay macro",bindKey:o("Ctrl-Shift-E","Command-Shift-E"),exec:function(e){e.commands.replay(e)},readOnly:!0},{name:"jumptomatching",description:"Jump to matching",bindKey:o("Ctrl-\\|Ctrl-P","Command-\\"),exec:function(e){e.jumpToMatching()},multiSelectAction:"forEach",scrollIntoView:"animate",readOnly:!0},{name:"selecttomatching",description:"Select to matching",bindKey:o("Ctrl-Shift-\\|Ctrl-Shift-P","Command-Shift-\\"),exec:function(e){e.jumpToMatching(!0)},multiSelectAction:"forEach",scrollIntoView:"animate",readOnly:!0},{name:"expandToMatching",description:"Expand to matching",bindKey:o("Ctrl-Shift-M","Ctrl-Shift-M"),exec:function(e){e.jumpToMatching(!0,!0)},multiSelectAction:"forEach",scrollIntoView:"animate",readOnly:!0},{name:"passKeysToBrowser",description:"Pass keys to browser",bindKey:o(null,null),exec:function(){},passEvent:!0,readOnly:!0},{name:"copy",description:"Copy",exec:function(e){},readOnly:!0},{name:"cut",description:"Cut",exec:function(e){var t=e.$copyWithEmptySelection&&e.selection.isEmpty(),n=t?e.selection.getLineRange():e.selection.getRange();e._emit("cut",n),n.isEmpty()||e.session.remove(n),e.clearSelection()},scrollIntoView:"cursor",multiSelectAction:"forEach"},{name:"paste",description:"Paste",exec:function(e,t){e.$handlePaste(t)},scrollIntoView:"cursor"},{name:"removeline",description:"Remove line",bindKey:o("Ctrl-D","Command-D"),exec:function(e){e.removeLines()},scrollIntoView:"cursor",multiSelectAction:"forEachLine"},{name:"duplicateSelection",description:"Duplicate selection",bindKey:o("Ctrl-Shift-D","Command-Shift-D"),exec:function(e){e.duplicateSelection()},scrollIntoView:"cursor",multiSelectAction:"forEach"},{name:"sortlines",description:"Sort lines",bindKey:o("Ctrl-Alt-S","Command-Alt-S"),exec:function(e){e.sortLines()},scrollIntoView:"selection",multiSelectAction:"forEachLine"},{name:"togglecomment",description:"Toggle comment",bindKey:o("Ctrl-/","Command-/"),exec:function(e){e.toggleCommentLines()},multiSelectAction:"forEachLine",scrollIntoView:"selectionPart"},{name:"toggleBlockComment",description:"Toggle block comment",bindKey:o("Ctrl-Shift-/","Command-Shift-/"),exec:function(e){e.toggleBlockComment()},multiSelectAction:"forEach",scrollIntoView:"selectionPart"},{name:"modifyNumberUp",description:"Modify number up",bindKey:o("Ctrl-Shift-Up","Alt-Shift-Up"),exec:function(e){e.modifyNumber(1)},scrollIntoView:"cursor",multiSelectAction:"forEach"},{name:"modifyNumberDown",description:"Modify number down",bindKey:o("Ctrl-Shift-Down","Alt-Shift-Down"),exec:function(e){e.modifyNumber(-1)},scrollIntoView:"cursor",multiSelectAction:"forEach"},{name:"replace",description:"Replace",bindKey:o("Ctrl-H","Command-Option-F"),exec:function(e){i.loadModule("ace/ext/searchbox",function(t){t.Search(e,!0)})}},{name:"undo",description:"Undo",bindKey:o("Ctrl-Z","Command-Z"),exec:function(e){e.undo()}},{name:"redo",description:"Redo",bindKey:o("Ctrl-Shift-Z|Ctrl-Y","Command-Shift-Z|Command-Y"),exec:function(e){e.redo()}},{name:"copylinesup",description:"Copy lines up",bindKey:o("Alt-Shift-Up","Command-Option-Up"),exec:function(e){e.copyLinesUp()},scrollIntoView:"cursor"},{name:"movelinesup",description:"Move lines up",bindKey:o("Alt-Up","Option-Up"),exec:function(e){e.moveLinesUp()},scrollIntoView:"cursor"},{name:"copylinesdown",description:"Copy lines down",bindKey:o("Alt-Shift-Down","Command-Option-Down"),exec:function(e){e.copyLinesDown()},scrollIntoView:"cursor"},{name:"movelinesdown",description:"Move lines down",bindKey:o("Alt-Down","Option-Down"),exec:function(e){e.moveLinesDown()},scrollIntoView:"cursor"},{name:"del",description:"Delete",bindKey:o("Delete","Delete|Ctrl-D|Shift-Delete"),exec:function(e){e.remove("right")},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"backspace",description:"Backspace",bindKey:o("Shift-Backspace|Backspace","Ctrl-Backspace|Shift-Backspace|Backspace|Ctrl-H"),exec:function(e){e.remove("left")},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"cut_or_delete",description:"Cut or delete",bindKey:o("Shift-Delete",null),exec:function(e){if(!e.selection.isEmpty())return!1;e.remove("left")},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"removetolinestart",description:"Remove to line start",bindKey:o("Alt-Backspace","Command-Backspace"),exec:function(e){e.removeToLineStart()},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"removetolineend",description:"Remove to line end",bindKey:o("Alt-Delete","Ctrl-K|Command-Delete"),exec:function(e){e.removeToLineEnd()},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"removetolinestarthard",description:"Remove to line start hard",bindKey:o("Ctrl-Shift-Backspace",null),exec:function(e){var t=e.selection.getRange();t.start.column=0,e.session.remove(t)},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"removetolineendhard",description:"Remove to line end hard",bindKey:o("Ctrl-Shift-Delete",null),exec:function(e){var t=e.selection.getRange();t.end.column=Number.MAX_VALUE,e.session.remove(t)},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"removewordleft",description:"Remove word left",bindKey:o("Ctrl-Backspace","Alt-Backspace|Ctrl-Alt-Backspace"),exec:function(e){e.removeWordLeft()},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"removewordright",description:"Remove word right",bindKey:o("Ctrl-Delete","Alt-Delete"),exec:function(e){e.removeWordRight()},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"outdent",description:"Outdent",bindKey:o("Shift-Tab","Shift-Tab"),exec:function(e){e.blockOutdent()},multiSelectAction:"forEach",scrollIntoView:"selectionPart"},{name:"indent",description:"Indent",bindKey:o("Tab","Tab"),exec:function(e){e.indent()},multiSelectAction:"forEach",scrollIntoView:"selectionPart"},{name:"blockoutdent",description:"Block outdent",bindKey:o("Ctrl-[","Ctrl-["),exec:function(e){e.blockOutdent()},multiSelectAction:"forEachLine",scrollIntoView:"selectionPart"},{name:"blockindent",description:"Block indent",bindKey:o("Ctrl-]","Ctrl-]"),exec:function(e){e.blockIndent()},multiSelectAction:"forEachLine",scrollIntoView:"selectionPart"},{name:"insertstring",description:"Insert string",exec:function(e,t){e.insert(t)},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"inserttext",description:"Insert text",exec:function(e,t){e.insert(r.stringRepeat(t.text||"",t.times||1))},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"splitline",description:"Split line",bindKey:o(null,"Ctrl-O"),exec:function(e){e.splitLine()},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"transposeletters",description:"Transpose letters",bindKey:o("Alt-Shift-X","Ctrl-T"),exec:function(e){e.transposeLetters()},multiSelectAction:function(e){e.transposeSelections(1)},scrollIntoView:"cursor"},{name:"touppercase",description:"To uppercase",bindKey:o("Ctrl-U","Ctrl-U"),exec:function(e){e.toUpperCase()},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"tolowercase",description:"To lowercase",bindKey:o("Ctrl-Shift-U","Ctrl-Shift-U"),exec:function(e){e.toLowerCase()},multiSelectAction:"forEach",scrollIntoView:"cursor"},{name:"expandtoline",description:"Expand to line",bindKey:o("Ctrl-Shift-L","Command-Shift-L"),exec:function(e){var t=e.selection.getRange();t.start.column=t.end.column=0,t.end.row++,e.selection.setRange(t,!1)},multiSelectAction:"forEach",scrollIntoView:"cursor",readOnly:!0},{name:"joinlines",description:"Join lines",bindKey:o(null,null),exec:function(e){var t=e.selection.isBackwards(),n=t?e.selection.getSelectionLead():e.selection.getSelectionAnchor(),i=t?e.selection.getSelectionAnchor():e.selection.getSelectionLead(),o=e.session.doc.getLine(n.row).length,u=e.session.doc.getTextRange(e.selection.getRange()),a=u.replace(/\n\s*/," ").length,f=e.session.doc.getLine(n.row);for(var l=n.row+1;l<=i.row+1;l++){var c=r.stringTrimLeft(r.stringTrimRight(e.session.doc.getLine(l)));c.length!==0&&(c=" "+c),f+=c}i.row+1<e.session.doc.getLength()-1&&(f+=e.session.doc.getNewLineCharacter()),e.clearSelection(),e.session.doc.replace(new s(n.row,0,i.row+2,0),f),a>0?(e.selection.moveCursorTo(n.row,n.column),e.selection.selectTo(n.row,n.column+a)):(o=e.session.doc.getLine(n.row).length>o?o+1:o,e.selection.moveCursorTo(n.row,o))},multiSelectAction:"forEach",readOnly:!0},{name:"invertSelection",description:"Invert selection",bindKey:o(null,null),exec:function(e){var t=e.session.doc.getLength()-1,n=e.session.doc.getLine(t).length,r=e.selection.rangeList.ranges,i=[];r.length<1&&(r=[e.selection.getRange()]);for(var o=0;o<r.length;o++)o==r.length-1&&(r[o].end.row!==t||r[o].end.column!==n)&&i.push(new s(r[o].end.row,r[o].end.column,t,n)),o===0?(r[o].start.row!==0||r[o].start.column!==0)&&i.push(new s(0,0,r[o].start.row,r[o].start.column)):i.push(new s(r[o-1].end.row,r[o-1].end.column,r[o].start.row,r[o].start.column));e.exitMultiSelectMode(),e.clearSelection();for(var o=0;o<i.length;o++)e.selection.addRange(i[o],!1)},readOnly:!0,scrollIntoView:"none"},{name:"openCommandPallete",description:"Open command pallete",bindKey:o("F1","F1"),exec:function(e){e.prompt({$type:"commands"})},readOnly:!0},{name:"modeSelect",description:"Change language mode...",bindKey:o(null,null),exec:function(e){e.prompt({$type:"modes"})},readOnly:!0}]}),ace.define("ace/editor",["require","exports","module","ace/lib/fixoldbrowsers","ace/lib/oop","ace/lib/dom","ace/lib/lang","ace/lib/useragent","ace/keyboard/textinput","ace/mouse/mouse_handler","ace/mouse/fold_handler","ace/keyboard/keybinding","ace/edit_session","ace/search","ace/range","ace/lib/event_emitter","ace/commands/command_manager","ace/commands/default_commands","ace/config","ace/token_iterator","ace/clipboard"],function(e,t,n){"use strict";e("./lib/fixoldbrowsers");var r=e("./lib/oop"),i=e("./lib/dom"),s=e("./lib/lang"),o=e("./lib/useragent"),u=e("./keyboard/textinput").TextInput,a=e("./mouse/mouse_handler").MouseHandler,f=e("./mouse/fold_handler").FoldHandler,l=e("./keyboard/keybinding").KeyBinding,c=e("./edit_session").EditSession,h=e("./search").Search,p=e("./range").Range,d=e("./lib/event_emitter").EventEmitter,v=e("./commands/command_manager").CommandManager,m=e("./commands/default_commands").commands,g=e("./config"),y=e("./token_iterator").TokenIterator,b=e("./clipboard"),w=function(e,t,n){var r=e.getContainerElement();this.container=r,this.renderer=e,this.id="editor"+ ++w.$uid,this.commands=new v(o.isMac?"mac":"win",m),typeof document=="object"&&(this.textInput=new u(e.getTextAreaContainer(),this),this.renderer.textarea=this.textInput.getElement(),this.$mouseHandler=new a(this),new f(this)),this.keyBinding=new l(this),this.$search=(new h).set({wrap:!0}),this.$historyTracker=this.$historyTracker.bind(this),this.commands.on("exec",this.$historyTracker),this.$initOperationListeners(),this._$emitInputEvent=s.delayedCall(function(){this._signal("input",{}),this.session&&this.session.bgTokenizer&&this.session.bgTokenizer.scheduleStart()}.bind(this)),this.on("change",function(e,t){t._$emitInputEvent.schedule(31)}),this.setSession(t||n&&n.session||new c("")),g.resetOptions(this),n&&this.setOptions(n),g._signal("editor",this)};w.$uid=0,function(){r.implement(this,d),this.$initOperationListeners=function(){this.commands.on("exec",this.startOperation.bind(this),!0),this.commands.on("afterExec",this.endOperation.bind(this),!0),this.$opResetTimer=s.delayedCall(this.endOperation.bind(this,!0)),this.on("change",function(){this.curOp||(this.startOperation(),this.curOp.selectionBefore=this.$lastSel),this.curOp.docChanged=!0}.bind(this),!0),this.on("changeSelection",function(){this.curOp||(this.startOperation(),this.curOp.selectionBefore=this.$lastSel),this.curOp.selectionChanged=!0}.bind(this),!0)},this.curOp=null,this.prevOp={},this.startOperation=function(e){if(this.curOp){if(!e||this.curOp.command)return;this.prevOp=this.curOp}e||(this.previousCommand=null,e={}),this.$opResetTimer.schedule(),this.curOp=this.session.curOp={command:e.command||{},args:e.args,scrollTop:this.renderer.scrollTop},this.curOp.selectionBefore=this.selection.toJSON()},this.endOperation=function(e){if(this.curOp){if(e&&e.returnValue===!1)return this.curOp=null;if(e==1&&this.curOp.command&&this.curOp.command.name=="mouse")return;this._signal("beforeEndOperation");if(!this.curOp)return;var t=this.curOp.command,n=t&&t.scrollIntoView;if(n){switch(n){case"center-animate":n="animate";case"center":this.renderer.scrollCursorIntoView(null,.5);break;case"animate":case"cursor":this.renderer.scrollCursorIntoView();break;case"selectionPart":var r=this.selection.getRange(),i=this.renderer.layerConfig;(r.start.row>=i.lastRow||r.end.row<=i.firstRow)&&this.renderer.scrollSelectionIntoView(this.selection.anchor,this.selection.lead);break;default:}n=="animate"&&this.renderer.animateScrolling(this.curOp.scrollTop)}var s=this.selection.toJSON();this.curOp.selectionAfter=s,this.$lastSel=this.selection.toJSON(),this.session.getUndoManager().addSelection(s),this.prevOp=this.curOp,this.curOp=null}},this.$mergeableCommands=["backspace","del","insertstring"],this.$historyTracker=function(e){if(!this.$mergeUndoDeltas)return;var t=this.prevOp,n=this.$mergeableCommands,r=t.command&&e.command.name==t.command.name;if(e.command.name=="insertstring"){var i=e.args;this.mergeNextCommand===undefined&&(this.mergeNextCommand=!0),r=r&&this.mergeNextCommand&&(!/\s/.test(i)||/\s/.test(t.args)),this.mergeNextCommand=!0}else r=r&&n.indexOf(e.command.name)!==-1;this.$mergeUndoDeltas!="always"&&Date.now()-this.sequenceStartTime>2e3&&(r=!1),r?this.session.mergeUndoDeltas=!0:n.indexOf(e.command.name)!==-1&&(this.sequenceStartTime=Date.now())},this.setKeyboardHandler=function(e,t){if(e&&typeof e=="string"&&e!="ace"){this.$keybindingId=e;var n=this;g.loadModule(["keybinding",e],function(r){n.$keybindingId==e&&n.keyBinding.setKeyboardHandler(r&&r.handler),t&&t()})}else this.$keybindingId=null,this.keyBinding.setKeyboardHandler(e),t&&t()},this.getKeyboardHandler=function(){return this.keyBinding.getKeyboardHandler()},this.setSession=function(e){if(this.session==e)return;this.curOp&&this.endOperation(),this.curOp={};var t=this.session;if(t){this.session.off("change",this.$onDocumentChange),this.session.off("changeMode",this.$onChangeMode),this.session.off("tokenizerUpdate",this.$onTokenizerUpdate),this.session.off("changeTabSize",this.$onChangeTabSize),this.session.off("changeWrapLimit",this.$onChangeWrapLimit),this.session.off("changeWrapMode",this.$onChangeWrapMode),this.session.off("changeFold",this.$onChangeFold),this.session.off("changeFrontMarker",this.$onChangeFrontMarker),this.session.off("changeBackMarker",this.$onChangeBackMarker),this.session.off("changeBreakpoint",this.$onChangeBreakpoint),this.session.off("changeAnnotation",this.$onChangeAnnotation),this.session.off("changeOverwrite",this.$onCursorChange),this.session.off("changeScrollTop",this.$onScrollTopChange),this.session.off("changeScrollLeft",this.$onScrollLeftChange);var n=this.session.getSelection();n.off("changeCursor",this.$onCursorChange),n.off("changeSelection",this.$onSelectionChange)}this.session=e,e?(this.$onDocumentChange=this.onDocumentChange.bind(this),e.on("change",this.$onDocumentChange),this.renderer.setSession(e),this.$onChangeMode=this.onChangeMode.bind(this),e.on("changeMode",this.$onChangeMode),this.$onTokenizerUpdate=this.onTokenizerUpdate.bind(this),e.on("tokenizerUpdate",this.$onTokenizerUpdate),this.$onChangeTabSize=this.renderer.onChangeTabSize.bind(this.renderer),e.on("changeTabSize",this.$onChangeTabSize),this.$onChangeWrapLimit=this.onChangeWrapLimit.bind(this),e.on("changeWrapLimit",this.$onChangeWrapLimit),this.$onChangeWrapMode=this.onChangeWrapMode.bind(this),e.on("changeWrapMode",this.$onChangeWrapMode),this.$onChangeFold=this.onChangeFold.bind(this),e.on("changeFold",this.$onChangeFold),this.$onChangeFrontMarker=this.onChangeFrontMarker.bind(this),this.session.on("changeFrontMarker",this.$onChangeFrontMarker),this.$onChangeBackMarker=this.onChangeBackMarker.bind(this),this.session.on("changeBackMarker",this.$onChangeBackMarker),this.$onChangeBreakpoint=this.onChangeBreakpoint.bind(this),this.session.on("changeBreakpoint",this.$onChangeBreakpoint),this.$onChangeAnnotation=this.onChangeAnnotation.bind(this),this.session.on("changeAnnotation",this.$onChangeAnnotation),this.$onCursorChange=this.onCursorChange.bind(this),this.session.on("changeOverwrite",this.$onCursorChange),this.$onScrollTopChange=this.onScrollTopChange.bind(this),this.session.on("changeScrollTop",this.$onScrollTopChange),this.$onScrollLeftChange=this.onScrollLeftChange.bind(this),this.session.on("changeScrollLeft",this.$onScrollLeftChange),this.selection=e.getSelection(),this.selection.on("changeCursor",this.$onCursorChange),this.$onSelectionChange=this.onSelectionChange.bind(this),this.selection.on("changeSelection",this.$onSelectionChange),this.onChangeMode(),this.onCursorChange(),this.onScrollTopChange(),this.onScrollLeftChange(),this.onSelectionChange(),this.onChangeFrontMarker(),this.onChangeBackMarker(),this.onChangeBreakpoint(),this.onChangeAnnotation(),this.session.getUseWrapMode()&&this.renderer.adjustWrapLimit(),this.renderer.updateFull()):(this.selection=null,this.renderer.setSession(e)),this._signal("changeSession",{session:e,oldSession:t}),this.curOp=null,t&&t._signal("changeEditor",{oldEditor:this}),e&&e._signal("changeEditor",{editor:this}),e&&e.bgTokenizer&&e.bgTokenizer.scheduleStart()},this.getSession=function(){return this.session},this.setValue=function(e,t){return this.session.doc.setValue(e),t?t==1?this.navigateFileEnd():t==-1&&this.navigateFileStart():this.selectAll(),e},this.getValue=function(){return this.session.getValue()},this.getSelection=function(){return this.selection},this.resize=function(e){this.renderer.onResize(e)},this.setTheme=function(e,t){this.renderer.setTheme(e,t)},this.getTheme=function(){return this.renderer.getTheme()},this.setStyle=function(e){this.renderer.setStyle(e)},this.unsetStyle=function(e){this.renderer.unsetStyle(e)},this.getFontSize=function(){return this.getOption("fontSize")||i.computedStyle(this.container).fontSize},this.setFontSize=function(e){this.setOption("fontSize",e)},this.$highlightBrackets=function(){this.session.$bracketHighlight&&(this.session.removeMarker(this.session.$bracketHighlight),this.session.$bracketHighlight=null);if(this.$highlightPending)return;var e=this;this.$highlightPending=!0,setTimeout(function(){e.$highlightPending=!1;var t=e.session;if(!t||!t.bgTokenizer)return;var n=t.findMatchingBracket(e.getCursorPosition());if(n)var r=new p(n.row,n.column,n.row,n.column+1);else if(t.$mode.getMatching)var r=t.$mode.getMatching(e.session);r&&(t.$bracketHighlight=t.addMarker(r,"ace_bracket","text"))},50)},this.$highlightTags=function(){if(this.$highlightTagPending)return;var e=this;this.$highlightTagPending=!0,setTimeout(function(){e.$highlightTagPending=!1;var t=e.session;if(!t||!t.bgTokenizer)return;var n=e.getCursorPosition(),r=new y(e.session,n.row,n.column),i=r.getCurrentToken();if(!i||!/\b(?:tag-open|tag-name)/.test(i.type)){t.removeMarker(t.$tagHighlight),t.$tagHighlight=null;return}if(i.type.indexOf("tag-open")!=-1){i=r.stepForward();if(!i)return}var s=i.value,o=0,u=r.stepBackward();if(u.value=="<"){do u=i,i=r.stepForward(),i&&i.value===s&&i.type.indexOf("tag-name")!==-1&&(u.value==="<"?o++:u.value==="</"&&o--);while(i&&o>=0)}else{do i=u,u=r.stepBackward(),i&&i.value===s&&i.type.indexOf("tag-name")!==-1&&(u.value==="<"?o++:u.value==="</"&&o--);while(u&&o<=0);r.stepForward()}if(!i){t.removeMarker(t.$tagHighlight),t.$tagHighlight=null;return}var a=r.getCurrentTokenRow(),f=r.getCurrentTokenColumn(),l=new p(a,f,a,f+i.value.length),c=t.$backMarkers[t.$tagHighlight];t.$tagHighlight&&c!=undefined&&l.compareRange(c.range)!==0&&(t.removeMarker(t.$tagHighlight),t.$tagHighlight=null),t.$tagHighlight||(t.$tagHighlight=t.addMarker(l,"ace_bracket","text"))},50)},this.focus=function(){var e=this;setTimeout(function(){e.isFocused()||e.textInput.focus()}),this.textInput.focus()},this.isFocused=function(){return this.textInput.isFocused()},this.blur=function(){this.textInput.blur()},this.onFocus=function(e){if(this.$isFocused)return;this.$isFocused=!0,this.renderer.showCursor(),this.renderer.visualizeFocus(),this._emit("focus",e)},this.onBlur=function(e){if(!this.$isFocused)return;this.$isFocused=!1,this.renderer.hideCursor(),this.renderer.visualizeBlur(),this._emit("blur",e)},this.$cursorChange=function(){this.renderer.updateCursor()},this.onDocumentChange=function(e){var t=this.session.$useWrapMode,n=e.start.row==e.end.row?e.end.row:Infinity;this.renderer.updateLines(e.start.row,n,t),this._signal("change",e),this.$cursorChange(),this.$updateHighlightActiveLine()},this.onTokenizerUpdate=function(e){var t=e.data;this.renderer.updateLines(t.first,t.last)},this.onScrollTopChange=function(){this.renderer.scrollToY(this.session.getScrollTop())},this.onScrollLeftChange=function(){this.renderer.scrollToX(this.session.getScrollLeft())},this.onCursorChange=function(){this.$cursorChange(),this.$highlightBrackets(),this.$highlightTags(),this.$updateHighlightActiveLine(),this._signal("changeSelection")},this.$updateHighlightActiveLine=function(){var e=this.getSession(),t;if(this.$highlightActiveLine){if(this.$selectionStyle!="line"||!this.selection.isMultiLine())t=this.getCursorPosition();this.renderer.theme&&this.renderer.theme.$selectionColorConflict&&!this.selection.isEmpty()&&(t=!1),this.renderer.$maxLines&&this.session.getLength()===1&&!(this.renderer.$minLines>1)&&(t=!1)}if(e.$highlightLineMarker&&!t)e.removeMarker(e.$highlightLineMarker.id),e.$highlightLineMarker=null;else if(!e.$highlightLineMarker&&t){var n=new p(t.row,t.column,t.row,Infinity);n.id=e.addMarker(n,"ace_active-line","screenLine"),e.$highlightLineMarker=n}else t&&(e.$highlightLineMarker.start.row=t.row,e.$highlightLineMarker.end.row=t.row,e.$highlightLineMarker.start.column=t.column,e._signal("changeBackMarker"))},this.onSelectionChange=function(e){var t=this.session;t.$selectionMarker&&t.removeMarker(t.$selectionMarker),t.$selectionMarker=null;if(!this.selection.isEmpty()){var n=this.selection.getRange(),r=this.getSelectionStyle();t.$selectionMarker=t.addMarker(n,"ace_selection",r)}else this.$updateHighlightActiveLine();var i=this.$highlightSelectedWord&&this.$getSelectionHighLightRegexp();this.session.highlight(i),this._signal("changeSelection")},this.$getSelectionHighLightRegexp=function(){var e=this.session,t=this.getSelectionRange();if(t.isEmpty()||t.isMultiLine())return;var n=t.start.column,r=t.end.column,i=e.getLine(t.start.row),s=i.substring(n,r);if(s.length>5e3||!/[\w\d]/.test(s))return;var o=this.$search.$assembleRegExp({wholeWord:!0,caseSensitive:!0,needle:s}),u=i.substring(n-1,r+1);if(!o.test(u))return;return o},this.onChangeFrontMarker=function(){this.renderer.updateFrontMarkers()},this.onChangeBackMarker=function(){this.renderer.updateBackMarkers()},this.onChangeBreakpoint=function(){this.renderer.updateBreakpoints()},this.onChangeAnnotation=function(){this.renderer.setAnnotations(this.session.getAnnotations())},this.onChangeMode=function(e){this.renderer.updateText(),this._emit("changeMode",e)},this.onChangeWrapLimit=function(){this.renderer.updateFull()},this.onChangeWrapMode=function(){this.renderer.onResize(!0)},this.onChangeFold=function(){this.$updateHighlightActiveLine(),this.renderer.updateFull()},this.getSelectedText=function(){return this.session.getTextRange(this.getSelectionRange())},this.getCopyText=function(){var e=this.getSelectedText(),t=this.session.doc.getNewLineCharacter(),n=!1;if(!e&&this.$copyWithEmptySelection){n=!0;var r=this.selection.getAllRanges();for(var i=0;i<r.length;i++){var s=r[i];if(i&&r[i-1].start.row==s.start.row)continue;e+=this.session.getLine(s.start.row)+t}}var o={text:e};return this._signal("copy",o),b.lineMode=n?o.text:"",o.text},this.onCopy=function(){this.commands.exec("copy",this)},this.onCut=function(){this.commands.exec("cut",this)},this.onPaste=function(e,t){var n={text:e,event:t};this.commands.exec("paste",this,n)},this.$handlePaste=function(e){typeof e=="string"&&(e={text:e}),this._signal("paste",e);var t=e.text,n=t==b.lineMode,r=this.session;if(!this.inMultiSelectMode||this.inVirtualSelectionMode)n?r.insert({row:this.selection.lead.row,column:0},t):this.insert(t);else if(n)this.selection.rangeList.ranges.forEach(function(e){r.insert({row:e.start.row,column:0},t)});else{var i=t.split(/\r\n|\r|\n/),s=this.selection.rangeList.ranges,o=i.length==2&&(!i[0]||!i[1]);if(i.length!=s.length||o)return this.commands.exec("insertstring",this,t);for(var u=s.length;u--;){var a=s[u];a.isEmpty()||r.remove(a),r.insert(a.start,i[u])}}},this.execCommand=function(e,t){return this.commands.exec(e,this,t)},this.insert=function(e,t){var n=this.session,r=n.getMode(),i=this.getCursorPosition();if(this.getBehavioursEnabled()&&!t){var s=r.transformAction(n.getState(i.row),"insertion",this,n,e);s&&(e!==s.text&&(this.inVirtualSelectionMode||(this.session.mergeUndoDeltas=!1,this.mergeNextCommand=!1)),e=s.text)}e=="	"&&(e=this.session.getTabString());if(!this.selection.isEmpty()){var o=this.getSelectionRange();i=this.session.remove(o),this.clearSelection()}else if(this.session.getOverwrite()&&e.indexOf("\n")==-1){var o=new p.fromPoints(i,i);o.end.column+=e.length,this.session.remove(o)}if(e=="\n"||e=="\r\n"){var u=n.getLine(i.row);if(i.column>u.search(/\S|$/)){var a=u.substr(i.column).search(/\S|$/);n.doc.removeInLine(i.row,i.column,i.column+a)}}this.clearSelection();var f=i.column,l=n.getState(i.row),u=n.getLine(i.row),c=r.checkOutdent(l,u,e);n.insert(i,e),s&&s.selection&&(s.selection.length==2?this.selection.setSelectionRange(new p(i.row,f+s.selection[0],i.row,f+s.selection[1])):this.selection.setSelectionRange(new p(i.row+s.selection[0],s.selection[1],i.row+s.selection[2],s.selection[3])));if(n.getDocument().isNewLine(e)){var h=r.getNextLineIndent(l,u.slice(0,i.column),n.getTabString());n.insert({row:i.row+1,column:0},h)}c&&r.autoOutdent(l,n,i.row)},this.onTextInput=function(e,t){if(!t)return this.keyBinding.onTextInput(e);this.startOperation({command:{name:"insertstring"}});var n=this.applyComposition.bind(this,e,t);this.selection.rangeCount?this.forEachSelection(n):n(),this.endOperation()},this.applyComposition=function(e,t){if(t.extendLeft||t.extendRight){var n=this.selection.getRange();n.start.column-=t.extendLeft,n.end.column+=t.extendRight,this.selection.setRange(n),!e&&!n.isEmpty()&&this.remove()}(e||!this.selection.isEmpty())&&this.insert(e,!0);if(t.restoreStart||t.restoreEnd){var n=this.selection.getRange();n.start.column-=t.restoreStart,n.end.column-=t.restoreEnd,this.selection.setRange(n)}},this.onCommandKey=function(e,t,n){return this.keyBinding.onCommandKey(e,t,n)},this.setOverwrite=function(e){this.session.setOverwrite(e)},this.getOverwrite=function(){return this.session.getOverwrite()},this.toggleOverwrite=function(){this.session.toggleOverwrite()},this.setScrollSpeed=function(e){this.setOption("scrollSpeed",e)},this.getScrollSpeed=function(){return this.getOption("scrollSpeed")},this.setDragDelay=function(e){this.setOption("dragDelay",e)},this.getDragDelay=function(){return this.getOption("dragDelay")},this.setSelectionStyle=function(e){this.setOption("selectionStyle",e)},this.getSelectionStyle=function(){return this.getOption("selectionStyle")},this.setHighlightActiveLine=function(e){this.setOption("highlightActiveLine",e)},this.getHighlightActiveLine=function(){return this.getOption("highlightActiveLine")},this.setHighlightGutterLine=function(e){this.setOption("highlightGutterLine",e)},this.getHighlightGutterLine=function(){return this.getOption("highlightGutterLine")},this.setHighlightSelectedWord=function(e){this.setOption("highlightSelectedWord",e)},this.getHighlightSelectedWord=function(){return this.$highlightSelectedWord},this.setAnimatedScroll=function(e){this.renderer.setAnimatedScroll(e)},this.getAnimatedScroll=function(){return this.renderer.getAnimatedScroll()},this.setShowInvisibles=function(e){this.renderer.setShowInvisibles(e)},this.getShowInvisibles=function(){return this.renderer.getShowInvisibles()},this.setDisplayIndentGuides=function(e){this.renderer.setDisplayIndentGuides(e)},this.getDisplayIndentGuides=function(){return this.renderer.getDisplayIndentGuides()},this.setShowPrintMargin=function(e){this.renderer.setShowPrintMargin(e)},this.getShowPrintMargin=function(){return this.renderer.getShowPrintMargin()},this.setPrintMarginColumn=function(e){this.renderer.setPrintMarginColumn(e)},this.getPrintMarginColumn=function(){return this.renderer.getPrintMarginColumn()},this.setReadOnly=function(e){this.setOption("readOnly",e)},this.getReadOnly=function(){return this.getOption("readOnly")},this.setBehavioursEnabled=function(e){this.setOption("behavioursEnabled",e)},this.getBehavioursEnabled=function(){return this.getOption("behavioursEnabled")},this.setWrapBehavioursEnabled=function(e){this.setOption("wrapBehavioursEnabled",e)},this.getWrapBehavioursEnabled=function(){return this.getOption("wrapBehavioursEnabled")},this.setShowFoldWidgets=function(e){this.setOption("showFoldWidgets",e)},this.getShowFoldWidgets=function(){return this.getOption("showFoldWidgets")},this.setFadeFoldWidgets=function(e){this.setOption("fadeFoldWidgets",e)},this.getFadeFoldWidgets=function(){return this.getOption("fadeFoldWidgets")},this.remove=function(e){this.selection.isEmpty()&&(e=="left"?this.selection.selectLeft():this.selection.selectRight());var t=this.getSelectionRange();if(this.getBehavioursEnabled()){var n=this.session,r=n.getState(t.start.row),i=n.getMode().transformAction(r,"deletion",this,n,t);if(t.end.column===0){var s=n.getTextRange(t);if(s[s.length-1]=="\n"){var o=n.getLine(t.end.row);/^\s+$/.test(o)&&(t.end.column=o.length)}}i&&(t=i)}this.session.remove(t),this.clearSelection()},this.removeWordRight=function(){this.selection.isEmpty()&&this.selection.selectWordRight(),this.session.remove(this.getSelectionRange()),this.clearSelection()},this.removeWordLeft=function(){this.selection.isEmpty()&&this.selection.selectWordLeft(),this.session.remove(this.getSelectionRange()),this.clearSelection()},this.removeToLineStart=function(){this.selection.isEmpty()&&this.selection.selectLineStart(),this.selection.isEmpty()&&this.selection.selectLeft(),this.session.remove(this.getSelectionRange()),this.clearSelection()},this.removeToLineEnd=function(){this.selection.isEmpty()&&this.selection.selectLineEnd();var e=this.getSelectionRange();e.start.column==e.end.column&&e.start.row==e.end.row&&(e.end.column=0,e.end.row++),this.session.remove(e),this.clearSelection()},this.splitLine=function(){this.selection.isEmpty()||(this.session.remove(this.getSelectionRange()),this.clearSelection());var e=this.getCursorPosition();this.insert("\n"),this.moveCursorToPosition(e)},this.transposeLetters=function(){if(!this.selection.isEmpty())return;var e=this.getCursorPosition(),t=e.column;if(t===0)return;var n=this.session.getLine(e.row),r,i;t<n.length?(r=n.charAt(t)+n.charAt(t-1),i=new p(e.row,t-1,e.row,t+1)):(r=n.charAt(t-1)+n.charAt(t-2),i=new p(e.row,t-2,e.row,t)),this.session.replace(i,r),this.session.selection.moveToPosition(i.end)},this.toLowerCase=function(){var e=this.getSelectionRange();this.selection.isEmpty()&&this.selection.selectWord();var t=this.getSelectionRange(),n=this.session.getTextRange(t);this.session.replace(t,n.toLowerCase()),this.selection.setSelectionRange(e)},this.toUpperCase=function(){var e=this.getSelectionRange();this.selection.isEmpty()&&this.selection.selectWord();var t=this.getSelectionRange(),n=this.session.getTextRange(t);this.session.replace(t,n.toUpperCase()),this.selection.setSelectionRange(e)},this.indent=function(){var e=this.session,t=this.getSelectionRange();if(t.start.row<t.end.row){var n=this.$getSelectedRows();e.indentRows(n.first,n.last,"	");return}if(t.start.column<t.end.column){var r=e.getTextRange(t);if(!/^\s+$/.test(r)){var n=this.$getSelectedRows();e.indentRows(n.first,n.last,"	");return}}var i=e.getLine(t.start.row),o=t.start,u=e.getTabSize(),a=e.documentToScreenColumn(o.row,o.column);if(this.session.getUseSoftTabs())var f=u-a%u,l=s.stringRepeat(" ",f);else{var f=a%u;while(i[t.start.column-1]==" "&&f)t.start.column--,f--;this.selection.setSelectionRange(t),l="	"}return this.insert(l)},this.blockIndent=function(){var e=this.$getSelectedRows();this.session.indentRows(e.first,e.last,"	")},this.blockOutdent=function(){var e=this.session.getSelection();this.session.outdentRows(e.getRange())},this.sortLines=function(){var e=this.$getSelectedRows(),t=this.session,n=[];for(var r=e.first;r<=e.last;r++)n.push(t.getLine(r));n.sort(function(e,t){return e.toLowerCase()<t.toLowerCase()?-1:e.toLowerCase()>t.toLowerCase()?1:0});var i=new p(0,0,0,0);for(var r=e.first;r<=e.last;r++){var s=t.getLine(r);i.start.row=r,i.end.row=r,i.end.column=s.length,t.replace(i,n[r-e.first])}},this.toggleCommentLines=function(){var e=this.session.getState(this.getCursorPosition().row),t=this.$getSelectedRows();this.session.getMode().toggleCommentLines(e,this.session,t.first,t.last)},this.toggleBlockComment=function(){var e=this.getCursorPosition(),t=this.session.getState(e.row),n=this.getSelectionRange();this.session.getMode().toggleBlockComment(t,this.session,n,e)},this.getNumberAt=function(e,t){var n=/[\-]?[0-9]+(?:\.[0-9]+)?/g;n.lastIndex=0;var r=this.session.getLine(e);while(n.lastIndex<t){var i=n.exec(r);if(i.index<=t&&i.index+i[0].length>=t){var s={value:i[0],start:i.index,end:i.index+i[0].length};return s}}return null},this.modifyNumber=function(e){var t=this.selection.getCursor().row,n=this.selection.getCursor().column,r=new p(t,n-1,t,n),i=this.session.getTextRange(r);if(!isNaN(parseFloat(i))&&isFinite(i)){var s=this.getNumberAt(t,n);if(s){var o=s.value.indexOf(".")>=0?s.start+s.value.indexOf(".")+1:s.end,u=s.start+s.value.length-o,a=parseFloat(s.value);a*=Math.pow(10,u),o!==s.end&&n<o?e*=Math.pow(10,s.end-n-1):e*=Math.pow(10,s.end-n),a+=e,a/=Math.pow(10,u);var f=a.toFixed(u),l=new p(t,s.start,t,s.end);this.session.replace(l,f),this.moveCursorTo(t,Math.max(s.start+1,n+f.length-s.value.length))}}else this.toggleWord()},this.$toggleWordPairs=[["first","last"],["true","false"],["yes","no"],["width","height"],["top","bottom"],["right","left"],["on","off"],["x","y"],["get","set"],["max","min"],["horizontal","vertical"],["show","hide"],["add","remove"],["up","down"],["before","after"],["even","odd"],["inside","outside"],["next","previous"],["increase","decrease"],["attach","detach"],["&&","||"],["==","!="]],this.toggleWord=function(){var e=this.selection.getCursor().row,t=this.selection.getCursor().column;this.selection.selectWord();var n=this.getSelectedText(),r=this.selection.getWordRange().start.column,i=n.replace(/([a-z]+|[A-Z]+)(?=[A-Z_]|$)/g,"$1 ").split(/\s/),o=t-r-1;o<0&&(o=0);var u=0,a=0,f=this;n.match(/[A-Za-z0-9_]+/)&&i.forEach(function(t,i){a=u+t.length,o>=u&&o<=a&&(n=t,f.selection.clearSelection(),f.moveCursorTo(e,u+r),f.selection.selectTo(e,a+r)),u=a});var l=this.$toggleWordPairs,c;for(var h=0;h<l.length;h++){var p=l[h];for(var d=0;d<=1;d++){var v=+!d,m=n.match(new RegExp("^\\s?_?("+s.escapeRegExp(p[d])+")\\s?$","i"));if(m){var g=n.match(new RegExp("([_]|^|\\s)("+s.escapeRegExp(m[1])+")($|\\s)","g"));g&&(c=n.replace(new RegExp(s.escapeRegExp(p[d]),"i"),function(e){var t=p[v];return e.toUpperCase()==e?t=t.toUpperCase():e.charAt(0).toUpperCase()==e.charAt(0)&&(t=t.substr(0,0)+p[v].charAt(0).toUpperCase()+t.substr(1)),t}),this.insert(c),c="")}}}},this.removeLines=function(){var e=this.$getSelectedRows();this.session.removeFullLines(e.first,e.last),this.clearSelection()},this.duplicateSelection=function(){var e=this.selection,t=this.session,n=e.getRange(),r=e.isBackwards();if(n.isEmpty()){var i=n.start.row;t.duplicateLines(i,i)}else{var s=r?n.start:n.end,o=t.insert(s,t.getTextRange(n),!1);n.start=s,n.end=o,e.setSelectionRange(n,r)}},this.moveLinesDown=function(){this.$moveLines(1,!1)},this.moveLinesUp=function(){this.$moveLines(-1,!1)},this.moveText=function(e,t,n){return this.session.moveText(e,t,n)},this.copyLinesUp=function(){this.$moveLines(-1,!0)},this.copyLinesDown=function(){this.$moveLines(1,!0)},this.$moveLines=function(e,t){var n,r,i=this.selection;if(!i.inMultiSelectMode||this.inVirtualSelectionMode){var s=i.toOrientedRange();n=this.$getSelectedRows(s),r=this.session.$moveLines(n.first,n.last,t?0:e),t&&e==-1&&(r=0),s.moveBy(r,0),i.fromOrientedRange(s)}else{var o=i.rangeList.ranges;i.rangeList.detach(this.session),this.inVirtualSelectionMode=!0;var u=0,a=0,f=o.length;for(var l=0;l<f;l++){var c=l;o[l].moveBy(u,0),n=this.$getSelectedRows(o[l]);var h=n.first,p=n.last;while(++l<f){a&&o[l].moveBy(a,0);var d=this.$getSelectedRows(o[l]);if(t&&d.first!=p)break;if(!t&&d.first>p+1)break;p=d.last}l--,u=this.session.$moveLines(h,p,t?0:e),t&&e==-1&&(c=l+1);while(c<=l)o[c].moveBy(u,0),c++;t||(u=0),a+=u}i.fromOrientedRange(i.ranges[0]),i.rangeList.attach(this.session),this.inVirtualSelectionMode=!1}},this.$getSelectedRows=function(e){return e=(e||this.getSelectionRange()).collapseRows(),{first:this.session.getRowFoldStart(e.start.row),last:this.session.getRowFoldEnd(e.end.row)}},this.onCompositionStart=function(e){this.renderer.showComposition(e)},this.onCompositionUpdate=function(e){this.renderer.setCompositionText(e)},this.onCompositionEnd=function(){this.renderer.hideComposition()},this.getFirstVisibleRow=function(){return this.renderer.getFirstVisibleRow()},this.getLastVisibleRow=function(){return this.renderer.getLastVisibleRow()},this.isRowVisible=function(e){return e>=this.getFirstVisibleRow()&&e<=this.getLastVisibleRow()},this.isRowFullyVisible=function(e){return e>=this.renderer.getFirstFullyVisibleRow()&&e<=this.renderer.getLastFullyVisibleRow()},this.$getVisibleRowCount=function(){return this.renderer.getScrollBottomRow()-this.renderer.getScrollTopRow()+1},this.$moveByPage=function(e,t){var n=this.renderer,r=this.renderer.layerConfig,i=e*Math.floor(r.height/r.lineHeight);t===!0?this.selection.$moveSelection(function(){this.moveCursorBy(i,0)}):t===!1&&(this.selection.moveCursorBy(i,0),this.selection.clearSelection());var s=n.scrollTop;n.scrollBy(0,i*r.lineHeight),t!=null&&n.scrollCursorIntoView(null,.5),n.animateScrolling(s)},this.selectPageDown=function(){this.$moveByPage(1,!0)},this.selectPageUp=function(){this.$moveByPage(-1,!0)},this.gotoPageDown=function(){this.$moveByPage(1,!1)},this.gotoPageUp=function(){this.$moveByPage(-1,!1)},this.scrollPageDown=function(){this.$moveByPage(1)},this.scrollPageUp=function(){this.$moveByPage(-1)},this.scrollToRow=function(e){this.renderer.scrollToRow(e)},this.scrollToLine=function(e,t,n,r){this.renderer.scrollToLine(e,t,n,r)},this.centerSelection=function(){var e=this.getSelectionRange(),t={row:Math.floor(e.start.row+(e.end.row-e.start.row)/2),column:Math.floor(e.start.column+(e.end.column-e.start.column)/2)};this.renderer.alignCursor(t,.5)},this.getCursorPosition=function(){return this.selection.getCursor()},this.getCursorPositionScreen=function(){return this.session.documentToScreenPosition(this.getCursorPosition())},this.getSelectionRange=function(){return this.selection.getRange()},this.selectAll=function(){this.selection.selectAll()},this.clearSelection=function(){this.selection.clearSelection()},this.moveCursorTo=function(e,t){this.selection.moveCursorTo(e,t)},this.moveCursorToPosition=function(e){this.selection.moveCursorToPosition(e)},this.jumpToMatching=function(e,t){var n=this.getCursorPosition(),r=new y(this.session,n.row,n.column),i=r.getCurrentToken(),s=i||r.stepForward();if(!s)return;var o,u=!1,a={},f=n.column-s.start,l,c={")":"(","(":"(","]":"[","[":"[","{":"{","}":"{"};do{if(s.value.match(/[{}()\[\]]/g))for(;f<s.value.length&&!u;f++){if(!c[s.value[f]])continue;l=c[s.value[f]]+"."+s.type.replace("rparen","lparen"),isNaN(a[l])&&(a[l]=0);switch(s.value[f]){case"(":case"[":case"{":a[l]++;break;case")":case"]":case"}":a[l]--,a[l]===-1&&(o="bracket",u=!0)}}else s.type.indexOf("tag-name")!==-1&&(isNaN(a[s.value])&&(a[s.value]=0),i.value==="<"?a[s.value]++:i.value==="</"&&a[s.value]--,a[s.value]===-1&&(o="tag",u=!0));u||(i=s,s=r.stepForward(),f=0)}while(s&&!u);if(!o)return;var h,d;if(o==="bracket"){h=this.session.getBracketRange(n);if(!h){h=new p(r.getCurrentTokenRow(),r.getCurrentTokenColumn()+f-1,r.getCurrentTokenRow(),r.getCurrentTokenColumn()+f-1),d=h.start;if(t||d.row===n.row&&Math.abs(d.column-n.column)<2)h=this.session.getBracketRange(d)}}else if(o==="tag"){if(!s||s.type.indexOf("tag-name")===-1)return;var v=s.value;h=new p(r.getCurrentTokenRow(),r.getCurrentTokenColumn()-2,r.getCurrentTokenRow(),r.getCurrentTokenColumn()-2);if(h.compare(n.row,n.column)===0){u=!1;do s=i,i=r.stepBackward(),i&&(i.type.indexOf("tag-close")!==-1&&h.setEnd(r.getCurrentTokenRow(),r.getCurrentTokenColumn()+1),s.value===v&&s.type.indexOf("tag-name")!==-1&&(i.value==="<"?a[v]++:i.value==="</"&&a[v]--,a[v]===0&&(u=!0)));while(i&&!u)}s&&s.type.indexOf("tag-name")&&(d=h.start,d.row==n.row&&Math.abs(d.column-n.column)<2&&(d=h.end))}d=h&&h.cursor||d,d&&(e?h&&t?this.selection.setRange(h):h&&h.isEqual(this.getSelectionRange())?this.clearSelection():this.selection.selectTo(d.row,d.column):this.selection.moveTo(d.row,d.column))},this.gotoLine=function(e,t,n){this.selection.clearSelection(),this.session.unfold({row:e-1,column:t||0}),this.exitMultiSelectMode&&this.exitMultiSelectMode(),this.moveCursorTo(e-1,t||0),this.isRowFullyVisible(e-1)||this.scrollToLine(e-1,!0,n)},this.navigateTo=function(e,t){this.selection.moveTo(e,t)},this.navigateUp=function(e){if(this.selection.isMultiLine()&&!this.selection.isBackwards()){var t=this.selection.anchor.getPosition();return this.moveCursorToPosition(t)}this.selection.clearSelection(),this.selection.moveCursorBy(-e||-1,0)},this.navigateDown=function(e){if(this.selection.isMultiLine()&&this.selection.isBackwards()){var t=this.selection.anchor.getPosition();return this.moveCursorToPosition(t)}this.selection.clearSelection(),this.selection.moveCursorBy(e||1,0)},this.navigateLeft=function(e){if(!this.selection.isEmpty()){var t=this.getSelectionRange().start;this.moveCursorToPosition(t)}else{e=e||1;while(e--)this.selection.moveCursorLeft()}this.clearSelection()},this.navigateRight=function(e){if(!this.selection.isEmpty()){var t=this.getSelectionRange().end;this.moveCursorToPosition(t)}else{e=e||1;while(e--)this.selection.moveCursorRight()}this.clearSelection()},this.navigateLineStart=function(){this.selection.moveCursorLineStart(),this.clearSelection()},this.navigateLineEnd=function(){this.selection.moveCursorLineEnd(),this.clearSelection()},this.navigateFileEnd=function(){this.selection.moveCursorFileEnd(),this.clearSelection()},this.navigateFileStart=function(){this.selection.moveCursorFileStart(),this.clearSelection()},this.navigateWordRight=function(){this.selection.moveCursorWordRight(),this.clearSelection()},this.navigateWordLeft=function(){this.selection.moveCursorWordLeft(),this.clearSelection()},this.replace=function(e,t){t&&this.$search.set(t);var n=this.$search.find(this.session),r=0;return n?(this.$tryReplace(n,e)&&(r=1),this.selection.setSelectionRange(n),this.renderer.scrollSelectionIntoView(n.start,n.end),r):r},this.replaceAll=function(e,t){t&&this.$search.set(t);var n=this.$search.findAll(this.session),r=0;if(!n.length)return r;var i=this.getSelectionRange();this.selection.moveTo(0,0);for(var s=n.length-1;s>=0;--s)this.$tryReplace(n[s],e)&&r++;return this.selection.setSelectionRange(i),r},this.$tryReplace=function(e,t){var n=this.session.getTextRange(e);return t=this.$search.replace(n,t),t!==null?(e.end=this.session.replace(e,t),e):null},this.getLastSearchOptions=function(){return this.$search.getOptions()},this.find=function(e,t,n){t||(t={}),typeof e=="string"||e instanceof RegExp?t.needle=e:typeof e=="object"&&r.mixin(t,e);var i=this.selection.getRange();t.needle==null&&(e=this.session.getTextRange(i)||this.$search.$options.needle,e||(i=this.session.getWordRange(i.start.row,i.start.column),e=this.session.getTextRange(i)),this.$search.set({needle:e})),this.$search.set(t),t.start||this.$search.set({start:i});var s=this.$search.find(this.session);if(t.preventScroll)return s;if(s)return this.revealRange(s,n),s;t.backwards?i.start=i.end:i.end=i.start,this.selection.setRange(i)},this.findNext=function(e,t){this.find({skipCurrent:!0,backwards:!1},e,t)},this.findPrevious=function(e,t){this.find(e,{skipCurrent:!0,backwards:!0},t)},this.revealRange=function(e,t){this.session.unfold(e),this.selection.setSelectionRange(e);var n=this.renderer.scrollTop;this.renderer.scrollSelectionIntoView(e.start,e.end,.5),t!==!1&&this.renderer.animateScrolling(n)},this.undo=function(){this.session.getUndoManager().undo(this.session),this.renderer.scrollCursorIntoView(null,.5)},this.redo=function(){this.session.getUndoManager().redo(this.session),this.renderer.scrollCursorIntoView(null,.5)},this.destroy=function(){this.renderer.destroy(),this._signal("destroy",this),this.session&&this.session.destroy()},this.setAutoScrollEditorIntoView=function(e){if(!e)return;var t,n=this,r=!1;this.$scrollAnchor||(this.$scrollAnchor=document.createElement("div"));var i=this.$scrollAnchor;i.style.cssText="position:absolute",this.container.insertBefore(i,this.container.firstChild);var s=this.on("changeSelection",function(){r=!0}),o=this.renderer.on("beforeRender",function(){r&&(t=n.renderer.container.getBoundingClientRect())}),u=this.renderer.on("afterRender",function(){if(r&&t&&(n.isFocused()||n.searchBox&&n.searchBox.isFocused())){var e=n.renderer,s=e.$cursorLayer.$pixelPos,o=e.layerConfig,u=s.top-o.offset;s.top>=0&&u+t.top<0?r=!0:s.top<o.height&&s.top+t.top+o.lineHeight>window.innerHeight?r=!1:r=null,r!=null&&(i.style.top=u+"px",i.style.left=s.left+"px",i.style.height=o.lineHeight+"px",i.scrollIntoView(r)),r=t=null}});this.setAutoScrollEditorIntoView=function(e){if(e)return;delete this.setAutoScrollEditorIntoView,this.off("changeSelection",s),this.renderer.off("afterRender",u),this.renderer.off("beforeRender",o)}},this.$resetCursorStyle=function(){var e=this.$cursorStyle||"ace",t=this.renderer.$cursorLayer;if(!t)return;t.setSmoothBlinking(/smooth/.test(e)),t.isBlinking=!this.$readOnly&&e!="wide",i.setCssClass(t.element,"ace_slim-cursors",/slim/.test(e))},this.prompt=function(e,t,n){var r=this;g.loadModule("./ext/prompt",function(i){i.prompt(r,e,t,n)})}}.call(w.prototype),g.defineOptions(w.prototype,"editor",{selectionStyle:{set:function(e){this.onSelectionChange(),this._signal("changeSelectionStyle",{data:e})},initialValue:"line"},highlightActiveLine:{set:function(){this.$updateHighlightActiveLine()},initialValue:!0},highlightSelectedWord:{set:function(e){this.$onSelectionChange()},initialValue:!0},readOnly:{set:function(e){this.textInput.setReadOnly(e),this.$resetCursorStyle()},initialValue:!1},copyWithEmptySelection:{set:function(e){this.textInput.setCopyWithEmptySelection(e)},initialValue:!1},cursorStyle:{set:function(e){this.$resetCursorStyle()},values:["ace","slim","smooth","wide"],initialValue:"ace"},mergeUndoDeltas:{values:[!1,!0,"always"],initialValue:!0},behavioursEnabled:{initialValue:!0},wrapBehavioursEnabled:{initialValue:!0},autoScrollEditorIntoView:{set:function(e){this.setAutoScrollEditorIntoView(e)}},keyboardHandler:{set:function(e){this.setKeyboardHandler(e)},get:function(){return this.$keybindingId},handlesSet:!0},value:{set:function(e){this.session.setValue(e)},get:function(){return this.getValue()},handlesSet:!0,hidden:!0},session:{set:function(e){this.setSession(e)},get:function(){return this.session},handlesSet:!0,hidden:!0},showLineNumbers:{set:function(e){this.renderer.$gutterLayer.setShowLineNumbers(e),this.renderer.$loop.schedule(this.renderer.CHANGE_GUTTER),e&&this.$relativeLineNumbers?E.attach(this):E.detach(this)},initialValue:!0},relativeLineNumbers:{set:function(e){this.$showLineNumbers&&e?E.attach(this):E.detach(this)}},hScrollBarAlwaysVisible:"renderer",vScrollBarAlwaysVisible:"renderer",highlightGutterLine:"renderer",animatedScroll:"renderer",showInvisibles:"renderer",showPrintMargin:"renderer",printMarginColumn:"renderer",printMargin:"renderer",fadeFoldWidgets:"renderer",showFoldWidgets:"renderer",displayIndentGuides:"renderer",showGutter:"renderer",fontSize:"renderer",fontFamily:"renderer",maxLines:"renderer",minLines:"renderer",scrollPastEnd:"renderer",fixedWidthGutter:"renderer",theme:"renderer",hasCssTransforms:"renderer",maxPixelHeight:"renderer",useTextareaForIME:"renderer",scrollSpeed:"$mouseHandler",dragDelay:"$mouseHandler",dragEnabled:"$mouseHandler",focusTimeout:"$mouseHandler",tooltipFollowsMouse:"$mouseHandler",firstLineNumber:"session",overwrite:"session",newLineMode:"session",useWorker:"session",useSoftTabs:"session",navigateWithinSoftTabs:"session",tabSize:"session",wrap:"session",indentedSoftWrap:"session",foldStyle:"session",mode:"session"});var E={getText:function(e,t){return(Math.abs(e.selection.lead.row-t)||t+1+(t<9?"\u00b7":""))+""},getWidth:function(e,t,n){return Math.max(t.toString().length,(n.lastRow+1).toString().length,2)*n.characterWidth},update:function(e,t){t.renderer.$loop.schedule(t.renderer.CHANGE_GUTTER)},attach:function(e){e.renderer.$gutterLayer.$renderer=this,e.on("changeSelection",this.update),this.update(null,e)},detach:function(e){e.renderer.$gutterLayer.$renderer==this&&(e.renderer.$gutterLayer.$renderer=null),e.off("changeSelection",this.update),this.update(null,e)}};t.Editor=w}),ace.define("ace/undomanager",["require","exports","module","ace/range"],function(e,t,n){"use strict";function i(e,t){for(var n=t;n--;){var r=e[n];if(r&&!r[0].ignore){while(n<t-1){var i=d(e[n],e[n+1]);e[n]=i[0],e[n+1]=i[1],n++}return!0}}}function a(e){var t=e.action=="insert",n=e.start,r=e.end,i=(r.row-n.row)*(t?1:-1),s=(r.column-n.column)*(t?1:-1);t&&(r=n);for(var o in this.marks){var a=this.marks[o],f=u(a,n);if(f<0)continue;if(f===0&&t){if(a.bias!=1){a.bias==-1;continue}f=1}var l=t?f:u(a,r);if(l>0){a.row+=i,a.column+=a.row==r.row?s:0;continue}!t&&l<=0&&(a.row=n.row,a.column=n.column,l===0&&(a.bias=1))}}function f(e){return{row:e.row,column:e.column}}function l(e){return{start:f(e.start),end:f(e.end),action:e.action,lines:e.lines.slice()}}function c(e){e=e||this;if(Array.isArray(e))return e.map(c).join("\n");var t="";e.action?(t=e.action=="insert"?"+":"-",t+="["+e.lines+"]"):e.value&&(Array.isArray(e.value)?t=e.value.map(h).join("\n"):t=h(e.value)),e.start&&(t+=h(e));if(e.id||e.rev)t+="	("+(e.id||e.rev)+")";return t}function h(e){return e.start.row+":"+e.start.column+"=>"+e.end.row+":"+e.end.column}function p(e,t){var n=e.action=="insert",r=t.action=="insert";if(n&&r)if(o(t.start,e.end)>=0)m(t,e,-1);else{if(!(o(t.start,e.start)<=0))return null;m(e,t,1)}else if(n&&!r)if(o(t.start,e.end)>=0)m(t,e,-1);else{if(!(o(t.end,e.start)<=0))return null;m(e,t,-1)}else if(!n&&r)if(o(t.start,e.start)>=0)m(t,e,1);else{if(!(o(t.start,e.start)<=0))return null;m(e,t,1)}else if(!n&&!r)if(o(t.start,e.start)>=0)m(t,e,1);else{if(!(o(t.end,e.start)<=0))return null;m(e,t,-1)}return[t,e]}function d(e,t){for(var n=e.length;n--;)for(var r=0;r<t.length;r++)if(!p(e[n],t[r])){while(n<e.length){while(r--)p(t[r],e[n]);r=t.length,n++}return[e,t]}return e.selectionBefore=t.selectionBefore=e.selectionAfter=t.selectionAfter=null,[t,e]}function v(e,t){var n=e.action=="insert",r=t.action=="insert";if(n&&r)o(e.start,t.start)<0?m(t,e,1):m(e,t,1);else if(n&&!r)o(e.start,t.end)>=0?m(e,t,-1):o(e.start,t.start)<=0?m(t,e,1):(m(e,s.fromPoints(t.start,e.start),-1),m(t,e,1));else if(!n&&r)o(t.start,e.end)>=0?m(t,e,-1):o(t.start,e.start)<=0?m(e,t,1):(m(t,s.fromPoints(e.start,t.start),-1),m(e,t,1));else if(!n&&!r)if(o(t.start,e.end)>=0)m(t,e,-1);else{if(!(o(t.end,e.start)<=0)){var i,u;return o(e.start,t.start)<0&&(i=e,e=y(e,t.start)),o(e.end,t.end)>0&&(u=y(e,t.end)),g(t.end,e.start,e.end,-1),u&&!i&&(e.lines=u.lines,e.start=u.start,e.end=u.end,u=e),[t,i,u].filter(Boolean)}m(e,t,-1)}return[t,e]}function m(e,t,n){g(e.start,t.start,t.end,n),g(e.end,t.start,t.end,n)}function g(e,t,n,r){e.row==(r==1?t:n).row&&(e.column+=r*(n.column-t.column)),e.row+=r*(n.row-t.row)}function y(e,t){var n=e.lines,r=e.end;e.end=f(t);var i=e.end.row-e.start.row,s=n.splice(i,n.length),o=i?t.column:t.column-e.start.column;n.push(s[0].substring(0,o)),s[0]=s[0].substr(o);var u={start:f(t),end:r,lines:s,action:e.action};return u}function b(e,t){t=l(t);for(var n=e.length;n--;){var r=e[n];for(var i=0;i<r.length;i++){var s=r[i],o=v(s,t);t=o[0],o.length!=2&&(o[2]?(r.splice(i+1,1,o[1],o[2]),i++):o[1]||(r.splice(i,1),i--))}r.length||e.splice(n,1)}return e}function w(e,t){for(var n=0;n<t.length;n++){var r=t[n];for(var i=0;i<r.length;i++)b(e,r[i])}}var r=function(){this.$maxRev=0,this.$fromUndo=!1,this.reset()};(function(){this.addSession=function(e){this.$session=e},this.add=function(e,t,n){if(this.$fromUndo)return;if(e==this.$lastDelta)return;if(t===!1||!this.lastDeltas)this.lastDeltas=[],this.$undoStack.push(this.lastDeltas),e.id=this.$rev=++this.$maxRev;if(e.action=="remove"||e.action=="insert")this.$lastDelta=e;this.lastDeltas.push(e)},this.addSelection=function(e,t){this.selections.push({value:e,rev:t||this.$rev})},this.startNewGroup=function(){return this.lastDeltas=null,this.$rev},this.markIgnored=function(e,t){t==null&&(t=this.$rev+1);var n=this.$undoStack;for(var r=n.length;r--;){var i=n[r][0];if(i.id<=e)break;i.id<t&&(i.ignore=!0)}this.lastDeltas=null},this.getSelection=function(e,t){var n=this.selections;for(var r=n.length;r--;){var i=n[r];if(i.rev<e)return t&&(i=n[r+1]),i}},this.getRevision=function(){return this.$rev},this.getDeltas=function(e,t){t==null&&(t=this.$rev+1);var n=this.$undoStack,r=null,i=0;for(var s=n.length;s--;){var o=n[s][0];o.id<t&&!r&&(r=s+1);if(o.id<=e){i=s+1;break}}return n.slice(i,r)},this.getChangedRanges=function(e,t){t==null&&(t=this.$rev+1)},this.getChangedLines=function(e,t){t==null&&(t=this.$rev+1)},this.undo=function(e,t){this.lastDeltas=null;var n=this.$undoStack;if(!i(n,n.length))return;e||(e=this.$session),this.$redoStackBaseRev!==this.$rev&&this.$redoStack.length&&(this.$redoStack=[]),this.$fromUndo=!0;var r=n.pop(),s=null;return r&&r.length&&(s=e.undoChanges(r,t),this.$redoStack.push(r),this.$syncRev()),this.$fromUndo=!1,s},this.redo=function(e,t){this.lastDeltas=null,e||(e=this.$session),this.$fromUndo=!0;if(this.$redoStackBaseRev!=this.$rev){var n=this.getDeltas(this.$redoStackBaseRev,this.$rev+1);w(this.$redoStack,n),this.$redoStackBaseRev=this.$rev,this.$redoStack.forEach(function(e){e[0].id=++this.$maxRev},this)}var r=this.$redoStack.pop(),i=null;return r&&(i=e.redoChanges(r,t),this.$undoStack.push(r),this.$syncRev()),this.$fromUndo=!1,i},this.$syncRev=function(){var e=this.$undoStack,t=e[e.length-1],n=t&&t[0].id||0;this.$redoStackBaseRev=n,this.$rev=n},this.reset=function(){this.lastDeltas=null,this.$lastDelta=null,this.$undoStack=[],this.$redoStack=[],this.$rev=0,this.mark=0,this.$redoStackBaseRev=this.$rev,this.selections=[]},this.canUndo=function(){return this.$undoStack.length>0},this.canRedo=function(){return this.$redoStack.length>0},this.bookmark=function(e){e==undefined&&(e=this.$rev),this.mark=e},this.isAtBookmark=function(){return this.$rev===this.mark},this.toJSON=function(){},this.fromJSON=function(){},this.hasUndo=this.canUndo,this.hasRedo=this.canRedo,this.isClean=this.isAtBookmark,this.markClean=this.bookmark,this.$prettyPrint=function(e){return e?c(e):c(this.$undoStack)+"\n---\n"+c(this.$redoStack)}}).call(r.prototype);var s=e("./range").Range,o=s.comparePoints,u=s.comparePoints;t.UndoManager=r}),ace.define("ace/layer/lines",["require","exports","module","ace/lib/dom"],function(e,t,n){"use strict";var r=e("../lib/dom"),i=function(e,t){this.element=e,this.canvasHeight=t||5e5,this.element.style.height=this.canvasHeight*2+"px",this.cells=[],this.cellCache=[],this.$offsetCoefficient=0};(function(){this.moveContainer=function(e){r.translate(this.element,0,-(e.firstRowScreen*e.lineHeight%this.canvasHeight)-e.offset*this.$offsetCoefficient)},this.pageChanged=function(e,t){return Math.floor(e.firstRowScreen*e.lineHeight/this.canvasHeight)!==Math.floor(t.firstRowScreen*t.lineHeight/this.canvasHeight)},this.computeLineTop=function(e,t,n){var r=t.firstRowScreen*t.lineHeight,i=Math.floor(r/this.canvasHeight),s=n.documentToScreenRow(e,0)*t.lineHeight;return s-i*this.canvasHeight},this.computeLineHeight=function(e,t,n){return t.lineHeight*n.getRowLength(e)},this.getLength=function(){return this.cells.length},this.get=function(e){return this.cells[e]},this.shift=function(){this.$cacheCell(this.cells.shift())},this.pop=function(){this.$cacheCell(this.cells.pop())},this.push=function(e){if(Array.isArray(e)){this.cells.push.apply(this.cells,e);var t=r.createFragment(this.element);for(var n=0;n<e.length;n++)t.appendChild(e[n].element);this.element.appendChild(t)}else this.cells.push(e),this.element.appendChild(e.element)},this.unshift=function(e){if(Array.isArray(e)){this.cells.unshift.apply(this.cells,e);var t=r.createFragment(this.element);for(var n=0;n<e.length;n++)t.appendChild(e[n].element);this.element.firstChild?this.element.insertBefore(t,this.element.firstChild):this.element.appendChild(t)}else this.cells.unshift(e),this.element.insertAdjacentElement("afterbegin",e.element)},this.last=function(){return this.cells.length?this.cells[this.cells.length-1]:null},this.$cacheCell=function(e){if(!e)return;e.element.remove(),this.cellCache.push(e)},this.createCell=function(e,t,n,i){var s=this.cellCache.pop();if(!s){var o=r.createElement("div");i&&i(o),this.element.appendChild(o),s={element:o,text:"",row:e}}return s.row=e,s}}).call(i.prototype),t.Lines=i}),ace.define("ace/layer/gutter",["require","exports","module","ace/lib/dom","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/layer/lines"],function(e,t,n){"use strict";function f(e){var t=document.createTextNode("");e.appendChild(t);var n=r.createElement("span");return e.appendChild(n),e}var r=e("../lib/dom"),i=e("../lib/oop"),s=e("../lib/lang"),o=e("../lib/event_emitter").EventEmitter,u=e("./lines").Lines,a=function(e){this.element=r.createElement("div"),this.element.className="ace_layer ace_gutter-layer",e.appendChild(this.element),this.setShowFoldWidgets(this.$showFoldWidgets),this.gutterWidth=0,this.$annotations=[],this.$updateAnnotations=this.$updateAnnotations.bind(this),this.$lines=new u(this.element),this.$lines.$offsetCoefficient=1};(function(){i.implement(this,o),this.setSession=function(e){this.session&&this.session.removeEventListener("change",this.$updateAnnotations),this.session=e,e&&e.on("change",this.$updateAnnotations)},this.addGutterDecoration=function(e,t){window.console&&console.warn&&console.warn("deprecated use session.addGutterDecoration"),this.session.addGutterDecoration(e,t)},this.removeGutterDecoration=function(e,t){window.console&&console.warn&&console.warn("deprecated use session.removeGutterDecoration"),this.session.removeGutterDecoration(e,t)},this.setAnnotations=function(e){this.$annotations=[];for(var t=0;t<e.length;t++){var n=e[t],r=n.row,i=this.$annotations[r];i||(i=this.$annotations[r]={text:[]});var o=n.text;o=o?s.escapeHTML(o):n.html||"",i.text.indexOf(o)===-1&&i.text.push(o);var u=n.type;u=="error"?i.className=" ace_error":u=="warning"&&i.className!=" ace_error"?i.className=" ace_warning":u=="info"&&!i.className&&(i.className=" ace_info")}},this.$updateAnnotations=function(e){if(!this.$annotations.length)return;var t=e.start.row,n=e.end.row-t;if(n!==0)if(e.action=="remove")this.$annotations.splice(t,n+1,null);else{var r=new Array(n+1);r.unshift(t,1),this.$annotations.splice.apply(this.$annotations,r)}},this.update=function(e){this.config=e;var t=this.session,n=e.firstRow,r=Math.min(e.lastRow+e.gutterOffset,t.getLength()-1);this.oldLastRow=r,this.config=e,this.$lines.moveContainer(e),this.$updateCursorRow();var i=t.getNextFoldLine(n),s=i?i.start.row:Infinity,o=null,u=-1,a=n;for(;;){a>s&&(a=i.end.row+1,i=t.getNextFoldLine(a,i),s=i?i.start.row:Infinity);if(a>r){while(this.$lines.getLength()>u+1)this.$lines.pop();break}o=this.$lines.get(++u),o?o.row=a:(o=this.$lines.createCell(a,e,this.session,f),this.$lines.push(o)),this.$renderCell(o,e,i,a),a++}this._signal("afterRender"),this.$updateGutterWidth(e)},this.$updateGutterWidth=function(e){var t=this.session,n=t.gutterRenderer||this.$renderer,r=t.$firstLineNumber,i=this.$lines.last()?this.$lines.last().text:"";if(this.$fixedWidth||t.$useWrapMode)i=t.getLength()+r-1;var s=n?n.getWidth(t,i,e):i.toString().length*e.characterWidth,o=this.$padding||this.$computePadding();s+=o.left+o.right,s!==this.gutterWidth&&!isNaN(s)&&(this.gutterWidth=s,this.element.parentNode.style.width=this.element.style.width=Math.ceil(this.gutterWidth)+"px",this._signal("changeGutterWidth",s))},this.$updateCursorRow=function(){if(!this.$highlightGutterLine)return;var e=this.session.selection.getCursor();if(this.$cursorRow===e.row)return;this.$cursorRow=e.row},this.updateLineHighlight=function(){if(!this.$highlightGutterLine)return;var e=this.session.selection.cursor.row;this.$cursorRow=e;if(this.$cursorCell&&this.$cursorCell.row==e)return;this.$cursorCell&&(this.$cursorCell.element.className=this.$cursorCell.element.className.replace("ace_gutter-active-line ",""));var t=this.$lines.cells;this.$cursorCell=null;for(var n=0;n<t.length;n++){var r=t[n];if(r.row>=this.$cursorRow){if(r.row>this.$cursorRow){var i=this.session.getFoldLine(this.$cursorRow);if(!(n>0&&i&&i.start.row==t[n-1].row))break;r=t[n-1]}r.element.className="ace_gutter-active-line "+r.element.className,this.$cursorCell=r;break}}},this.scrollLines=function(e){var t=this.config;this.config=e,this.$updateCursorRow();if(this.$lines.pageChanged(t,e))return this.update(e);this.$lines.moveContainer(e);var n=Math.min(e.lastRow+e.gutterOffset,this.session.getLength()-1),r=this.oldLastRow;this.oldLastRow=n;if(!t||r<e.firstRow)return this.update(e);if(n<t.firstRow)return this.update(e);if(t.firstRow<e.firstRow)for(var i=this.session.getFoldedRowCount(t.firstRow,e.firstRow-1);i>0;i--)this.$lines.shift();if(r>n)for(var i=this.session.getFoldedRowCount(n+1,r);i>0;i--)this.$lines.pop();e.firstRow<t.firstRow&&this.$lines.unshift(this.$renderLines(e,e.firstRow,t.firstRow-1)),n>r&&this.$lines.push(this.$renderLines(e,r+1,n)),this.updateLineHighlight(),this._signal("afterRender"),this.$updateGutterWidth(e)},this.$renderLines=function(e,t,n){var r=[],i=t,s=this.session.getNextFoldLine(i),o=s?s.start.row:Infinity;for(;;){i>o&&(i=s.end.row+1,s=this.session.getNextFoldLine(i,s),o=s?s.start.row:Infinity);if(i>n)break;var u=this.$lines.createCell(i,e,this.session,f);this.$renderCell(u,e,s,i),r.push(u),i++}return r},this.$renderCell=function(e,t,n,i){var s=e.element,o=this.session,u=s.childNodes[0],a=s.childNodes[1],f=o.$firstLineNumber,l=o.$breakpoints,c=o.$decorations,h=o.gutterRenderer||this.$renderer,p=this.$showFoldWidgets&&o.foldWidgets,d=n?n.start.row:Number.MAX_VALUE,v="ace_gutter-cell ";this.$highlightGutterLine&&(i==this.$cursorRow||n&&i<this.$cursorRow&&i>=d&&this.$cursorRow<=n.end.row)&&(v+="ace_gutter-active-line ",this.$cursorCell!=e&&(this.$cursorCell&&(this.$cursorCell.element.className=this.$cursorCell.element.className.replace("ace_gutter-active-line ","")),this.$cursorCell=e)),l[i]&&(v+=l[i]),c[i]&&(v+=c[i]),this.$annotations[i]&&(v+=this.$annotations[i].className),s.className!=v&&(s.className=v);if(p){var m=p[i];m==null&&(m=p[i]=o.getFoldWidget(i))}if(m){var v="ace_fold-widget ace_"+m;m=="start"&&i==d&&i<n.end.row?v+=" ace_closed":v+=" ace_open",a.className!=v&&(a.className=v);var g=t.lineHeight+"px";r.setStyle(a.style,"height",g),r.setStyle(a.style,"display","inline-block")}else a&&r.setStyle(a.style,"display","none");var y=(h?h.getText(o,i):i+f).toString();return y!==u.data&&(u.data=y),r.setStyle(e.element.style,"height",this.$lines.computeLineHeight(i,t,o)+"px"),r.setStyle(e.element.style,"top",this.$lines.computeLineTop(i,t,o)+"px"),e.text=y,e},this.$fixedWidth=!1,this.$highlightGutterLine=!0,this.$renderer="",this.setHighlightGutterLine=function(e){this.$highlightGutterLine=e},this.$showLineNumbers=!0,this.$renderer="",this.setShowLineNumbers=function(e){this.$renderer=!e&&{getWidth:function(){return 0},getText:function(){return""}}},this.getShowLineNumbers=function(){return this.$showLineNumbers},this.$showFoldWidgets=!0,this.setShowFoldWidgets=function(e){e?r.addCssClass(this.element,"ace_folding-enabled"):r.removeCssClass(this.element,"ace_folding-enabled"),this.$showFoldWidgets=e,this.$padding=null},this.getShowFoldWidgets=function(){return this.$showFoldWidgets},this.$computePadding=function(){if(!this.element.firstChild)return{left:0,right:0};var e=r.computedStyle(this.element.firstChild);return this.$padding={},this.$padding.left=(parseInt(e.borderLeftWidth)||0)+(parseInt(e.paddingLeft)||0)+1,this.$padding.right=(parseInt(e.borderRightWidth)||0)+(parseInt(e.paddingRight)||0),this.$padding},this.getRegion=function(e){var t=this.$padding||this.$computePadding(),n=this.element.getBoundingClientRect();if(e.x<t.left+n.left)return"markers";if(this.$showFoldWidgets&&e.x>n.right-t.right)return"foldWidgets"}}).call(a.prototype),t.Gutter=a}),ace.define("ace/layer/marker",["require","exports","module","ace/range","ace/lib/dom"],function(e,t,n){"use strict";var r=e("../range").Range,i=e("../lib/dom"),s=function(e){this.element=i.createElement("div"),this.element.className="ace_layer ace_marker-layer",e.appendChild(this.element)};(function(){function e(e,t,n,r){return(e?1:0)|(t?2:0)|(n?4:0)|(r?8:0)}this.$padding=0,this.setPadding=function(e){this.$padding=e},this.setSession=function(e){this.session=e},this.setMarkers=function(e){this.markers=e},this.elt=function(e,t){var n=this.i!=-1&&this.element.childNodes[this.i];n?this.i++:(n=document.createElement("div"),this.element.appendChild(n),this.i=-1),n.style.cssText=t,n.className=e},this.update=function(e){if(!e)return;this.config=e,this.i=0;var t;for(var n in this.markers){var r=this.markers[n];if(!r.range){r.update(t,this,this.session,e);continue}var i=r.range.clipRows(e.firstRow,e.lastRow);if(i.isEmpty())continue;i=i.toScreenRange(this.session);if(r.renderer){var s=this.$getTop(i.start.row,e),o=this.$padding+i.start.column*e.characterWidth;r.renderer(t,i,o,s,e)}else r.type=="fullLine"?this.drawFullLineMarker(t,i,r.clazz,e):r.type=="screenLine"?this.drawScreenLineMarker(t,i,r.clazz,e):i.isMultiLine()?r.type=="text"?this.drawTextMarker(t,i,r.clazz,e):this.drawMultiLineMarker(t,i,r.clazz,e):this.drawSingleLineMarker(t,i,r.clazz+" ace_start"+" ace_br15",e)}if(this.i!=-1)while(this.i<this.element.childElementCount)this.element.removeChild(this.element.lastChild)},this.$getTop=function(e,t){return(e-t.firstRowScreen)*t.lineHeight},this.drawTextMarker=function(t,n,i,s,o){var u=this.session,a=n.start.row,f=n.end.row,l=a,c=0,h=0,p=u.getScreenLastRowColumn(l),d=new r(l,n.start.column,l,h);for(;l<=f;l++)d.start.row=d.end.row=l,d.start.column=l==a?n.start.column:u.getRowWrapIndent(l),d.end.column=p,c=h,h=p,p=l+1<f?u.getScreenLastRowColumn(l+1):l==f?0:n.end.column,this.drawSingleLineMarker(t,d,i+(l==a?" ace_start":"")+" ace_br"+e(l==a||l==a+1&&n.start.column,c<h,h>p,l==f),s,l==f?0:1,o)},this.drawMultiLineMarker=function(e,t,n,r,i){var s=this.$padding,o=r.lineHeight,u=this.$getTop(t.start.row,r),a=s+t.start.column*r.characterWidth;i=i||"";if(this.session.$bidiHandler.isBidiRow(t.start.row)){var f=t.clone();f.end.row=f.start.row,f.end.column=this.session.getLine(f.start.row).length,this.drawBidiSingleLineMarker(e,f,n+" ace_br1 ace_start",r,null,i)}else this.elt(n+" ace_br1 ace_start","height:"+o+"px;"+"right:0;"+"top:"+u+"px;left:"+a+"px;"+(i||""));if(this.session.$bidiHandler.isBidiRow(t.end.row)){var f=t.clone();f.start.row=f.end.row,f.start.column=0,this.drawBidiSingleLineMarker(e,f,n+" ace_br12",r,null,i)}else{u=this.$getTop(t.end.row,r);var l=t.end.column*r.characterWidth;this.elt(n+" ace_br12","height:"+o+"px;"+"width:"+l+"px;"+"top:"+u+"px;"+"left:"+s+"px;"+(i||""))}o=(t.end.row-t.start.row-1)*r.lineHeight;if(o<=0)return;u=this.$getTop(t.start.row+1,r);var c=(t.start.column?1:0)|(t.end.column?0:8);this.elt(n+(c?" ace_br"+c:""),"height:"+o+"px;"+"right:0;"+"top:"+u+"px;"+"left:"+s+"px;"+(i||""))},this.drawSingleLineMarker=function(e,t,n,r,i,s){if(this.session.$bidiHandler.isBidiRow(t.start.row))return this.drawBidiSingleLineMarker(e,t,n,r,i,s);var o=r.lineHeight,u=(t.end.column+(i||0)-t.start.column)*r.characterWidth,a=this.$getTop(t.start.row,r),f=this.$padding+t.start.column*r.characterWidth;this.elt(n,"height:"+o+"px;"+"width:"+u+"px;"+"top:"+a+"px;"+"left:"+f+"px;"+(s||""))},this.drawBidiSingleLineMarker=function(e,t,n,r,i,s){var o=r.lineHeight,u=this.$getTop(t.start.row,r),a=this.$padding,f=this.session.$bidiHandler.getSelections(t.start.column,t.end.column);f.forEach(function(e){this.elt(n,"height:"+o+"px;"+"width:"+e.width+(i||0)+"px;"+"top:"+u+"px;"+"left:"+(a+e.left)+"px;"+(s||""))},this)},this.drawFullLineMarker=function(e,t,n,r,i){var s=this.$getTop(t.start.row,r),o=r.lineHeight;t.start.row!=t.end.row&&(o+=this.$getTop(t.end.row,r)-s),this.elt(n,"height:"+o+"px;"+"top:"+s+"px;"+"left:0;right:0;"+(i||""))},this.drawScreenLineMarker=function(e,t,n,r,i){var s=this.$getTop(t.start.row,r),o=r.lineHeight;this.elt(n,"height:"+o+"px;"+"top:"+s+"px;"+"left:0;right:0;"+(i||""))}}).call(s.prototype),t.Marker=s}),ace.define("ace/layer/text",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/lib/lang","ace/layer/lines","ace/lib/event_emitter"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("../lib/dom"),s=e("../lib/lang"),o=e("./lines").Lines,u=e("../lib/event_emitter").EventEmitter,a=function(e){this.dom=i,this.element=this.dom.createElement("div"),this.element.className="ace_layer ace_text-layer",e.appendChild(this.element),this.$updateEolChar=this.$updateEolChar.bind(this),this.$lines=new o(this.element)};(function(){r.implement(this,u),this.EOF_CHAR="\u00b6",this.EOL_CHAR_LF="\u00ac",this.EOL_CHAR_CRLF="\u00a4",this.EOL_CHAR=this.EOL_CHAR_LF,this.TAB_CHAR="\u2014",this.SPACE_CHAR="\u00b7",this.$padding=0,this.MAX_LINE_LENGTH=1e4,this.$updateEolChar=function(){var e=this.session.doc,t=e.getNewLineCharacter()=="\n"&&e.getNewLineMode()!="windows",n=t?this.EOL_CHAR_LF:this.EOL_CHAR_CRLF;if(this.EOL_CHAR!=n)return this.EOL_CHAR=n,!0},this.setPadding=function(e){this.$padding=e,this.element.style.margin="0 "+e+"px"},this.getLineHeight=function(){return this.$fontMetrics.$characterSize.height||0},this.getCharacterWidth=function(){return this.$fontMetrics.$characterSize.width||0},this.$setFontMetrics=function(e){this.$fontMetrics=e,this.$fontMetrics.on("changeCharacterSize",function(e){this._signal("changeCharacterSize",e)}.bind(this)),this.$pollSizeChanges()},this.checkForSizeChanges=function(){this.$fontMetrics.checkForSizeChanges()},this.$pollSizeChanges=function(){return this.$pollSizeChangesTimer=this.$fontMetrics.$pollSizeChanges()},this.setSession=function(e){this.session=e,e&&this.$computeTabString()},this.showInvisibles=!1,this.setShowInvisibles=function(e){return this.showInvisibles==e?!1:(this.showInvisibles=e,this.$computeTabString(),!0)},this.displayIndentGuides=!0,this.setDisplayIndentGuides=function(e){return this.displayIndentGuides==e?!1:(this.displayIndentGuides=e,this.$computeTabString(),!0)},this.$tabStrings=[],this.onChangeTabSize=this.$computeTabString=function(){var e=this.session.getTabSize();this.tabSize=e;var t=this.$tabStrings=[0];for(var n=1;n<e+1;n++)if(this.showInvisibles){var r=this.dom.createElement("span");r.className="ace_invisible ace_invisible_tab",r.textContent=s.stringRepeat(this.TAB_CHAR,n),t.push(r)}else t.push(this.dom.createTextNode(s.stringRepeat(" ",n),this.element));if(this.displayIndentGuides){this.$indentGuideRe=/\s\S| \t|\t |\s$/;var i="ace_indent-guide",o="",u="";if(this.showInvisibles){i+=" ace_invisible",o=" ace_invisible_space",u=" ace_invisible_tab";var a=s.stringRepeat(this.SPACE_CHAR,this.tabSize),f=s.stringRepeat(this.TAB_CHAR,this.tabSize)}else var a=s.stringRepeat(" ",this.tabSize),f=a;var r=this.dom.createElement("span");r.className=i+o,r.textContent=a,this.$tabStrings[" "]=r;var r=this.dom.createElement("span");r.className=i+u,r.textContent=f,this.$tabStrings["	"]=r}},this.updateLines=function(e,t,n){if(this.config.lastRow!=e.lastRow||this.config.firstRow!=e.firstRow)return this.update(e);this.config=e;var r=Math.max(t,e.firstRow),i=Math.min(n,e.lastRow),s=this.element.childNodes,o=0;for(var u=e.firstRow;u<r;u++){var a=this.session.getFoldLine(u);if(a){if(a.containsRow(r)){r=a.start.row;break}u=a.end.row}o++}var f=!1,u=r,a=this.session.getNextFoldLine(u),l=a?a.start.row:Infinity;for(;;){u>l&&(u=a.end.row+1,a=this.session.getNextFoldLine(u,a),l=a?a.start.row:Infinity);if(u>i)break;var c=s[o++];if(c){this.dom.removeChildren(c),this.$renderLine(c,u,u==l?a:!1),f&&(c.style.top=this.$lines.computeLineTop(u,e,this.session)+"px");var h=e.lineHeight*this.session.getRowLength(u)+"px";c.style.height!=h&&(f=!0,c.style.height=h)}u++}if(f)while(o<this.$lines.cells.length){var p=this.$lines.cells[o++];p.element.style.top=this.$lines.computeLineTop(p.row,e,this.session)+"px"}},this.scrollLines=function(e){var t=this.config;this.config=e;if(this.$lines.pageChanged(t,e))return this.update(e);this.$lines.moveContainer(e);var n=e.lastRow,r=t?t.lastRow:-1;if(!t||r<e.firstRow)return this.update(e);if(n<t.firstRow)return this.update(e);if(!t||t.lastRow<e.firstRow)return this.update(e);if(e.lastRow<t.firstRow)return this.update(e);if(t.firstRow<e.firstRow)for(var i=this.session.getFoldedRowCount(t.firstRow,e.firstRow-1);i>0;i--)this.$lines.shift();if(t.lastRow>e.lastRow)for(var i=this.session.getFoldedRowCount(e.lastRow+1,t.lastRow);i>0;i--)this.$lines.pop();e.firstRow<t.firstRow&&this.$lines.unshift(this.$renderLinesFragment(e,e.firstRow,t.firstRow-1)),e.lastRow>t.lastRow&&this.$lines.push(this.$renderLinesFragment(e,t.lastRow+1,e.lastRow))},this.$renderLinesFragment=function(e,t,n){var r=[],s=t,o=this.session.getNextFoldLine(s),u=o?o.start.row:Infinity;for(;;){s>u&&(s=o.end.row+1,o=this.session.getNextFoldLine(s,o),u=o?o.start.row:Infinity);if(s>n)break;var a=this.$lines.createCell(s,e,this.session),f=a.element;this.dom.removeChildren(f),i.setStyle(f.style,"height",this.$lines.computeLineHeight(s,e,this.session)+"px"),i.setStyle(f.style,"top",this.$lines.computeLineTop(s,e,this.session)+"px"),this.$renderLine(f,s,s==u?o:!1),this.$useLineGroups()?f.className="ace_line_group":f.className="ace_line",r.push(a),s++}return r},this.update=function(e){this.$lines.moveContainer(e),this.config=e;var t=e.firstRow,n=e.lastRow,r=this.$lines;while(r.getLength())r.pop();r.push(this.$renderLinesFragment(e,t,n))},this.$textToken={text:!0,rparen:!0,lparen:!0},this.$renderToken=function(e,t,n,r){var i=this,o=/(\t)|( +)|([\x00-\x1f\x80-\xa0\xad\u1680\u180E\u2000-\u200f\u2028\u2029\u202F\u205F\uFEFF\uFFF9-\uFFFC]+)|(\u3000)|([\u1100-\u115F\u11A3-\u11A7\u11FA-\u11FF\u2329-\u232A\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3001-\u303E\u3041-\u3096\u3099-\u30FF\u3105-\u312D\u3131-\u318E\u3190-\u31BA\u31C0-\u31E3\u31F0-\u321E\u3220-\u3247\u3250-\u32FE\u3300-\u4DBF\u4E00-\uA48C\uA490-\uA4C6\uA960-\uA97C\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE66\uFE68-\uFE6B\uFF01-\uFF60\uFFE0-\uFFE6]|[\uD800-\uDBFF][\uDC00-\uDFFF])/g,u=this.dom.createFragment(this.element),a,f=0;while(a=o.exec(r)){var l=a[1],c=a[2],h=a[3],p=a[4],d=a[5];if(!i.showInvisibles&&c)continue;var v=f!=a.index?r.slice(f,a.index):"";f=a.index+a[0].length,v&&u.appendChild(this.dom.createTextNode(v,this.element));if(l){var m=i.session.getScreenTabSize(t+a.index);u.appendChild(i.$tabStrings[m].cloneNode(!0)),t+=m-1}else if(c)if(i.showInvisibles){var g=this.dom.createElement("span");g.className="ace_invisible ace_invisible_space",g.textContent=s.stringRepeat(i.SPACE_CHAR,c.length),u.appendChild(g)}else u.appendChild(this.com.createTextNode(c,this.element));else if(h){var g=this.dom.createElement("span");g.className="ace_invisible ace_invisible_space ace_invalid",g.textContent=s.stringRepeat(i.SPACE_CHAR,h.length),u.appendChild(g)}else if(p){t+=1;var g=this.dom.createElement("span");g.style.width=i.config.characterWidth*2+"px",g.className=i.showInvisibles?"ace_cjk ace_invisible ace_invisible_space":"ace_cjk",g.textContent=i.showInvisibles?i.SPACE_CHAR:p,u.appendChild(g)}else if(d){t+=1;var g=this.dom.createElement("span");g.style.width=i.config.characterWidth*2+"px",g.className="ace_cjk",g.textContent=d,u.appendChild(g)}}u.appendChild(this.dom.createTextNode(f?r.slice(f):r,this.element));if(!this.$textToken[n.type]){var y="ace_"+n.type.replace(/\./g," ace_"),g=this.dom.createElement("span");n.type=="fold"&&(g.style.width=n.value.length*this.config.characterWidth+"px"),g.className=y,g.appendChild(u),e.appendChild(g)}else e.appendChild(u);return t+r.length},this.renderIndentGuide=function(e,t,n){var r=t.search(this.$indentGuideRe);if(r<=0||r>=n)return t;if(t[0]==" "){r-=r%this.tabSize;var i=r/this.tabSize;for(var s=0;s<i;s++)e.appendChild(this.$tabStrings[" "].cloneNode(!0));return t.substr(r)}if(t[0]=="	"){for(var s=0;s<r;s++)e.appendChild(this.$tabStrings["	"].cloneNode(!0));return t.substr(r)}return t},this.$createLineElement=function(e){var t=this.dom.createElement("div");return t.className="ace_line",t.style.height=this.config.lineHeight+"px",t},this.$renderWrappedLine=function(e,t,n){var r=0,i=0,o=n[0],u=0,a=this.$createLineElement();e.appendChild(a);for(var f=0;f<t.length;f++){var l=t[f],c=l.value;if(f==0&&this.displayIndentGuides){r=c.length,c=this.renderIndentGuide(a,c,o);if(!c)continue;r-=c.length}if(r+c.length<o)u=this.$renderToken(a,u,l,c),r+=c.length;else{while(r+c.length>=o)u=this.$renderToken(a,u,l,c.substring(0,o-r)),c=c.substring(o-r),r=o,a=this.$createLineElement(),e.appendChild(a),a.appendChild(this.dom.createTextNode(s.stringRepeat("\u00a0",n.indent),this.element)),i++,u=0,o=n[i]||Number.MAX_VALUE;c.length!=0&&(r+=c.length,u=this.$renderToken(a,u,l,c))}}n[n.length-1]>this.MAX_LINE_LENGTH&&this.$renderOverflowMessage(a,u,null,"",!0)},this.$renderSimpleLine=function(e,t){var n=0,r=t[0],i=r.value;this.displayIndentGuides&&(i=this.renderIndentGuide(e,i)),i&&(n=this.$renderToken(e,n,r,i));for(var s=1;s<t.length;s++){r=t[s],i=r.value;if(n+i.length>this.MAX_LINE_LENGTH)return this.$renderOverflowMessage(e,n,r,i);n=this.$renderToken(e,n,r,i)}},this.$renderOverflowMessage=function(e,t,n,r,i){n&&this.$renderToken(e,t,n,r.slice(0,this.MAX_LINE_LENGTH-t));var s=this.dom.createElement("span");s.className="ace_inline_button ace_keyword ace_toggle_wrap",s.textContent=i?"<hide>":"<click to see more...>",e.appendChild(s)},this.$renderLine=function(e,t,n){!n&&n!=0&&(n=this.session.getFoldLine(t));if(n)var r=this.$getFoldLineTokens(t,n);else var r=this.session.getTokens(t);var i=e;if(r.length){var s=this.session.getRowSplitData(t);if(s&&s.length){this.$renderWrappedLine(e,r,s);var i=e.lastChild}else{var i=e;this.$useLineGroups()&&(i=this.$createLineElement(),e.appendChild(i)),this.$renderSimpleLine(i,r)}}else this.$useLineGroups()&&(i=this.$createLineElement(),e.appendChild(i));if(this.showInvisibles&&i){n&&(t=n.end.row);var o=this.dom.createElement("span");o.className="ace_invisible ace_invisible_eol",o.textContent=t==this.session.getLength()-1?this.EOF_CHAR:this.EOL_CHAR,i.appendChild(o)}},this.$getFoldLineTokens=function(e,t){function i(e,t,n){var i=0,s=0;while(s+e[i].value.length<t){s+=e[i].value.length,i++;if(i==e.length)return}if(s!=t){var o=e[i].value.substring(t-s);o.length>n-t&&(o=o.substring(0,n-t)),r.push({type:e[i].type,value:o}),s=t+o.length,i+=1}while(s<n&&i<e.length){var o=e[i].value;o.length+s>n?r.push({type:e[i].type,value:o.substring(0,n-s)}):r.push(e[i]),s+=o.length,i+=1}}var n=this.session,r=[],s=n.getTokens(e);return t.walk(function(e,t,o,u,a){e!=null?r.push({type:"fold",value:e}):(a&&(s=n.getTokens(t)),s.length&&i(s,u,o))},t.end.row,this.session.getLine(t.end.row).length),r},this.$useLineGroups=function(){return this.session.getUseWrapMode()},this.destroy=function(){}}).call(a.prototype),t.Text=a}),ace.define("ace/layer/cursor",["require","exports","module","ace/lib/dom"],function(e,t,n){"use strict";var r=e("../lib/dom"),i=function(e){this.element=r.createElement("div"),this.element.className="ace_layer ace_cursor-layer",e.appendChild(this.element),this.isVisible=!1,this.isBlinking=!0,this.blinkInterval=1e3,this.smoothBlinking=!1,this.cursors=[],this.cursor=this.addCursor(),r.addCssClass(this.element,"ace_hidden-cursors"),this.$updateCursors=this.$updateOpacity.bind(this)};(function(){this.$updateOpacity=function(e){var t=this.cursors;for(var n=t.length;n--;)r.setStyle(t[n].style,"opacity",e?"":"0")},this.$startCssAnimation=function(){var e=this.cursors;for(var t=e.length;t--;)e[t].style.animationDuration=this.blinkInterval+"ms";setTimeout(function(){r.addCssClass(this.element,"ace_animate-blinking")}.bind(this))},this.$stopCssAnimation=function(){r.removeCssClass(this.element,"ace_animate-blinking")},this.$padding=0,this.setPadding=function(e){this.$padding=e},this.setSession=function(e){this.session=e},this.setBlinking=function(e){e!=this.isBlinking&&(this.isBlinking=e,this.restartTimer())},this.setBlinkInterval=function(e){e!=this.blinkInterval&&(this.blinkInterval=e,this.restartTimer())},this.setSmoothBlinking=function(e){e!=this.smoothBlinking&&(this.smoothBlinking=e,r.setCssClass(this.element,"ace_smooth-blinking",e),this.$updateCursors(!0),this.restartTimer())},this.addCursor=function(){var e=r.createElement("div");return e.className="ace_cursor",this.element.appendChild(e),this.cursors.push(e),e},this.removeCursor=function(){if(this.cursors.length>1){var e=this.cursors.pop();return e.parentNode.removeChild(e),e}},this.hideCursor=function(){this.isVisible=!1,r.addCssClass(this.element,"ace_hidden-cursors"),this.restartTimer()},this.showCursor=function(){this.isVisible=!0,r.removeCssClass(this.element,"ace_hidden-cursors"),this.restartTimer()},this.restartTimer=function(){var e=this.$updateCursors;clearInterval(this.intervalId),clearTimeout(this.timeoutId),this.$stopCssAnimation(),this.smoothBlinking&&r.removeCssClass(this.element,"ace_smooth-blinking"),e(!0);if(!this.isBlinking||!this.blinkInterval||!this.isVisible){this.$stopCssAnimation();return}this.smoothBlinking&&setTimeout(function(){r.addCssClass(this.element,"ace_smooth-blinking")}.bind(this));if(r.HAS_CSS_ANIMATION)this.$startCssAnimation();else{var t=function(){this.timeoutId=setTimeout(function(){e(!1)},.6*this.blinkInterval)}.bind(this);this.intervalId=setInterval(function(){e(!0),t()},this.blinkInterval),t()}},this.getPixelPosition=function(e,t){if(!this.config||!this.session)return{left:0,top:0};e||(e=this.session.selection.getCursor());var n=this.session.documentToScreenPosition(e),r=this.$padding+(this.session.$bidiHandler.isBidiRow(n.row,e.row)?this.session.$bidiHandler.getPosLeft(n.column):n.column*this.config.characterWidth),i=(n.row-(t?this.config.firstRowScreen:0))*this.config.lineHeight;return{left:r,top:i}},this.isCursorInView=function(e,t){return e.top>=0&&e.top<t.maxHeight},this.update=function(e){this.config=e;var t=this.session.$selectionMarkers,n=0,i=0;if(t===undefined||t.length===0)t=[{cursor:null}];for(var n=0,s=t.length;n<s;n++){var o=this.getPixelPosition(t[n].cursor,!0);if((o.top>e.height+e.offset||o.top<0)&&n>1)continue;var u=this.cursors[i++]||this.addCursor(),a=u.style;this.drawCursor?this.drawCursor(u,o,e,t[n],this.session):this.isCursorInView(o,e)?(r.setStyle(a,"display","block"),r.translate(u,o.left,o.top),r.setStyle(a,"width",Math.round(e.characterWidth)+"px"),r.setStyle(a,"height",e.lineHeight+"px")):r.setStyle(a,"display","none")}while(this.cursors.length>i)this.removeCursor();var f=this.session.getOverwrite();this.$setOverwrite(f),this.$pixelPos=o,this.restartTimer()},this.drawCursor=null,this.$setOverwrite=function(e){e!=this.overwrite&&(this.overwrite=e,e?r.addCssClass(this.element,"ace_overwrite-cursors"):r.removeCssClass(this.element,"ace_overwrite-cursors"))},this.destroy=function(){clearInterval(this.intervalId),clearTimeout(this.timeoutId)}}).call(i.prototype),t.Cursor=i}),ace.define("ace/scrollbar",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/lib/event","ace/lib/event_emitter"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./lib/dom"),s=e("./lib/event"),o=e("./lib/event_emitter").EventEmitter,u=32768,a=function(e){this.element=i.createElement("div"),this.element.className="ace_scrollbar ace_scrollbar"+this.classSuffix,this.inner=i.createElement("div"),this.inner.className="ace_scrollbar-inner",this.inner.textContent="\u00a0",this.element.appendChild(this.inner),e.appendChild(this.element),this.setVisible(!1),this.skipEvent=!1,s.addListener(this.element,"scroll",this.onScroll.bind(this)),s.addListener(this.element,"mousedown",s.preventDefault)};(function(){r.implement(this,o),this.setVisible=function(e){this.element.style.display=e?"":"none",this.isVisible=e,this.coeff=1}}).call(a.prototype);var f=function(e,t){a.call(this,e),this.scrollTop=0,this.scrollHeight=0,t.$scrollbarWidth=this.width=i.scrollbarWidth(e.ownerDocument),this.inner.style.width=this.element.style.width=(this.width||15)+5+"px",this.$minWidth=0};r.inherits(f,a),function(){this.classSuffix="-v",this.onScroll=function(){if(!this.skipEvent){this.scrollTop=this.element.scrollTop;if(this.coeff!=1){var e=this.element.clientHeight/this.scrollHeight;this.scrollTop=this.scrollTop*(1-e)/(this.coeff-e)}this._emit("scroll",{data:this.scrollTop})}this.skipEvent=!1},this.getWidth=function(){return Math.max(this.isVisible?this.width:0,this.$minWidth||0)},this.setHeight=function(e){this.element.style.height=e+"px"},this.setInnerHeight=this.setScrollHeight=function(e){this.scrollHeight=e,e>u?(this.coeff=u/e,e=u):this.coeff!=1&&(this.coeff=1),this.inner.style.height=e+"px"},this.setScrollTop=function(e){this.scrollTop!=e&&(this.skipEvent=!0,this.scrollTop=e,this.element.scrollTop=e*this.coeff)}}.call(f.prototype);var l=function(e,t){a.call(this,e),this.scrollLeft=0,this.height=t.$scrollbarWidth,this.inner.style.height=this.element.style.height=(this.height||15)+5+"px"};r.inherits(l,a),function(){this.classSuffix="-h",this.onScroll=function(){this.skipEvent||(this.scrollLeft=this.element.scrollLeft,this._emit("scroll",{data:this.scrollLeft})),this.skipEvent=!1},this.getHeight=function(){return this.isVisible?this.height:0},this.setWidth=function(e){this.element.style.width=e+"px"},this.setInnerWidth=function(e){this.inner.style.width=e+"px"},this.setScrollWidth=function(e){this.inner.style.width=e+"px"},this.setScrollLeft=function(e){this.scrollLeft!=e&&(this.skipEvent=!0,this.scrollLeft=this.element.scrollLeft=e)}}.call(l.prototype),t.ScrollBar=f,t.ScrollBarV=f,t.ScrollBarH=l,t.VScrollBar=f,t.HScrollBar=l}),ace.define("ace/renderloop",["require","exports","module","ace/lib/event"],function(e,t,n){"use strict";var r=e("./lib/event"),i=function(e,t){this.onRender=e,this.pending=!1,this.changes=0,this.$recursionLimit=2,this.window=t||window;var n=this;this._flush=function(e){n.pending=!1;var t=n.changes;t&&(r.blockIdle(100),n.changes=0,n.onRender(t));if(n.changes){if(n.$recursionLimit--<0)return;n.schedule()}else n.$recursionLimit=2}};(function(){this.schedule=function(e){this.changes=this.changes|e,this.changes&&!this.pending&&(r.nextFrame(this._flush),this.pending=!0)},this.clear=function(e){var t=this.changes;return this.changes=0,t}}).call(i.prototype),t.RenderLoop=i}),ace.define("ace/layer/font_metrics",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/lib/lang","ace/lib/event","ace/lib/useragent","ace/lib/event_emitter"],function(e,t,n){var r=e("../lib/oop"),i=e("../lib/dom"),s=e("../lib/lang"),o=e("../lib/event"),u=e("../lib/useragent"),a=e("../lib/event_emitter").EventEmitter,f=256,l=typeof ResizeObserver=="function",c=200,h=t.FontMetrics=function(e){this.el=i.createElement("div"),this.$setMeasureNodeStyles(this.el.style,!0),this.$main=i.createElement("div"),this.$setMeasureNodeStyles(this.$main.style),this.$measureNode=i.createElement("div"),this.$setMeasureNodeStyles(this.$measureNode.style),this.el.appendChild(this.$main),this.el.appendChild(this.$measureNode),e.appendChild(this.el),this.$measureNode.innerHTML=s.stringRepeat("X",f),this.$characterSize={width:0,height:0},l?this.$addObserver():this.checkForSizeChanges()};(function(){r.implement(this,a),this.$characterSize={width:0,height:0},this.$setMeasureNodeStyles=function(e,t){e.width=e.height="auto",e.left=e.top="0px",e.visibility="hidden",e.position="absolute",e.whiteSpace="pre",u.isIE<8?e["font-family"]="inherit":e.font="inherit",e.overflow=t?"hidden":"visible"},this.checkForSizeChanges=function(e){e===undefined&&(e=this.$measureSizes());if(e&&(this.$characterSize.width!==e.width||this.$characterSize.height!==e.height)){this.$measureNode.style.fontWeight="bold";var t=this.$measureSizes();this.$measureNode.style.fontWeight="",this.$characterSize=e,this.charSizes=Object.create(null),this.allowBoldFonts=t&&t.width===e.width&&t.height===e.height,this._emit("changeCharacterSize",{data:e})}},this.$addObserver=function(){var e=this;this.$observer=new window.ResizeObserver(function(t){var n=t[0].contentRect;e.checkForSizeChanges({height:n.height,width:n.width/f})}),this.$observer.observe(this.$measureNode)},this.$pollSizeChanges=function(){if(this.$pollSizeChangesTimer||this.$observer)return this.$pollSizeChangesTimer;var e=this;return this.$pollSizeChangesTimer=o.onIdle(function t(){e.checkForSizeChanges(),o.onIdle(t,500)},500)},this.setPolling=function(e){e?this.$pollSizeChanges():this.$pollSizeChangesTimer&&(clearInterval(this.$pollSizeChangesTimer),this.$pollSizeChangesTimer=0)},this.$measureSizes=function(e){var t={height:(e||this.$measureNode).clientHeight,width:(e||this.$measureNode).clientWidth/f};return t.width===0||t.height===0?null:t},this.$measureCharWidth=function(e){this.$main.innerHTML=s.stringRepeat(e,f);var t=this.$main.getBoundingClientRect();return t.width/f},this.getCharacterWidth=function(e){var t=this.charSizes[e];return t===undefined&&(t=this.charSizes[e]=this.$measureCharWidth(e)/this.$characterSize.width),t},this.destroy=function(){clearInterval(this.$pollSizeChangesTimer),this.$observer&&this.$observer.disconnect(),this.el&&this.el.parentNode&&this.el.parentNode.removeChild(this.el)},this.$getZoom=function e(t){return t?(window.getComputedStyle(t).zoom||1)*e(t.parentElement):1},this.$initTransformMeasureNodes=function(){var e=function(e,t){return["div",{style:"position: absolute;top:"+e+"px;left:"+t+"px;"}]};this.els=i.buildDom([e(0,0),e(c,0),e(0,c),e(c,c)],this.el)},this.transformCoordinates=function(e,t){function r(e,t,n){var r=e[1]*t[0]-e[0]*t[1];return[(-t[1]*n[0]+t[0]*n[1])/r,(+e[1]*n[0]-e[0]*n[1])/r]}function i(e,t){return[e[0]-t[0],e[1]-t[1]]}function s(e,t){return[e[0]+t[0],e[1]+t[1]]}function o(e,t){return[e*t[0],e*t[1]]}function u(e){var t=e.getBoundingClientRect();return[t.left,t.top]}if(e){var n=this.$getZoom(this.el);e=o(1/n,e)}this.els||this.$initTransformMeasureNodes();var a=u(this.els[0]),f=u(this.els[1]),l=u(this.els[2]),h=u(this.els[3]),p=r(i(h,f),i(h,l),i(s(f,l),s(h,a))),d=o(1+p[0],i(f,a)),v=o(1+p[1],i(l,a));if(t){var m=t,g=p[0]*m[0]/c+p[1]*m[1]/c+1,y=s(o(m[0],d),o(m[1],v));return s(o(1/g/c,y),a)}var b=i(e,a),w=r(i(d,o(p[0],b)),i(v,o(p[1],b)),b);return o(c,w)}}).call(h.prototype)}),ace.define("ace/virtual_renderer",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/config","ace/layer/gutter","ace/layer/marker","ace/layer/text","ace/layer/cursor","ace/scrollbar","ace/scrollbar","ace/renderloop","ace/layer/font_metrics","ace/lib/event_emitter","ace/lib/useragent"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./lib/dom"),s=e("./config"),o=e("./layer/gutter").Gutter,u=e("./layer/marker").Marker,a=e("./layer/text").Text,f=e("./layer/cursor").Cursor,l=e("./scrollbar").HScrollBar,c=e("./scrollbar").VScrollBar,h=e("./renderloop").RenderLoop,p=e("./layer/font_metrics").FontMetrics,d=e("./lib/event_emitter").EventEmitter,v='.ace_br1 {border-top-left-radius    : 3px;}.ace_br2 {border-top-right-radius   : 3px;}.ace_br3 {border-top-left-radius    : 3px; border-top-right-radius:    3px;}.ace_br4 {border-bottom-right-radius: 3px;}.ace_br5 {border-top-left-radius    : 3px; border-bottom-right-radius: 3px;}.ace_br6 {border-top-right-radius   : 3px; border-bottom-right-radius: 3px;}.ace_br7 {border-top-left-radius    : 3px; border-top-right-radius:    3px; border-bottom-right-radius: 3px;}.ace_br8 {border-bottom-left-radius : 3px;}.ace_br9 {border-top-left-radius    : 3px; border-bottom-left-radius:  3px;}.ace_br10{border-top-right-radius   : 3px; border-bottom-left-radius:  3px;}.ace_br11{border-top-left-radius    : 3px; border-top-right-radius:    3px; border-bottom-left-radius:  3px;}.ace_br12{border-bottom-right-radius: 3px; border-bottom-left-radius:  3px;}.ace_br13{border-top-left-radius    : 3px; border-bottom-right-radius: 3px; border-bottom-left-radius:  3px;}.ace_br14{border-top-right-radius   : 3px; border-bottom-right-radius: 3px; border-bottom-left-radius:  3px;}.ace_br15{border-top-left-radius    : 3px; border-top-right-radius:    3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}.ace_editor {position: relative;overflow: hidden;font: 12px/normal \'Monaco\', \'Menlo\', \'Ubuntu Mono\', \'Consolas\', \'source-code-pro\', monospace;direction: ltr;text-align: left;-webkit-tap-highlight-color: rgba(0, 0, 0, 0);}.ace_scroller {position: absolute;overflow: hidden;top: 0;bottom: 0;background-color: inherit;-ms-user-select: none;-moz-user-select: none;-webkit-user-select: none;user-select: none;cursor: text;}.ace_content {position: absolute;box-sizing: border-box;min-width: 100%;contain: style size layout;}.ace_dragging .ace_scroller:before{position: absolute;top: 0;left: 0;right: 0;bottom: 0;content: \'\';background: rgba(250, 250, 250, 0.01);z-index: 1000;}.ace_dragging.ace_dark .ace_scroller:before{background: rgba(0, 0, 0, 0.01);}.ace_selecting, .ace_selecting * {cursor: text !important;}.ace_gutter {position: absolute;overflow : hidden;width: auto;top: 0;bottom: 0;left: 0;cursor: default;z-index: 4;-ms-user-select: none;-moz-user-select: none;-webkit-user-select: none;user-select: none;contain: style size layout;}.ace_gutter-active-line {position: absolute;left: 0;right: 0;}.ace_scroller.ace_scroll-left {box-shadow: 17px 0 16px -16px rgba(0, 0, 0, 0.4) inset;}.ace_gutter-cell {position: absolute;top: 0;left: 0;right: 0;padding-left: 19px;padding-right: 6px;background-repeat: no-repeat;}.ace_gutter-cell.ace_error {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAABOFBMVEX/////////QRswFAb/Ui4wFAYwFAYwFAaWGAfDRymzOSH/PxswFAb/SiUwFAYwFAbUPRvjQiDllog5HhHdRybsTi3/Tyv9Tir+Syj/UC3////XurebMBIwFAb/RSHbPx/gUzfdwL3kzMivKBAwFAbbvbnhPx66NhowFAYwFAaZJg8wFAaxKBDZurf/RB6mMxb/SCMwFAYwFAbxQB3+RB4wFAb/Qhy4Oh+4QifbNRcwFAYwFAYwFAb/QRzdNhgwFAYwFAbav7v/Uy7oaE68MBK5LxLewr/r2NXewLswFAaxJw4wFAbkPRy2PyYwFAaxKhLm1tMwFAazPiQwFAaUGAb/QBrfOx3bvrv/VC/maE4wFAbRPBq6MRO8Qynew8Dp2tjfwb0wFAbx6eju5+by6uns4uH9/f36+vr/GkHjAAAAYnRSTlMAGt+64rnWu/bo8eAA4InH3+DwoN7j4eLi4xP99Nfg4+b+/u9B/eDs1MD1mO7+4PHg2MXa347g7vDizMLN4eG+Pv7i5evs/v79yu7S3/DV7/498Yv24eH+4ufQ3Ozu/v7+y13sRqwAAADLSURBVHjaZc/XDsFgGIBhtDrshlitmk2IrbHFqL2pvXf/+78DPokj7+Fz9qpU/9UXJIlhmPaTaQ6QPaz0mm+5gwkgovcV6GZzd5JtCQwgsxoHOvJO15kleRLAnMgHFIESUEPmawB9ngmelTtipwwfASilxOLyiV5UVUyVAfbG0cCPHig+GBkzAENHS0AstVF6bacZIOzgLmxsHbt2OecNgJC83JERmePUYq8ARGkJx6XtFsdddBQgZE2nPR6CICZhawjA4Fb/chv+399kfR+MMMDGOQAAAABJRU5ErkJggg==");background-repeat: no-repeat;background-position: 2px center;}.ace_gutter-cell.ace_warning {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAmVBMVEX///8AAAD///8AAAAAAABPSzb/5sAAAAB/blH/73z/ulkAAAAAAAD85pkAAAAAAAACAgP/vGz/rkDerGbGrV7/pkQICAf////e0IsAAAD/oED/qTvhrnUAAAD/yHD/njcAAADuv2r/nz//oTj/p064oGf/zHAAAAA9Nir/tFIAAAD/tlTiuWf/tkIAAACynXEAAAAAAAAtIRW7zBpBAAAAM3RSTlMAABR1m7RXO8Ln31Z36zT+neXe5OzooRDfn+TZ4p3h2hTf4t3k3ucyrN1K5+Xaks52Sfs9CXgrAAAAjklEQVR42o3PbQ+CIBQFYEwboPhSYgoYunIqqLn6/z8uYdH8Vmdnu9vz4WwXgN/xTPRD2+sgOcZjsge/whXZgUaYYvT8QnuJaUrjrHUQreGczuEafQCO/SJTufTbroWsPgsllVhq3wJEk2jUSzX3CUEDJC84707djRc5MTAQxoLgupWRwW6UB5fS++NV8AbOZgnsC7BpEAAAAABJRU5ErkJggg==");background-position: 2px center;}.ace_gutter-cell.ace_info {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAAAAAA6mKC9AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAAJ0Uk5TAAB2k804AAAAPklEQVQY02NgIB68QuO3tiLznjAwpKTgNyDbMegwisCHZUETUZV0ZqOquBpXj2rtnpSJT1AEnnRmL2OgGgAAIKkRQap2htgAAAAASUVORK5CYII=");background-position: 2px center;}.ace_dark .ace_gutter-cell.ace_info {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAJFBMVEUAAAChoaGAgIAqKiq+vr6tra1ZWVmUlJSbm5s8PDxubm56enrdgzg3AAAAAXRSTlMAQObYZgAAAClJREFUeNpjYMAPdsMYHegyJZFQBlsUlMFVCWUYKkAZMxZAGdxlDMQBAG+TBP4B6RyJAAAAAElFTkSuQmCC");}.ace_scrollbar {contain: strict;position: absolute;right: 0;bottom: 0;z-index: 6;}.ace_scrollbar-inner {position: absolute;cursor: text;left: 0;top: 0;}.ace_scrollbar-v{overflow-x: hidden;overflow-y: scroll;top: 0;}.ace_scrollbar-h {overflow-x: scroll;overflow-y: hidden;left: 0;}.ace_print-margin {position: absolute;height: 100%;}.ace_text-input {position: absolute;z-index: 0;width: 0.5em;height: 1em;opacity: 0;background: transparent;-moz-appearance: none;appearance: none;border: none;resize: none;outline: none;overflow: hidden;font: inherit;padding: 0 1px;margin: 0 -1px;contain: strict;-ms-user-select: text;-moz-user-select: text;-webkit-user-select: text;user-select: text;white-space: pre!important;}.ace_text-input.ace_composition {background: transparent;color: inherit;z-index: 1000;opacity: 1;}.ace_composition_placeholder { color: transparent }.ace_composition_marker { border-bottom: 1px solid;position: absolute;border-radius: 0;margin-top: 1px;}[ace_nocontext=true] {transform: none!important;filter: none!important;perspective: none!important;clip-path: none!important;mask : none!important;contain: none!important;perspective: none!important;mix-blend-mode: initial!important;z-index: auto;}.ace_layer {z-index: 1;position: absolute;overflow: hidden;word-wrap: normal;white-space: pre;height: 100%;width: 100%;box-sizing: border-box;pointer-events: none;}.ace_gutter-layer {position: relative;width: auto;text-align: right;pointer-events: auto;height: 1000000px;contain: style size layout;}.ace_text-layer {font: inherit !important;position: absolute;height: 1000000px;width: 1000000px;contain: style size layout;}.ace_text-layer > .ace_line, .ace_text-layer > .ace_line_group {contain: style size layout;position: absolute;top: 0;left: 0;right: 0;}.ace_hidpi .ace_text-layer,.ace_hidpi .ace_gutter-layer,.ace_hidpi .ace_content,.ace_hidpi .ace_gutter {contain: strict;will-change: transform;}.ace_hidpi .ace_text-layer > .ace_line, .ace_hidpi .ace_text-layer > .ace_line_group {contain: strict;}.ace_cjk {display: inline-block;text-align: center;}.ace_cursor-layer {z-index: 4;}.ace_cursor {z-index: 4;position: absolute;box-sizing: border-box;border-left: 2px solid;transform: translatez(0);}.ace_multiselect .ace_cursor {border-left-width: 1px;}.ace_slim-cursors .ace_cursor {border-left-width: 1px;}.ace_overwrite-cursors .ace_cursor {border-left-width: 0;border-bottom: 1px solid;}.ace_hidden-cursors .ace_cursor {opacity: 0.2;}.ace_smooth-blinking .ace_cursor {transition: opacity 0.18s;}.ace_animate-blinking .ace_cursor {animation-duration: 1000ms;animation-timing-function: step-end;animation-name: blink-ace-animate;animation-iteration-count: infinite;}.ace_animate-blinking.ace_smooth-blinking .ace_cursor {animation-duration: 1000ms;animation-timing-function: ease-in-out;animation-name: blink-ace-animate-smooth;}@keyframes blink-ace-animate {from, to { opacity: 1; }60% { opacity: 0; }}@keyframes blink-ace-animate-smooth {from, to { opacity: 1; }45% { opacity: 1; }60% { opacity: 0; }85% { opacity: 0; }}.ace_marker-layer .ace_step, .ace_marker-layer .ace_stack {position: absolute;z-index: 3;}.ace_marker-layer .ace_selection {position: absolute;z-index: 5;}.ace_marker-layer .ace_bracket {position: absolute;z-index: 6;}.ace_marker-layer .ace_active-line {position: absolute;z-index: 2;}.ace_marker-layer .ace_selected-word {position: absolute;z-index: 4;box-sizing: border-box;}.ace_line .ace_fold {box-sizing: border-box;display: inline-block;height: 11px;margin-top: -2px;vertical-align: middle;background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAAJCAYAAADU6McMAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAJpJREFUeNpi/P//PwOlgAXGYGRklAVSokD8GmjwY1wasKljQpYACtpCFeADcHVQfQyMQAwzwAZI3wJKvCLkfKBaMSClBlR7BOQikCFGQEErIH0VqkabiGCAqwUadAzZJRxQr/0gwiXIal8zQQPnNVTgJ1TdawL0T5gBIP1MUJNhBv2HKoQHHjqNrA4WO4zY0glyNKLT2KIfIMAAQsdgGiXvgnYAAAAASUVORK5CYII="),url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAA3CAYAAADNNiA5AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAACJJREFUeNpi+P//fxgTAwPDBxDxD078RSX+YeEyDFMCIMAAI3INmXiwf2YAAAAASUVORK5CYII=");background-repeat: no-repeat, repeat-x;background-position: center center, top left;color: transparent;border: 1px solid black;border-radius: 2px;cursor: pointer;pointer-events: auto;}.ace_dark .ace_fold {}.ace_fold:hover{background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAAJCAYAAADU6McMAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAJpJREFUeNpi/P//PwOlgAXGYGRklAVSokD8GmjwY1wasKljQpYACtpCFeADcHVQfQyMQAwzwAZI3wJKvCLkfKBaMSClBlR7BOQikCFGQEErIH0VqkabiGCAqwUadAzZJRxQr/0gwiXIal8zQQPnNVTgJ1TdawL0T5gBIP1MUJNhBv2HKoQHHjqNrA4WO4zY0glyNKLT2KIfIMAAQsdgGiXvgnYAAAAASUVORK5CYII="),url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAA3CAYAAADNNiA5AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAACBJREFUeNpi+P//fz4TAwPDZxDxD5X4i5fLMEwJgAADAEPVDbjNw87ZAAAAAElFTkSuQmCC");}.ace_tooltip {background-color: #FFF;background-image: linear-gradient(to bottom, transparent, rgba(0, 0, 0, 0.1));border: 1px solid gray;border-radius: 1px;box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);color: black;max-width: 100%;padding: 3px 4px;position: fixed;z-index: 999999;box-sizing: border-box;cursor: default;white-space: pre;word-wrap: break-word;line-height: normal;font-style: normal;font-weight: normal;letter-spacing: normal;pointer-events: none;}.ace_folding-enabled > .ace_gutter-cell {padding-right: 13px;}.ace_fold-widget {box-sizing: border-box;margin: 0 -12px 0 1px;display: none;width: 11px;vertical-align: top;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAANElEQVR42mWKsQ0AMAzC8ixLlrzQjzmBiEjp0A6WwBCSPgKAXoLkqSot7nN3yMwR7pZ32NzpKkVoDBUxKAAAAABJRU5ErkJggg==");background-repeat: no-repeat;background-position: center;border-radius: 3px;border: 1px solid transparent;cursor: pointer;}.ace_folding-enabled .ace_fold-widget {display: inline-block;   }.ace_fold-widget.ace_end {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAANElEQVR42m3HwQkAMAhD0YzsRchFKI7sAikeWkrxwScEB0nh5e7KTPWimZki4tYfVbX+MNl4pyZXejUO1QAAAABJRU5ErkJggg==");}.ace_fold-widget.ace_closed {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAAGCAYAAAAG5SQMAAAAOUlEQVR42jXKwQkAMAgDwKwqKD4EwQ26sSOkVWjgIIHAzPiCgaqiqnJHZnKICBERHN194O5b9vbLuAVRL+l0YWnZAAAAAElFTkSuQmCCXA==");}.ace_fold-widget:hover {border: 1px solid rgba(0, 0, 0, 0.3);background-color: rgba(255, 255, 255, 0.2);box-shadow: 0 1px 1px rgba(255, 255, 255, 0.7);}.ace_fold-widget:active {border: 1px solid rgba(0, 0, 0, 0.4);background-color: rgba(0, 0, 0, 0.05);box-shadow: 0 1px 1px rgba(255, 255, 255, 0.8);}.ace_dark .ace_fold-widget {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHklEQVQIW2P4//8/AzoGEQ7oGCaLLAhWiSwB146BAQCSTPYocqT0AAAAAElFTkSuQmCC");}.ace_dark .ace_fold-widget.ace_end {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAH0lEQVQIW2P4//8/AxQ7wNjIAjDMgC4AxjCVKBirIAAF0kz2rlhxpAAAAABJRU5ErkJggg==");}.ace_dark .ace_fold-widget.ace_closed {background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAAFCAYAAACAcVaiAAAAHElEQVQIW2P4//+/AxAzgDADlOOAznHAKgPWAwARji8UIDTfQQAAAABJRU5ErkJggg==");}.ace_dark .ace_fold-widget:hover {box-shadow: 0 1px 1px rgba(255, 255, 255, 0.2);background-color: rgba(255, 255, 255, 0.1);}.ace_dark .ace_fold-widget:active {box-shadow: 0 1px 1px rgba(255, 255, 255, 0.2);}.ace_inline_button {border: 1px solid lightgray;display: inline-block;margin: -1px 8px;padding: 0 5px;pointer-events: auto;cursor: pointer;}.ace_inline_button:hover {border-color: gray;background: rgba(200,200,200,0.2);display: inline-block;pointer-events: auto;}.ace_fold-widget.ace_invalid {background-color: #FFB4B4;border-color: #DE5555;}.ace_fade-fold-widgets .ace_fold-widget {transition: opacity 0.4s ease 0.05s;opacity: 0;}.ace_fade-fold-widgets:hover .ace_fold-widget {transition: opacity 0.05s ease 0.05s;opacity:1;}.ace_underline {text-decoration: underline;}.ace_bold {font-weight: bold;}.ace_nobold .ace_bold {font-weight: normal;}.ace_italic {font-style: italic;}.ace_error-marker {background-color: rgba(255, 0, 0,0.2);position: absolute;z-index: 9;}.ace_highlight-marker {background-color: rgba(255, 255, 0,0.2);position: absolute;z-index: 8;}.ace_mobile-menu {position: absolute;line-height: 1.5;border-radius: 4px;-ms-user-select: none;-moz-user-select: none;-webkit-user-select: none;user-select: none;background: white;box-shadow: 1px 3px 2px grey;border: 1px solid #dcdcdc;color: black;}.ace_dark > .ace_mobile-menu {background: #333;color: #ccc;box-shadow: 1px 3px 2px grey;border: 1px solid #444;}.ace_mobile-button {padding: 2px;cursor: pointer;overflow: hidden;}.ace_mobile-button:hover {background-color: #eee;opacity:1;}.ace_mobile-button:active {background-color: #ddd;}',m=e("./lib/useragent"),g=m.isIE;i.importCssString(v,"ace_editor.css");var y=function(e,t){var n=this;this.container=e||i.createElement("div"),i.addCssClass(this.container,"ace_editor"),i.HI_DPI&&i.addCssClass(this.container,"ace_hidpi"),this.setTheme(t),this.$gutter=i.createElement("div"),this.$gutter.className="ace_gutter",this.container.appendChild(this.$gutter),this.$gutter.setAttribute("aria-hidden",!0),this.scroller=i.createElement("div"),this.scroller.className="ace_scroller",this.container.appendChild(this.scroller),this.content=i.createElement("div"),this.content.className="ace_content",this.scroller.appendChild(this.content),this.$gutterLayer=new o(this.$gutter),this.$gutterLayer.on("changeGutterWidth",this.onGutterResize.bind(this)),this.$markerBack=new u(this.content);var r=this.$textLayer=new a(this.content);this.canvas=r.element,this.$markerFront=new u(this.content),this.$cursorLayer=new f(this.content),this.$horizScroll=!1,this.$vScroll=!1,this.scrollBar=this.scrollBarV=new c(this.container,this),this.scrollBarH=new l(this.container,this),this.scrollBarV.addEventListener("scroll",function(e){n.$scrollAnimation||n.session.setScrollTop(e.data-n.scrollMargin.top)}),this.scrollBarH.addEventListener("scroll",function(e){n.$scrollAnimation||n.session.setScrollLeft(e.data-n.scrollMargin.left)}),this.scrollTop=0,this.scrollLeft=0,this.cursorPos={row:0,column:0},this.$fontMetrics=new p(this.container),this.$textLayer.$setFontMetrics(this.$fontMetrics),this.$textLayer.addEventListener("changeCharacterSize",function(e){n.updateCharacterSize(),n.onResize(!0,n.gutterWidth,n.$size.width,n.$size.height),n._signal("changeCharacterSize",e)}),this.$size={width:0,height:0,scrollerHeight:0,scrollerWidth:0,$dirty:!0},this.layerConfig={width:1,padding:0,firstRow:0,firstRowScreen:0,lastRow:0,lineHeight:0,characterWidth:0,minHeight:1,maxHeight:1,offset:0,height:1,gutterOffset:1},this.scrollMargin={left:0,right:0,top:0,bottom:0,v:0,h:0},this.margin={left:0,right:0,top:0,bottom:0,v:0,h:0},this.$keepTextAreaAtCursor=!m.isIOS,this.$loop=new h(this.$renderChanges.bind(this),this.container.ownerDocument.defaultView),this.$loop.schedule(this.CHANGE_FULL),this.updateCharacterSize(),this.setPadding(4),s.resetOptions(this),s._signal("renderer",this)};(function(){this.CHANGE_CURSOR=1,this.CHANGE_MARKER=2,this.CHANGE_GUTTER=4,this.CHANGE_SCROLL=8,this.CHANGE_LINES=16,this.CHANGE_TEXT=32,this.CHANGE_SIZE=64,this.CHANGE_MARKER_BACK=128,this.CHANGE_MARKER_FRONT=256,this.CHANGE_FULL=512,this.CHANGE_H_SCROLL=1024,r.implement(this,d),this.updateCharacterSize=function(){this.$textLayer.allowBoldFonts!=this.$allowBoldFonts&&(this.$allowBoldFonts=this.$textLayer.allowBoldFonts,this.setStyle("ace_nobold",!this.$allowBoldFonts)),this.layerConfig.characterWidth=this.characterWidth=this.$textLayer.getCharacterWidth(),this.layerConfig.lineHeight=this.lineHeight=this.$textLayer.getLineHeight(),this.$updatePrintMargin(),i.setStyle(this.scroller.style,"line-height",this.lineHeight+"px")},this.setSession=function(e){this.session&&this.session.doc.off("changeNewLineMode",this.onChangeNewLineMode),this.session=e,e&&this.scrollMargin.top&&e.getScrollTop()<=0&&e.setScrollTop(-this.scrollMargin.top),this.$cursorLayer.setSession(e),this.$markerBack.setSession(e),this.$markerFront.setSession(e),this.$gutterLayer.setSession(e),this.$textLayer.setSession(e);if(!e)return;this.$loop.schedule(this.CHANGE_FULL),this.session.$setFontMetrics(this.$fontMetrics),this.scrollBarH.scrollLeft=this.scrollBarV.scrollTop=null,this.onChangeNewLineMode=this.onChangeNewLineMode.bind(this),this.onChangeNewLineMode(),this.session.doc.on("changeNewLineMode",this.onChangeNewLineMode)},this.updateLines=function(e,t,n){t===undefined&&(t=Infinity),this.$changedLines?(this.$changedLines.firstRow>e&&(this.$changedLines.firstRow=e),this.$changedLines.lastRow<t&&(this.$changedLines.lastRow=t)):this.$changedLines={firstRow:e,lastRow:t};if(this.$changedLines.lastRow<this.layerConfig.firstRow){if(!n)return;this.$changedLines.lastRow=this.layerConfig.lastRow}if(this.$changedLines.firstRow>this.layerConfig.lastRow)return;this.$loop.schedule(this.CHANGE_LINES)},this.onChangeNewLineMode=function(){this.$loop.schedule(this.CHANGE_TEXT),this.$textLayer.$updateEolChar(),this.session.$bidiHandler.setEolChar(this.$textLayer.EOL_CHAR)},this.onChangeTabSize=function(){this.$loop.schedule(this.CHANGE_TEXT|this.CHANGE_MARKER),this.$textLayer.onChangeTabSize()},this.updateText=function(){this.$loop.schedule(this.CHANGE_TEXT)},this.updateFull=function(e){e?this.$renderChanges(this.CHANGE_FULL,!0):this.$loop.schedule(this.CHANGE_FULL)},this.updateFontSize=function(){this.$textLayer.checkForSizeChanges()},this.$changes=0,this.$updateSizeAsync=function(){this.$loop.pending?this.$size.$dirty=!0:this.onResize()},this.onResize=function(e,t,n,r){if(this.resizing>2)return;this.resizing>0?this.resizing++:this.resizing=e?1:0;var i=this.container;r||(r=i.clientHeight||i.scrollHeight),n||(n=i.clientWidth||i.scrollWidth);var s=this.$updateCachedSize(e,t,n,r);if(!this.$size.scrollerHeight||!n&&!r)return this.resizing=0;e&&(this.$gutterLayer.$padding=null),e?this.$renderChanges(s|this.$changes,!0):this.$loop.schedule(s|this.$changes),this.resizing&&(this.resizing=0),this.scrollBarV.scrollLeft=this.scrollBarV.scrollTop=null},this.$updateCachedSize=function(e,t,n,r){r-=this.$extraHeight||0;var s=0,o=this.$size,u={width:o.width,height:o.height,scrollerHeight:o.scrollerHeight,scrollerWidth:o.scrollerWidth};r&&(e||o.height!=r)&&(o.height=r,s|=this.CHANGE_SIZE,o.scrollerHeight=o.height,this.$horizScroll&&(o.scrollerHeight-=this.scrollBarH.getHeight()),this.scrollBarV.element.style.bottom=this.scrollBarH.getHeight()+"px",s|=this.CHANGE_SCROLL);if(n&&(e||o.width!=n)){s|=this.CHANGE_SIZE,o.width=n,t==null&&(t=this.$showGutter?this.$gutter.offsetWidth:0),this.gutterWidth=t,i.setStyle(this.scrollBarH.element.style,"left",t+"px"),i.setStyle(this.scroller.style,"left",t+this.margin.left+"px"),o.scrollerWidth=Math.max(0,n-t-this.scrollBarV.getWidth()-this.margin.h),i.setStyle(this.$gutter.style,"left",this.margin.left+"px");var a=this.scrollBarV.getWidth()+"px";i.setStyle(this.scrollBarH.element.style,"right",a),i.setStyle(this.scroller.style,"right",a),i.setStyle(this.scroller.style,"bottom",this.scrollBarH.getHeight());if(this.session&&this.session.getUseWrapMode()&&this.adjustWrapLimit()||e)s|=this.CHANGE_FULL}return o.$dirty=!n||!r,s&&this._signal("resize",u),s},this.onGutterResize=function(e){var t=this.$showGutter?e:0;t!=this.gutterWidth&&(this.$changes|=this.$updateCachedSize(!0,t,this.$size.width,this.$size.height)),this.session.getUseWrapMode()&&this.adjustWrapLimit()?this.$loop.schedule(this.CHANGE_FULL):this.$size.$dirty?this.$loop.schedule(this.CHANGE_FULL):this.$computeLayerConfig()},this.adjustWrapLimit=function(){var e=this.$size.scrollerWidth-this.$padding*2,t=Math.floor(e/this.characterWidth);return this.session.adjustWrapLimit(t,this.$showPrintMargin&&this.$printMarginColumn)},this.setAnimatedScroll=function(e){this.setOption("animatedScroll",e)},this.getAnimatedScroll=function(){return this.$animatedScroll},this.setShowInvisibles=function(e){this.setOption("showInvisibles",e),this.session.$bidiHandler.setShowInvisibles(e)},this.getShowInvisibles=function(){return this.getOption("showInvisibles")},this.getDisplayIndentGuides=function(){return this.getOption("displayIndentGuides")},this.setDisplayIndentGuides=function(e){this.setOption("displayIndentGuides",e)},this.setShowPrintMargin=function(e){this.setOption("showPrintMargin",e)},this.getShowPrintMargin=function(){return this.getOption("showPrintMargin")},this.setPrintMarginColumn=function(e){this.setOption("printMarginColumn",e)},this.getPrintMarginColumn=function(){return this.getOption("printMarginColumn")},this.getShowGutter=function(){return this.getOption("showGutter")},this.setShowGutter=function(e){return this.setOption("showGutter",e)},this.getFadeFoldWidgets=function(){return this.getOption("fadeFoldWidgets")},this.setFadeFoldWidgets=function(e){this.setOption("fadeFoldWidgets",e)},this.setHighlightGutterLine=function(e){this.setOption("highlightGutterLine",e)},this.getHighlightGutterLine=function(){return this.getOption("highlightGutterLine")},this.$updatePrintMargin=function(){if(!this.$showPrintMargin&&!this.$printMarginEl)return;if(!this.$printMarginEl){var e=i.createElement("div");e.className="ace_layer ace_print-margin-layer",this.$printMarginEl=i.createElement("div"),this.$printMarginEl.className="ace_print-margin",e.appendChild(this.$printMarginEl),this.content.insertBefore(e,this.content.firstChild)}var t=this.$printMarginEl.style;t.left=Math.round(this.characterWidth*this.$printMarginColumn+this.$padding)+"px",t.visibility=this.$showPrintMargin?"visible":"hidden",this.session&&this.session.$wrap==-1&&this.adjustWrapLimit()},this.getContainerElement=function(){return this.container},this.getMouseEventTarget=function(){return this.scroller},this.getTextAreaContainer=function(){return this.container},this.$moveTextAreaToCursor=function(){if(this.$isMousePressed)return;var e=this.textarea.style,t=this.$composition;if(!this.$keepTextAreaAtCursor&&!t){i.translate(this.textarea,-100,0);return}var n=this.$cursorLayer.$pixelPos;if(!n)return;t&&t.markerRange&&(n=this.$cursorLayer.getPixelPosition(t.markerRange.start,!0));var r=this.layerConfig,s=n.top,o=n.left;s-=r.offset;var u=t&&t.useTextareaForIME?this.lineHeight:g?0:1;if(s<0||s>r.height-u){i.translate(this.textarea,0,0);return}var a=1,f=this.$size.height-u;if(!t)s+=this.lineHeight;else if(t.useTextareaForIME){var l=this.textarea.value;a=this.characterWidth*this.session.$getStringScreenWidth(l)[0],u+=2}else s+=this.lineHeight+2;o-=this.scrollLeft,o>this.$size.scrollerWidth-a&&(o=this.$size.scrollerWidth-a),o+=this.gutterWidth+this.margin.left,i.setStyle(e,"height",u+"px"),i.setStyle(e,"width",a+"px"),i.translate(this.textarea,Math.min(o,this.$size.scrollerWidth-a),Math.min(s,f))},this.getFirstVisibleRow=function(){return this.layerConfig.firstRow},this.getFirstFullyVisibleRow=function(){return this.layerConfig.firstRow+(this.layerConfig.offset===0?0:1)},this.getLastFullyVisibleRow=function(){var e=this.layerConfig,t=e.lastRow,n=this.session.documentToScreenRow(t,0)*e.lineHeight;return n-this.session.getScrollTop()>e.height-e.lineHeight?t-1:t},this.getLastVisibleRow=function(){return this.layerConfig.lastRow},this.$padding=null,this.setPadding=function(e){this.$padding=e,this.$textLayer.setPadding(e),this.$cursorLayer.setPadding(e),this.$markerFront.setPadding(e),this.$markerBack.setPadding(e),this.$loop.schedule(this.CHANGE_FULL),this.$updatePrintMargin()},this.setScrollMargin=function(e,t,n,r){var i=this.scrollMargin;i.top=e|0,i.bottom=t|0,i.right=r|0,i.left=n|0,i.v=i.top+i.bottom,i.h=i.left+i.right,i.top&&this.scrollTop<=0&&this.session&&this.session.setScrollTop(-i.top),this.updateFull()},this.setMargin=function(e,t,n,r){var i=this.margin;i.top=e|0,i.bottom=t|0,i.right=r|0,i.left=n|0,i.v=i.top+i.bottom,i.h=i.left+i.right,this.$updateCachedSize(!0,this.gutterWidth,this.$size.width,this.$size.height),this.updateFull()},this.getHScrollBarAlwaysVisible=function(){return this.$hScrollBarAlwaysVisible},this.setHScrollBarAlwaysVisible=function(e){this.setOption("hScrollBarAlwaysVisible",e)},this.getVScrollBarAlwaysVisible=function(){return this.$vScrollBarAlwaysVisible},this.setVScrollBarAlwaysVisible=function(e){this.setOption("vScrollBarAlwaysVisible",e)},this.$updateScrollBarV=function(){var e=this.layerConfig.maxHeight,t=this.$size.scrollerHeight;!this.$maxLines&&this.$scrollPastEnd&&(e-=(t-this.lineHeight)*this.$scrollPastEnd,this.scrollTop>e-t&&(e=this.scrollTop+t,this.scrollBarV.scrollTop=null)),this.scrollBarV.setScrollHeight(e+this.scrollMargin.v),this.scrollBarV.setScrollTop(this.scrollTop+this.scrollMargin.top)},this.$updateScrollBarH=function(){this.scrollBarH.setScrollWidth(this.layerConfig.width+2*this.$padding+this.scrollMargin.h),this.scrollBarH.setScrollLeft(this.scrollLeft+this.scrollMargin.left)},this.$frozen=!1,this.freeze=function(){this.$frozen=!0},this.unfreeze=function(){this.$frozen=!1},this.$renderChanges=function(e,t){this.$changes&&(e|=this.$changes,this.$changes=0);if(!this.session||!this.container.offsetWidth||this.$frozen||!e&&!t){this.$changes|=e;return}if(this.$size.$dirty)return this.$changes|=e,this.onResize(!0);this.lineHeight||this.$textLayer.checkForSizeChanges(),this._signal("beforeRender"),this.session&&this.session.$bidiHandler&&this.session.$bidiHandler.updateCharacterWidths(this.$fontMetrics);var n=this.layerConfig;if(e&this.CHANGE_FULL||e&this.CHANGE_SIZE||e&this.CHANGE_TEXT||e&this.CHANGE_LINES||e&this.CHANGE_SCROLL||e&this.CHANGE_H_SCROLL){e|=this.$computeLayerConfig()|this.$loop.clear();if(n.firstRow!=this.layerConfig.firstRow&&n.firstRowScreen==this.layerConfig.firstRowScreen){var r=this.scrollTop+(n.firstRow-this.layerConfig.firstRow)*this.lineHeight;r>0&&(this.scrollTop=r,e|=this.CHANGE_SCROLL,e|=this.$computeLayerConfig()|this.$loop.clear())}n=this.layerConfig,this.$updateScrollBarV(),e&this.CHANGE_H_SCROLL&&this.$updateScrollBarH(),i.translate(this.content,-this.scrollLeft,-n.offset);var s=n.width+2*this.$padding+"px",o=n.minHeight+"px";i.setStyle(this.content.style,"width",s),i.setStyle(this.content.style,"height",o)}e&this.CHANGE_H_SCROLL&&(i.translate(this.content,-this.scrollLeft,-n.offset),this.scroller.className=this.scrollLeft<=0?"ace_scroller":"ace_scroller ace_scroll-left");if(e&this.CHANGE_FULL){this.$changedLines=null,this.$textLayer.update(n),this.$showGutter&&this.$gutterLayer.update(n),this.$markerBack.update(n),this.$markerFront.update(n),this.$cursorLayer.update(n),this.$moveTextAreaToCursor(),this._signal("afterRender");return}if(e&this.CHANGE_SCROLL){this.$changedLines=null,e&this.CHANGE_TEXT||e&this.CHANGE_LINES?this.$textLayer.update(n):this.$textLayer.scrollLines(n),this.$showGutter&&(e&this.CHANGE_GUTTER||e&this.CHANGE_LINES?this.$gutterLayer.update(n):this.$gutterLayer.scrollLines(n)),this.$markerBack.update(n),this.$markerFront.update(n),this.$cursorLayer.update(n),this.$moveTextAreaToCursor(),this._signal("afterRender");return}e&this.CHANGE_TEXT?(this.$changedLines=null,this.$textLayer.update(n),this.$showGutter&&this.$gutterLayer.update(n)):e&this.CHANGE_LINES?(this.$updateLines()||e&this.CHANGE_GUTTER&&this.$showGutter)&&this.$gutterLayer.update(n):e&this.CHANGE_TEXT||e&this.CHANGE_GUTTER?this.$showGutter&&this.$gutterLayer.update(n):e&this.CHANGE_CURSOR&&this.$highlightGutterLine&&this.$gutterLayer.updateLineHighlight(n),e&this.CHANGE_CURSOR&&(this.$cursorLayer.update(n),this.$moveTextAreaToCursor()),e&(this.CHANGE_MARKER|this.CHANGE_MARKER_FRONT)&&this.$markerFront.update(n),e&(this.CHANGE_MARKER|this.CHANGE_MARKER_BACK)&&this.$markerBack.update(n),this._signal("afterRender")},this.$autosize=function(){var e=this.session.getScreenLength()*this.lineHeight,t=this.$maxLines*this.lineHeight,n=Math.min(t,Math.max((this.$minLines||1)*this.lineHeight,e))+this.scrollMargin.v+(this.$extraHeight||0);this.$horizScroll&&(n+=this.scrollBarH.getHeight()),this.$maxPixelHeight&&n>this.$maxPixelHeight&&(n=this.$maxPixelHeight);var r=n<=2*this.lineHeight,i=!r&&e>t;if(n!=this.desiredHeight||this.$size.height!=this.desiredHeight||i!=this.$vScroll){i!=this.$vScroll&&(this.$vScroll=i,this.scrollBarV.setVisible(i));var s=this.container.clientWidth;this.container.style.height=n+"px",this.$updateCachedSize(!0,this.$gutterWidth,s,n),this.desiredHeight=n,this._signal("autosize")}},this.$computeLayerConfig=function(){var e=this.session,t=this.$size,n=t.height<=2*this.lineHeight,r=this.session.getScreenLength(),i=r*this.lineHeight,s=this.$getLongestLine(),o=!n&&(this.$hScrollBarAlwaysVisible||t.scrollerWidth-s-2*this.$padding<0),u=this.$horizScroll!==o;u&&(this.$horizScroll=o,this.scrollBarH.setVisible(o));var a=this.$vScroll;this.$maxLines&&this.lineHeight>1&&this.$autosize();var f=t.scrollerHeight+this.lineHeight,l=!this.$maxLines&&this.$scrollPastEnd?(t.scrollerHeight-this.lineHeight)*this.$scrollPastEnd:0;i+=l;var c=this.scrollMargin;this.session.setScrollTop(Math.max(-c.top,Math.min(this.scrollTop,i-t.scrollerHeight+c.bottom))),this.session.setScrollLeft(Math.max(-c.left,Math.min(this.scrollLeft,s+2*this.$padding-t.scrollerWidth+c.right)));var h=!n&&(this.$vScrollBarAlwaysVisible||t.scrollerHeight-i+l<0||this.scrollTop>c.top),p=a!==h;p&&(this.$vScroll=h,this.scrollBarV.setVisible(h));var d=this.scrollTop%this.lineHeight,v=Math.ceil(f/this.lineHeight)-1,m=Math.max(0,Math.round((this.scrollTop-d)/this.lineHeight)),g=m+v,y,b,w=this.lineHeight;m=e.screenToDocumentRow(m,0);var E=e.getFoldLine(m);E&&(m=E.start.row),y=e.documentToScreenRow(m,0),b=e.getRowLength(m)*w,g=Math.min(e.screenToDocumentRow(g,0),e.getLength()-1),f=t.scrollerHeight+e.getRowLength(g)*w+b,d=this.scrollTop-y*w;var S=0;if(this.layerConfig.width!=s||u)S=this.CHANGE_H_SCROLL;if(u||p)S|=this.$updateCachedSize(!0,this.gutterWidth,t.width,t.height),this._signal("scrollbarVisibilityChanged"),p&&(s=this.$getLongestLine());return this.layerConfig={width:s,padding:this.$padding,firstRow:m,firstRowScreen:y,lastRow:g,lineHeight:w,characterWidth:this.characterWidth,minHeight:f,maxHeight:i,offset:d,gutterOffset:w?Math.max(0,Math.ceil((d+t.height-t.scrollerHeight)/w)):0,height:this.$size.scrollerHeight},this.session.$bidiHandler&&this.session.$bidiHandler.setContentWidth(s-this.$padding),S},this.$updateLines=function(){if(!this.$changedLines)return;var e=this.$changedLines.firstRow,t=this.$changedLines.lastRow;this.$changedLines=null;var n=this.layerConfig;if(e>n.lastRow+1)return;if(t<n.firstRow)return;if(t===Infinity){this.$showGutter&&this.$gutterLayer.update(n),this.$textLayer.update(n);return}return this.$textLayer.updateLines(n,e,t),!0},this.$getLongestLine=function(){var e=this.session.getScreenWidth();return this.showInvisibles&&!this.session.$useWrapMode&&(e+=1),this.$textLayer&&e>this.$textLayer.MAX_LINE_LENGTH&&(e=this.$textLayer.MAX_LINE_LENGTH+30),Math.max(this.$size.scrollerWidth-2*this.$padding,Math.round(e*this.characterWidth))},this.updateFrontMarkers=function(){this.$markerFront.setMarkers(this.session.getMarkers(!0)),this.$loop.schedule(this.CHANGE_MARKER_FRONT)},this.updateBackMarkers=function(){this.$markerBack.setMarkers(this.session.getMarkers()),this.$loop.schedule(this.CHANGE_MARKER_BACK)},this.addGutterDecoration=function(e,t){this.$gutterLayer.addGutterDecoration(e,t)},this.removeGutterDecoration=function(e,t){this.$gutterLayer.removeGutterDecoration(e,t)},this.updateBreakpoints=function(e){this.$loop.schedule(this.CHANGE_GUTTER)},this.setAnnotations=function(e){this.$gutterLayer.setAnnotations(e),this.$loop.schedule(this.CHANGE_GUTTER)},this.updateCursor=function(){this.$loop.schedule(this.CHANGE_CURSOR)},this.hideCursor=function(){this.$cursorLayer.hideCursor()},this.showCursor=function(){this.$cursorLayer.showCursor()},this.scrollSelectionIntoView=function(e,t,n){this.scrollCursorIntoView(e,n),this.scrollCursorIntoView(t,n)},this.scrollCursorIntoView=function(e,t,n){if(this.$size.scrollerHeight===0)return;var r=this.$cursorLayer.getPixelPosition(e),i=r.left,s=r.top,o=n&&n.top||0,u=n&&n.bottom||0,a=this.$scrollAnimation?this.session.getScrollTop():this.scrollTop;a+o>s?(t&&a+o>s+this.lineHeight&&(s-=t*this.$size.scrollerHeight),s===0&&(s=-this.scrollMargin.top),this.session.setScrollTop(s)):a+this.$size.scrollerHeight-u<s+this.lineHeight&&(t&&a+this.$size.scrollerHeight-u<s-this.lineHeight&&(s+=t*this.$size.scrollerHeight),this.session.setScrollTop(s+this.lineHeight+u-this.$size.scrollerHeight));var f=this.scrollLeft;f>i?(i<this.$padding+2*this.layerConfig.characterWidth&&(i=-this.scrollMargin.left),this.session.setScrollLeft(i)):f+this.$size.scrollerWidth<i+this.characterWidth?this.session.setScrollLeft(Math.round(i+this.characterWidth-this.$size.scrollerWidth)):f<=this.$padding&&i-f<this.characterWidth&&this.session.setScrollLeft(0)},this.getScrollTop=function(){return this.session.getScrollTop()},this.getScrollLeft=function(){return this.session.getScrollLeft()},this.getScrollTopRow=function(){return this.scrollTop/this.lineHeight},this.getScrollBottomRow=function(){return Math.max(0,Math.floor((this.scrollTop+this.$size.scrollerHeight)/this.lineHeight)-1)},this.scrollToRow=function(e){this.session.setScrollTop(e*this.lineHeight)},this.alignCursor=function(e,t){typeof e=="number"&&(e={row:e,column:0});var n=this.$cursorLayer.getPixelPosition(e),r=this.$size.scrollerHeight-this.lineHeight,i=n.top-r*(t||0);return this.session.setScrollTop(i),i},this.STEPS=8,this.$calcSteps=function(e,t){var n=0,r=this.STEPS,i=[],s=function(e,t,n){return n*(Math.pow(e-1,3)+1)+t};for(n=0;n<r;++n)i.push(s(n/this.STEPS,e,t-e));return i},this.scrollToLine=function(e,t,n,r){var i=this.$cursorLayer.getPixelPosition({row:e,column:0}),s=i.top;t&&(s-=this.$size.scrollerHeight/2);var o=this.scrollTop;this.session.setScrollTop(s),n!==!1&&this.animateScrolling(o,r)},this.animateScrolling=function(e,t){var n=this.scrollTop;if(!this.$animatedScroll)return;var r=this;if(e==n)return;if(this.$scrollAnimation){var i=this.$scrollAnimation.steps;if(i.length){e=i[0];if(e==n)return}}var s=r.$calcSteps(e,n);this.$scrollAnimation={from:e,to:n,steps:s},clearInterval(this.$timer),r.session.setScrollTop(s.shift()),r.session.$scrollTop=n,this.$timer=setInterval(function(){s.length?(r.session.setScrollTop(s.shift()),r.session.$scrollTop=n):n!=null?(r.session.$scrollTop=-1,r.session.setScrollTop(n),n=null):(r.$timer=clearInterval(r.$timer),r.$scrollAnimation=null,t&&t())},10)},this.scrollToY=function(e){this.scrollTop!==e&&(this.$loop.schedule(this.CHANGE_SCROLL),this.scrollTop=e)},this.scrollToX=function(e){this.scrollLeft!==e&&(this.scrollLeft=e),this.$loop.schedule(this.CHANGE_H_SCROLL)},this.scrollTo=function(e,t){this.session.setScrollTop(t),this.session.setScrollLeft(t)},this.scrollBy=function(e,t){t&&this.session.setScrollTop(this.session.getScrollTop()+t),e&&this.session.setScrollLeft(this.session.getScrollLeft()+e)},this.isScrollableBy=function(e,t){if(t<0&&this.session.getScrollTop()>=1-this.scrollMargin.top)return!0;if(t>0&&this.session.getScrollTop()+this.$size.scrollerHeight-this.layerConfig.maxHeight<-1+this.scrollMargin.bottom)return!0;if(e<0&&this.session.getScrollLeft()>=1-this.scrollMargin.left)return!0;if(e>0&&this.session.getScrollLeft()+this.$size.scrollerWidth-this.layerConfig.width<-1+this.scrollMargin.right)return!0},this.pixelToScreenCoordinates=function(e,t){var n;if(this.$hasCssTransforms){n={top:0,left:0};var r=this.$fontMetrics.transformCoordinates([e,t]);e=r[1]-this.gutterWidth-this.margin.left,t=r[0]}else n=this.scroller.getBoundingClientRect();var i=e+this.scrollLeft-n.left-this.$padding,s=i/this.characterWidth,o=Math.floor((t+this.scrollTop-n.top)/this.lineHeight),u=this.$blockCursor?Math.floor(s):Math.round(s);return{row:o,column:u,side:s-u>0?1:-1,offsetX:i}},this.screenToTextCoordinates=function(e,t){var n;if(this.$hasCssTransforms){n={top:0,left:0};var r=this.$fontMetrics.transformCoordinates([e,t]);e=r[1]-this.gutterWidth-this.margin.left,t=r[0]}else n=this.scroller.getBoundingClientRect();var i=e+this.scrollLeft-n.left-this.$padding,s=i/this.characterWidth,o=this.$blockCursor?Math.floor(s):Math.round(s),u=Math.floor((t+this.scrollTop-n.top)/this.lineHeight);return this.session.screenToDocumentPosition(u,Math.max(o,0),i)},this.textToScreenCoordinates=function(e,t){var n=this.scroller.getBoundingClientRect(),r=this.session.documentToScreenPosition(e,t),i=this.$padding+(this.session.$bidiHandler.isBidiRow(r.row,e)?this.session.$bidiHandler.getPosLeft(r.column):Math.round(r.column*this.characterWidth)),s=r.row*this.lineHeight;return{pageX:n.left+i-this.scrollLeft,pageY:n.top+s-this.scrollTop}},this.visualizeFocus=function(){i.addCssClass(this.container,"ace_focus")},this.visualizeBlur=function(){i.removeCssClass(this.container,"ace_focus")},this.showComposition=function(e){this.$composition=e,e.cssText||(e.cssText=this.textarea.style.cssText),e.useTextareaForIME=this.$useTextareaForIME,this.$useTextareaForIME?(i.addCssClass(this.textarea,"ace_composition"),this.textarea.style.cssText="",this.$moveTextAreaToCursor(),this.$cursorLayer.element.style.display="none"):e.markerId=this.session.addMarker(e.markerRange,"ace_composition_marker","text")},this.setCompositionText=function(e){var t=this.session.selection.cursor;this.addToken(e,"composition_placeholder",t.row,t.column),this.$moveTextAreaToCursor()},this.hideComposition=function(){if(!this.$composition)return;this.$composition.markerId&&this.session.removeMarker(this.$composition.markerId),i.removeCssClass(this.textarea,"ace_composition"),this.textarea.style.cssText=this.$composition.cssText,this.$composition=null,this.$cursorLayer.element.style.display=""},this.addToken=function(e,t,n,r){var i=this.session;i.bgTokenizer.lines[n]=null;var s={type:t,value:e},o=i.getTokens(n);if(r==null)o.push(s);else{var u=0;for(var a=0;a<o.length;a++){var f=o[a];u+=f.value.length;if(r<=u){var l=f.value.length-(u-r),c=f.value.slice(0,l),h=f.value.slice(l);o.splice(a,1,{type:f.type,value:c},s,{type:f.type,value:h});break}}}this.updateLines(n,n)},this.setTheme=function(e,t){function o(r){if(n.$themeId!=e)return t&&t();if(!r||!r.cssClass)throw new Error("couldn't load module "+e+" or it didn't call define");r.$id&&(n.$themeId=r.$id),i.importCssString(r.cssText,r.cssClass,n.container),n.theme&&i.removeCssClass(n.container,n.theme.cssClass);var s="padding"in r?r.padding:"padding"in(n.theme||{})?4:n.$padding;n.$padding&&s!=n.$padding&&n.setPadding(s),n.$theme=r.cssClass,n.theme=r,i.addCssClass(n.container,r.cssClass),i.setCssClass(n.container,"ace_dark",r.isDark),n.$size&&(n.$size.width=0,n.$updateSizeAsync()),n._dispatchEvent("themeLoaded",{theme:r}),t&&t()}var n=this;this.$themeId=e,n._dispatchEvent("themeChange",{theme:e});if(!e||typeof e=="string"){var r=e||this.$options.theme.initialValue;s.loadModule(["theme",r],o)}else o(e)},this.getTheme=function(){return this.$themeId},this.setStyle=function(e,t){i.setCssClass(this.container,e,t!==!1)},this.unsetStyle=function(e){i.removeCssClass(this.container,e)},this.setCursorStyle=function(e){i.setStyle(this.scroller.style,"cursor",e)},this.setMouseCursor=function(e){i.setStyle(this.scroller.style,"cursor",e)},this.attachToShadowRoot=function(){i.importCssString(v,"ace_editor.css",this.container)},this.destroy=function(){this.freeze(),this.$fontMetrics.destroy(),this.$cursorLayer.destroy()}}).call(y.prototype),s.defineOptions(y.prototype,"renderer",{animatedScroll:{initialValue:!1},showInvisibles:{set:function(e){this.$textLayer.setShowInvisibles(e)&&this.$loop.schedule(this.CHANGE_TEXT)},initialValue:!1},showPrintMargin:{set:function(){this.$updatePrintMargin()},initialValue:!0},printMarginColumn:{set:function(){this.$updatePrintMargin()},initialValue:80},printMargin:{set:function(e){typeof e=="number"&&(this.$printMarginColumn=e),this.$showPrintMargin=!!e,this.$updatePrintMargin()},get:function(){return this.$showPrintMargin&&this.$printMarginColumn}},showGutter:{set:function(e){this.$gutter.style.display=e?"block":"none",this.$loop.schedule(this.CHANGE_FULL),this.onGutterResize()},initialValue:!0},fadeFoldWidgets:{set:function(e){i.setCssClass(this.$gutter,"ace_fade-fold-widgets",e)},initialValue:!1},showFoldWidgets:{set:function(e){this.$gutterLayer.setShowFoldWidgets(e),this.$loop.schedule(this.CHANGE_GUTTER)},initialValue:!0},displayIndentGuides:{set:function(e){this.$textLayer.setDisplayIndentGuides(e)&&this.$loop.schedule(this.CHANGE_TEXT)},initialValue:!0},highlightGutterLine:{set:function(e){this.$gutterLayer.setHighlightGutterLine(e),this.$loop.schedule(this.CHANGE_GUTTER)},initialValue:!0},hScrollBarAlwaysVisible:{set:function(e){(!this.$hScrollBarAlwaysVisible||!this.$horizScroll)&&this.$loop.schedule(this.CHANGE_SCROLL)},initialValue:!1},vScrollBarAlwaysVisible:{set:function(e){(!this.$vScrollBarAlwaysVisible||!this.$vScroll)&&this.$loop.schedule(this.CHANGE_SCROLL)},initialValue:!1},fontSize:{set:function(e){typeof e=="number"&&(e+="px"),this.container.style.fontSize=e,this.updateFontSize()},initialValue:12},fontFamily:{set:function(e){this.container.style.fontFamily=e,this.updateFontSize()}},maxLines:{set:function(e){this.updateFull()}},minLines:{set:function(e){this.$minLines<562949953421311||(this.$minLines=0),this.updateFull()}},maxPixelHeight:{set:function(e){this.updateFull()},initialValue:0},scrollPastEnd:{set:function(e){e=+e||0;if(this.$scrollPastEnd==e)return;this.$scrollPastEnd=e,this.$loop.schedule(this.CHANGE_SCROLL)},initialValue:0,handlesSet:!0},fixedWidthGutter:{set:function(e){this.$gutterLayer.$fixedWidth=!!e,this.$loop.schedule(this.CHANGE_GUTTER)}},theme:{set:function(e){this.setTheme(e)},get:function(){return this.$themeId||this.theme},initialValue:"./theme/textmate",handlesSet:!0},hasCssTransforms:{},useTextareaForIME:{initialValue:!m.isMobile&&!m.isIE}}),t.VirtualRenderer=y}),ace.define("ace/worker/worker_client",["require","exports","module","ace/lib/oop","ace/lib/net","ace/lib/event_emitter","ace/config"],function(e,t,n){"use strict";function u(e){var t="importScripts('"+i.qualifyURL(e)+"');";try{return new Blob([t],{type:"application/javascript"})}catch(n){var r=window.BlobBuilder||window.WebKitBlobBuilder||window.MozBlobBuilder,s=new r;return s.append(t),s.getBlob("application/javascript")}}function a(e){if(typeof Worker=="undefined")return{postMessage:function(){},terminate:function(){}};if(o.get("loadWorkerFromBlob")){var t=u(e),n=window.URL||window.webkitURL,r=n.createObjectURL(t);return new Worker(r)}return new Worker(e)}var r=e("../lib/oop"),i=e("../lib/net"),s=e("../lib/event_emitter").EventEmitter,o=e("../config"),f=function(e){e.postMessage||(e=this.$createWorkerFromOldConfig.apply(this,arguments)),this.$worker=e,this.$sendDeltaQueue=this.$sendDeltaQueue.bind(this),this.changeListener=this.changeListener.bind(this),this.onMessage=this.onMessage.bind(this),this.callbackId=1,this.callbacks={},this.$worker.onmessage=this.onMessage};(function(){r.implement(this,s),this.$createWorkerFromOldConfig=function(t,n,r,i,s){e.nameToUrl&&!e.toUrl&&(e.toUrl=e.nameToUrl);if(o.get("packaged")||!e.toUrl)i=i||o.moduleUrl(n,"worker");else{var u=this.$normalizePath;i=i||u(e.toUrl("ace/worker/worker.js",null,"_"));var f={};t.forEach(function(t){f[t]=u(e.toUrl(t,null,"_").replace(/(\.js)?(\?.*)?$/,""))})}return this.$worker=a(i),s&&this.send("importScripts",s),this.$worker.postMessage({init:!0,tlns:f,module:n,classname:r}),this.$worker},this.onMessage=function(e){var t=e.data;switch(t.type){case"event":this._signal(t.name,{data:t.data});break;case"call":var n=this.callbacks[t.id];n&&(n(t.data),delete this.callbacks[t.id]);break;case"error":this.reportError(t.data);break;case"log":window.console&&console.log&&console.log.apply(console,t.data)}},this.reportError=function(e){window.console&&console.error&&console.error(e)},this.$normalizePath=function(e){return i.qualifyURL(e)},this.terminate=function(){this._signal("terminate",{}),this.deltaQueue=null,this.$worker.terminate(),this.$worker=null,this.$doc&&this.$doc.off("change",this.changeListener),this.$doc=null},this.send=function(e,t){this.$worker.postMessage({command:e,args:t})},this.call=function(e,t,n){if(n){var r=this.callbackId++;this.callbacks[r]=n,t.push(r)}this.send(e,t)},this.emit=function(e,t){try{t.data&&t.data.err&&(t.data.err={message:t.data.err.message,stack:t.data.err.stack,code:t.data.err.code}),this.$worker.postMessage({event:e,data:{data:t.data}})}catch(n){console.error(n.stack)}},this.attachToDocument=function(e){this.$doc&&this.terminate(),this.$doc=e,this.call("setValue",[e.getValue()]),e.on("change",this.changeListener)},this.changeListener=function(e){this.deltaQueue||(this.deltaQueue=[],setTimeout(this.$sendDeltaQueue,0)),e.action=="insert"?this.deltaQueue.push(e.start,e.lines):this.deltaQueue.push(e.start,e.end)},this.$sendDeltaQueue=function(){var e=this.deltaQueue;if(!e)return;this.deltaQueue=null,e.length>50&&e.length>this.$doc.getLength()>>1?this.call("setValue",[this.$doc.getValue()]):this.emit("change",{data:e})}}).call(f.prototype);var l=function(e,t,n){var r=null,i=!1,u=Object.create(s),a=[],l=new f({messageBuffer:a,terminate:function(){},postMessage:function(e){a.push(e);if(!r)return;i?setTimeout(c):c()}});l.setEmitSync=function(e){i=e};var c=function(){var e=a.shift();e.command?r[e.command].apply(r,e.args):e.event&&u._signal(e.event,e.data)};return u.postMessage=function(e){l.onMessage({data:e})},u.callback=function(e,t){this.postMessage({type:"call",id:t,data:e})},u.emit=function(e,t){this.postMessage({type:"event",name:e,data:t})},o.loadModule(["worker",t],function(e){r=new e[n](u);while(a.length)c()}),l};t.UIWorkerClient=l,t.WorkerClient=f,t.createWorker=a}),ace.define("ace/placeholder",["require","exports","module","ace/range","ace/lib/event_emitter","ace/lib/oop"],function(e,t,n){"use strict";var r=e("./range").Range,i=e("./lib/event_emitter").EventEmitter,s=e("./lib/oop"),o=function(e,t,n,r,i,s){var o=this;this.length=t,this.session=e,this.doc=e.getDocument(),this.mainClass=i,this.othersClass=s,this.$onUpdate=this.onUpdate.bind(this),this.doc.on("change",this.$onUpdate),this.$others=r,this.$onCursorChange=function(){setTimeout(function(){o.onCursorChange()})},this.$pos=n;var u=e.getUndoManager().$undoStack||e.getUndoManager().$undostack||{length:-1};this.$undoStackDepth=u.length,this.setup(),e.selection.on("changeCursor",this.$onCursorChange)};(function(){s.implement(this,i),this.setup=function(){var e=this,t=this.doc,n=this.session;this.selectionBefore=n.selection.toJSON(),n.selection.inMultiSelectMode&&n.selection.toSingleRange(),this.pos=t.createAnchor(this.$pos.row,this.$pos.column);var i=this.pos;i.$insertRight=!0,i.detach(),i.markerId=n.addMarker(new r(i.row,i.column,i.row,i.column+this.length),this.mainClass,null,!1),this.others=[],this.$others.forEach(function(n){var r=t.createAnchor(n.row,n.column);r.$insertRight=!0,r.detach(),e.others.push(r)}),n.setUndoSelect(!1)},this.showOtherMarkers=function(){if(this.othersActive)return;var e=this.session,t=this;this.othersActive=!0,this.others.forEach(function(n){n.markerId=e.addMarker(new r(n.row,n.column,n.row,n.column+t.length),t.othersClass,null,!1)})},this.hideOtherMarkers=function(){if(!this.othersActive)return;this.othersActive=!1;for(var e=0;e<this.others.length;e++)this.session.removeMarker(this.others[e].markerId)},this.onUpdate=function(e){if(this.$updating)return this.updateAnchors(e);var t=e;if(t.start.row!==t.end.row)return;if(t.start.row!==this.pos.row)return;this.$updating=!0;var n=e.action==="insert"?t.end.column-t.start.column:t.start.column-t.end.column,i=t.start.column>=this.pos.column&&t.start.column<=this.pos.column+this.length+1,s=t.start.column-this.pos.column;this.updateAnchors(e),i&&(this.length+=n);if(i&&!this.session.$fromUndo)if(e.action==="insert")for(var o=this.others.length-1;o>=0;o--){var u=this.others[o],a={row:u.row,column:u.column+s};this.doc.insertMergedLines(a,e.lines)}else if(e.action==="remove")for(var o=this.others.length-1;o>=0;o--){var u=this.others[o],a={row:u.row,column:u.column+s};this.doc.remove(new r(a.row,a.column,a.row,a.column-n))}this.$updating=!1,this.updateMarkers()},this.updateAnchors=function(e){this.pos.onChange(e);for(var t=this.others.length;t--;)this.others[t].onChange(e);this.updateMarkers()},this.updateMarkers=function(){if(this.$updating)return;var e=this,t=this.session,n=function(n,i){t.removeMarker(n.markerId),n.markerId=t.addMarker(new r(n.row,n.column,n.row,n.column+e.length),i,null,!1)};n(this.pos,this.mainClass);for(var i=this.others.length;i--;)n(this.others[i],this.othersClass)},this.onCursorChange=function(e){if(this.$updating||!this.session)return;var t=this.session.selection.getCursor();t.row===this.pos.row&&t.column>=this.pos.column&&t.column<=this.pos.column+this.length?(this.showOtherMarkers(),this._emit("cursorEnter",e)):(this.hideOtherMarkers(),this._emit("cursorLeave",e))},this.detach=function(){this.session.removeMarker(this.pos&&this.pos.markerId),this.hideOtherMarkers(),this.doc.removeEventListener("change",this.$onUpdate),this.session.selection.removeEventListener("changeCursor",this.$onCursorChange),this.session.setUndoSelect(!0),this.session=null},this.cancel=function(){if(this.$undoStackDepth===-1)return;var e=this.session.getUndoManager(),t=(e.$undoStack||e.$undostack).length-this.$undoStackDepth;for(var n=0;n<t;n++)e.undo(this.session,!0);this.selectionBefore&&this.session.selection.fromJSON(this.selectionBefore)}}).call(o.prototype),t.PlaceHolder=o}),ace.define("ace/mouse/multi_select_handler",["require","exports","module","ace/lib/event","ace/lib/useragent"],function(e,t,n){function s(e,t){return e.row==t.row&&e.column==t.column}function o(e){var t=e.domEvent,n=t.altKey,o=t.shiftKey,u=t.ctrlKey,a=e.getAccelKey(),f=e.getButton();u&&i.isMac&&(f=t.button);if(e.editor.inMultiSelectMode&&f==2){e.editor.textInput.onContextMenu(e.domEvent);return}if(!u&&!n&&!a){f===0&&e.editor.inMultiSelectMode&&e.editor.exitMultiSelectMode();return}if(f!==0)return;var l=e.editor,c=l.selection,h=l.inMultiSelectMode,p=e.getDocumentPosition(),d=c.getCursor(),v=e.inSelection()||c.isEmpty()&&s(p,d),m=e.x,g=e.y,y=function(e){m=e.clientX,g=e.clientY},b=l.session,w=l.renderer.pixelToScreenCoordinates(m,g),E=w,S;if(l.$mouseHandler.$enableJumpToDef)u&&n||a&&n?S=o?"block":"add":n&&l.$blockSelectEnabled&&(S="block");else if(a&&!n){S="add";if(!h&&o)return}else n&&l.$blockSelectEnabled&&(S="block");S&&i.isMac&&t.ctrlKey&&l.$mouseHandler.cancelContextMenu();if(S=="add"){if(!h&&v)return;if(!h){var x=c.toOrientedRange();l.addSelectionMarker(x)}var T=c.rangeList.rangeAtPoint(p);l.inVirtualSelectionMode=!0,o&&(T=null,x=c.ranges[0]||x,l.removeSelectionMarker(x)),l.once("mouseup",function(){var e=c.toOrientedRange();T&&e.isEmpty()&&s(T.cursor,e.cursor)?c.substractPoint(e.cursor):(o?c.substractPoint(x.cursor):x&&(l.removeSelectionMarker(x),c.addRange(x)),c.addRange(e)),l.inVirtualSelectionMode=!1})}else if(S=="block"){e.stop(),l.inVirtualSelectionMode=!0;var N,C=[],k=function(){var e=l.renderer.pixelToScreenCoordinates(m,g),t=b.screenToDocumentPosition(e.row,e.column,e.offsetX);if(s(E,e)&&s(t,c.lead))return;E=e,l.selection.moveToPosition(t),l.renderer.scrollCursorIntoView(),l.removeSelectionMarkers(C),C=c.rectangularRangeBlock(E,w),l.$mouseHandler.$clickSelection&&C.length==1&&C[0].isEmpty()&&(C[0]=l.$mouseHandler.$clickSelection.clone()),C.forEach(l.addSelectionMarker,l),l.updateSelectionMarkers()};h&&!a?c.toSingleRange():!h&&a&&(N=c.toOrientedRange(),l.addSelectionMarker(N)),o?w=b.documentToScreenPosition(c.lead):c.moveToPosition(p),E={row:-1,column:-1};var L=function(e){k(),clearInterval(O),l.removeSelectionMarkers(C),C.length||(C=[c.toOrientedRange()]),N&&(l.removeSelectionMarker(N),c.toSingleRange(N));for(var t=0;t<C.length;t++)c.addRange(C[t]);l.inVirtualSelectionMode=!1,l.$mouseHandler.$clickSelection=null},A=k;r.capture(l.container,y,L);var O=setInterval(function(){A()},20);return e.preventDefault()}}var r=e("../lib/event"),i=e("../lib/useragent");t.onMouseDown=o}),ace.define("ace/commands/multi_select_commands",["require","exports","module","ace/keyboard/hash_handler"],function(e,t,n){t.defaultCommands=[{name:"addCursorAbove",description:"Add cursor above",exec:function(e){e.selectMoreLines(-1)},bindKey:{win:"Ctrl-Alt-Up",mac:"Ctrl-Alt-Up"},scrollIntoView:"cursor",readOnly:!0},{name:"addCursorBelow",description:"Add cursor below",exec:function(e){e.selectMoreLines(1)},bindKey:{win:"Ctrl-Alt-Down",mac:"Ctrl-Alt-Down"},scrollIntoView:"cursor",readOnly:!0},{name:"addCursorAboveSkipCurrent",description:"Add cursor above (skip current)",exec:function(e){e.selectMoreLines(-1,!0)},bindKey:{win:"Ctrl-Alt-Shift-Up",mac:"Ctrl-Alt-Shift-Up"},scrollIntoView:"cursor",readOnly:!0},{name:"addCursorBelowSkipCurrent",description:"Add cursor below (skip current)",exec:function(e){e.selectMoreLines(1,!0)},bindKey:{win:"Ctrl-Alt-Shift-Down",mac:"Ctrl-Alt-Shift-Down"},scrollIntoView:"cursor",readOnly:!0},{name:"selectMoreBefore",description:"Select more before",exec:function(e){e.selectMore(-1)},bindKey:{win:"Ctrl-Alt-Left",mac:"Ctrl-Alt-Left"},scrollIntoView:"cursor",readOnly:!0},{name:"selectMoreAfter",description:"Select more after",exec:function(e){e.selectMore(1)},bindKey:{win:"Ctrl-Alt-Right",mac:"Ctrl-Alt-Right"},scrollIntoView:"cursor",readOnly:!0},{name:"selectNextBefore",description:"Select next before",exec:function(e){e.selectMore(-1,!0)},bindKey:{win:"Ctrl-Alt-Shift-Left",mac:"Ctrl-Alt-Shift-Left"},scrollIntoView:"cursor",readOnly:!0},{name:"selectNextAfter",description:"Select next after",exec:function(e){e.selectMore(1,!0)},bindKey:{win:"Ctrl-Alt-Shift-Right",mac:"Ctrl-Alt-Shift-Right"},scrollIntoView:"cursor",readOnly:!0},{name:"splitIntoLines",description:"Split into lines",exec:function(e){e.multiSelect.splitIntoLines()},bindKey:{win:"Ctrl-Alt-L",mac:"Ctrl-Alt-L"},readOnly:!0},{name:"alignCursors",description:"Align cursors",exec:function(e){e.alignCursors()},bindKey:{win:"Ctrl-Alt-A",mac:"Ctrl-Alt-A"},scrollIntoView:"cursor"},{name:"findAll",description:"Find all",exec:function(e){e.findAll()},bindKey:{win:"Ctrl-Alt-K",mac:"Ctrl-Alt-G"},scrollIntoView:"cursor",readOnly:!0}],t.multiSelectCommands=[{name:"singleSelection",description:"Single selection",bindKey:"esc",exec:function(e){e.exitMultiSelectMode()},scrollIntoView:"cursor",readOnly:!0,isAvailable:function(e){return e&&e.inMultiSelectMode}}];var r=e("../keyboard/hash_handler").HashHandler;t.keyboardHandler=new r(t.multiSelectCommands)}),ace.define("ace/multi_select",["require","exports","module","ace/range_list","ace/range","ace/selection","ace/mouse/multi_select_handler","ace/lib/event","ace/lib/lang","ace/commands/multi_select_commands","ace/search","ace/edit_session","ace/editor","ace/config"],function(e,t,n){function h(e,t,n){return c.$options.wrap=!0,c.$options.needle=t,c.$options.backwards=n==-1,c.find(e)}function v(e,t){return e.row==t.row&&e.column==t.column}function m(e){if(e.$multiselectOnSessionChange)return;e.$onAddRange=e.$onAddRange.bind(e),e.$onRemoveRange=e.$onRemoveRange.bind(e),e.$onMultiSelect=e.$onMultiSelect.bind(e),e.$onSingleSelect=e.$onSingleSelect.bind(e),e.$multiselectOnSessionChange=t.onSessionChange.bind(e),e.$checkMultiselectChange=e.$checkMultiselectChange.bind(e),e.$multiselectOnSessionChange(e),e.on("changeSession",e.$multiselectOnSessionChange),e.on("mousedown",o),e.commands.addCommands(f.defaultCommands),g(e)}function g(e){function r(t){n&&(e.renderer.setMouseCursor(""),n=!1)}if(!e.textInput)return;var t=e.textInput.getElement(),n=!1;u.addListener(t,"keydown",function(t){var i=t.keyCode==18&&!(t.ctrlKey||t.shiftKey||t.metaKey);e.$blockSelectEnabled&&i?n||(e.renderer.setMouseCursor("crosshair"),n=!0):n&&r()}),u.addListener(t,"keyup",r),u.addListener(t,"blur",r)}var r=e("./range_list").RangeList,i=e("./range").Range,s=e("./selection").Selection,o=e("./mouse/multi_select_handler").onMouseDown,u=e("./lib/event"),a=e("./lib/lang"),f=e("./commands/multi_select_commands");t.commands=f.defaultCommands.concat(f.multiSelectCommands);var l=e("./search").Search,c=new l,p=e("./edit_session").EditSession;(function(){this.getSelectionMarkers=function(){return this.$selectionMarkers}}).call(p.prototype),function(){this.ranges=null,this.rangeList=null,this.addRange=function(e,t){if(!e)return;if(!this.inMultiSelectMode&&this.rangeCount===0){var n=this.toOrientedRange();this.rangeList.add(n),this.rangeList.add(e);if(this.rangeList.ranges.length!=2)return this.rangeList.removeAll(),t||this.fromOrientedRange(e);this.rangeList.removeAll(),this.rangeList.add(n),this.$onAddRange(n)}e.cursor||(e.cursor=e.end);var r=this.rangeList.add(e);return this.$onAddRange(e),r.length&&this.$onRemoveRange(r),this.rangeCount>1&&!this.inMultiSelectMode&&(this._signal("multiSelect"),this.inMultiSelectMode=!0,this.session.$undoSelect=!1,this.rangeList.attach(this.session)),t||this.fromOrientedRange(e)},this.toSingleRange=function(e){e=e||this.ranges[0];var t=this.rangeList.removeAll();t.length&&this.$onRemoveRange(t),e&&this.fromOrientedRange(e)},this.substractPoint=function(e){var t=this.rangeList.substractPoint(e);if(t)return this.$onRemoveRange(t),t[0]},this.mergeOverlappingRanges=function(){var e=this.rangeList.merge();e.length&&this.$onRemoveRange(e)},this.$onAddRange=function(e){this.rangeCount=this.rangeList.ranges.length,this.ranges.unshift(e),this._signal("addRange",{range:e})},this.$onRemoveRange=function(e){this.rangeCount=this.rangeList.ranges.length;if(this.rangeCount==1&&this.inMultiSelectMode){var t=this.rangeList.ranges.pop();e.push(t),this.rangeCount=0}for(var n=e.length;n--;){var r=this.ranges.indexOf(e[n]);this.ranges.splice(r,1)}this._signal("removeRange",{ranges:e}),this.rangeCount===0&&this.inMultiSelectMode&&(this.inMultiSelectMode=!1,this._signal("singleSelect"),this.session.$undoSelect=!0,this.rangeList.detach(this.session)),t=t||this.ranges[0],t&&!t.isEqual(this.getRange())&&this.fromOrientedRange(t)},this.$initRangeList=function(){if(this.rangeList)return;this.rangeList=new r,this.ranges=[],this.rangeCount=0},this.getAllRanges=function(){return this.rangeCount?this.rangeList.ranges.concat():[this.getRange()]},this.splitIntoLines=function(){if(this.rangeCount>1){var e=this.rangeList.ranges,t=e[e.length-1],n=i.fromPoints(e[0].start,t.end);this.toSingleRange(),this.setSelectionRange(n,t.cursor==t.start)}else{var n=this.getRange(),r=this.isBackwards(),s=n.start.row,o=n.end.row;if(s==o){if(r)var u=n.end,a=n.start;else var u=n.start,a=n.end;this.addRange(i.fromPoints(a,a)),this.addRange(i.fromPoints(u,u));return}var f=[],l=this.getLineRange(s,!0);l.start.column=n.start.column,f.push(l);for(var c=s+1;c<o;c++)f.push(this.getLineRange(c,!0));l=this.getLineRange(o,!0),l.end.column=n.end.column,f.push(l),f.forEach(this.addRange,this)}},this.toggleBlockSelection=function(){if(this.rangeCount>1){var e=this.rangeList.ranges,t=e[e.length-1],n=i.fromPoints(e[0].start,t.end);this.toSingleRange(),this.setSelectionRange(n,t.cursor==t.start)}else{var r=this.session.documentToScreenPosition(this.cursor),s=this.session.documentToScreenPosition(this.anchor),o=this.rectangularRangeBlock(r,s);o.forEach(this.addRange,this)}},this.rectangularRangeBlock=function(e,t,n){var r=[],s=e.column<t.column;if(s)var o=e.column,u=t.column,a=e.offsetX,f=t.offsetX;else var o=t.column,u=e.column,a=t.offsetX,f=e.offsetX;var l=e.row<t.row;if(l)var c=e.row,h=t.row;else var c=t.row,h=e.row;o<0&&(o=0),c<0&&(c=0),c==h&&(n=!0);var p;for(var d=c;d<=h;d++){var m=i.fromPoints(this.session.screenToDocumentPosition(d,o,a),this.session.screenToDocumentPosition(d,u,f));if(m.isEmpty()){if(p&&v(m.end,p))break;p=m.end}m.cursor=s?m.start:m.end,r.push(m)}l&&r.reverse();if(!n){var g=r.length-1;while(r[g].isEmpty()&&g>0)g--;if(g>0){var y=0;while(r[y].isEmpty())y++}for(var b=g;b>=y;b--)r[b].isEmpty()&&r.splice(b,1)}return r}}.call(s.prototype);var d=e("./editor").Editor;(function(){this.updateSelectionMarkers=function(){this.renderer.updateCursor(),this.renderer.updateBackMarkers()},this.addSelectionMarker=function(e){e.cursor||(e.cursor=e.end);var t=this.getSelectionStyle();return e.marker=this.session.addMarker(e,"ace_selection",t),this.session.$selectionMarkers.push(e),this.session.selectionMarkerCount=this.session.$selectionMarkers.length,e},this.removeSelectionMarker=function(e){if(!e.marker)return;this.session.removeMarker(e.marker);var t=this.session.$selectionMarkers.indexOf(e);t!=-1&&this.session.$selectionMarkers.splice(t,1),this.session.selectionMarkerCount=this.session.$selectionMarkers.length},this.removeSelectionMarkers=function(e){var t=this.session.$selectionMarkers;for(var n=e.length;n--;){var r=e[n];if(!r.marker)continue;this.session.removeMarker(r.marker);var i=t.indexOf(r);i!=-1&&t.splice(i,1)}this.session.selectionMarkerCount=t.length},this.$onAddRange=function(e){this.addSelectionMarker(e.range),this.renderer.updateCursor(),this.renderer.updateBackMarkers()},this.$onRemoveRange=function(e){this.removeSelectionMarkers(e.ranges),this.renderer.updateCursor(),this.renderer.updateBackMarkers()},this.$onMultiSelect=function(e){if(this.inMultiSelectMode)return;this.inMultiSelectMode=!0,this.setStyle("ace_multiselect"),this.keyBinding.addKeyboardHandler(f.keyboardHandler),this.commands.setDefaultHandler("exec",this.$onMultiSelectExec),this.renderer.updateCursor(),this.renderer.updateBackMarkers()},this.$onSingleSelect=function(e){if(this.session.multiSelect.inVirtualMode)return;this.inMultiSelectMode=!1,this.unsetStyle("ace_multiselect"),this.keyBinding.removeKeyboardHandler(f.keyboardHandler),this.commands.removeDefaultHandler("exec",this.$onMultiSelectExec),this.renderer.updateCursor(),this.renderer.updateBackMarkers(),this._emit("changeSelection")},this.$onMultiSelectExec=function(e){var t=e.command,n=e.editor;if(!n.multiSelect)return;if(!t.multiSelectAction){var r=t.exec(n,e.args||{});n.multiSelect.addRange(n.multiSelect.toOrientedRange()),n.multiSelect.mergeOverlappingRanges()}else t.multiSelectAction=="forEach"?r=n.forEachSelection(t,e.args):t.multiSelectAction=="forEachLine"?r=n.forEachSelection(t,e.args,!0):t.multiSelectAction=="single"?(n.exitMultiSelectMode(),r=t.exec(n,e.args||{})):r=t.multiSelectAction(n,e.args||{});return r},this.forEachSelection=function(e,t,n){if(this.inVirtualSelectionMode)return;var r=n&&n.keepOrder,i=n==1||n&&n.$byLines,o=this.session,u=this.selection,a=u.rangeList,f=(r?u:a).ranges,l;if(!f.length)return e.exec?e.exec(this,t||{}):e(this,t||{});var c=u._eventRegistry;u._eventRegistry={};var h=new s(o);this.inVirtualSelectionMode=!0;for(var p=f.length;p--;){if(i)while(p>0&&f[p].start.row==f[p-1].end.row)p--;h.fromOrientedRange(f[p]),h.index=p,this.selection=o.selection=h;var d=e.exec?e.exec(this,t||{}):e(this,t||{});!l&&d!==undefined&&(l=d),h.toOrientedRange(f[p])}h.detach(),this.selection=o.selection=u,this.inVirtualSelectionMode=!1,u._eventRegistry=c,u.mergeOverlappingRanges(),u.ranges[0]&&u.fromOrientedRange(u.ranges[0]);var v=this.renderer.$scrollAnimation;return this.onCursorChange(),this.onSelectionChange(),v&&v.from==v.to&&this.renderer.animateScrolling(v.from),l},this.exitMultiSelectMode=function(){if(!this.inMultiSelectMode||this.inVirtualSelectionMode)return;this.multiSelect.toSingleRange()},this.getSelectedText=function(){var e="";if(this.inMultiSelectMode&&!this.inVirtualSelectionMode){var t=this.multiSelect.rangeList.ranges,n=[];for(var r=0;r<t.length;r++)n.push(this.session.getTextRange(t[r]));var i=this.session.getDocument().getNewLineCharacter();e=n.join(i),e.length==(n.length-1)*i.length&&(e="")}else this.selection.isEmpty()||(e=this.session.getTextRange(this.getSelectionRange()));return e},this.$checkMultiselectChange=function(e,t){if(this.inMultiSelectMode&&!this.inVirtualSelectionMode){var n=this.multiSelect.ranges[0];if(this.multiSelect.isEmpty()&&t==this.multiSelect.anchor)return;var r=t==this.multiSelect.anchor?n.cursor==n.start?n.end:n.start:n.cursor;r.row!=t.row||this.session.$clipPositionToDocument(r.row,r.column).column!=t.column?this.multiSelect.toSingleRange(this.multiSelect.toOrientedRange()):this.multiSelect.mergeOverlappingRanges()}},this.findAll=function(e,t,n){t=t||{},t.needle=e||t.needle;if(t.needle==undefined){var r=this.selection.isEmpty()?this.selection.getWordRange():this.selection.getRange();t.needle=this.session.getTextRange(r)}this.$search.set(t);var i=this.$search.findAll(this.session);if(!i.length)return 0;var s=this.multiSelect;n||s.toSingleRange(i[0]);for(var o=i.length;o--;)s.addRange(i[o],!0);return r&&s.rangeList.rangeAtPoint(r.start)&&s.addRange(r,!0),i.length},this.selectMoreLines=function(e,t){var n=this.selection.toOrientedRange(),r=n.cursor==n.end,s=this.session.documentToScreenPosition(n.cursor);this.selection.$desiredColumn&&(s.column=this.selection.$desiredColumn);var o=this.session.screenToDocumentPosition(s.row+e,s.column);if(!n.isEmpty())var u=this.session.documentToScreenPosition(r?n.end:n.start),a=this.session.screenToDocumentPosition(u.row+e,u.column);else var a=o;if(r){var f=i.fromPoints(o,a);f.cursor=f.start}else{var f=i.fromPoints(a,o);f.cursor=f.end}f.desiredColumn=s.column;if(!this.selection.inMultiSelectMode)this.selection.addRange(n);else if(t)var l=n.cursor;this.selection.addRange(f),l&&this.selection.substractPoint(l)},this.transposeSelections=function(e){var t=this.session,n=t.multiSelect,r=n.ranges;for(var i=r.length;i--;){var s=r[i];if(s.isEmpty()){var o=t.getWordRange(s.start.row,s.start.column);s.start.row=o.start.row,s.start.column=o.start.column,s.end.row=o.end.row,s.end.column=o.end.column}}n.mergeOverlappingRanges();var u=[];for(var i=r.length;i--;){var s=r[i];u.unshift(t.getTextRange(s))}e<0?u.unshift(u.pop()):u.push(u.shift());for(var i=r.length;i--;){var s=r[i],o=s.clone();t.replace(s,u[i]),s.start.row=o.start.row,s.start.column=o.start.column}n.fromOrientedRange(n.ranges[0])},this.selectMore=function(e,t,n){var r=this.session,i=r.multiSelect,s=i.toOrientedRange();if(s.isEmpty()){s=r.getWordRange(s.start.row,s.start.column),s.cursor=e==-1?s.start:s.end,this.multiSelect.addRange(s);if(n)return}var o=r.getTextRange(s),u=h(r,o,e);u&&(u.cursor=e==-1?u.start:u.end,this.session.unfold(u),this.multiSelect.addRange(u),this.renderer.scrollCursorIntoView(null,.5)),t&&this.multiSelect.substractPoint(s.cursor)},this.alignCursors=function(){var e=this.session,t=e.multiSelect,n=t.ranges,r=-1,s=n.filter(function(e){if(e.cursor.row==r)return!0;r=e.cursor.row});if(!n.length||s.length==n.length-1){var o=this.selection.getRange(),u=o.start.row,f=o.end.row,l=u==f;if(l){var c=this.session.getLength(),h;do h=this.session.getLine(f);while(/[=:]/.test(h)&&++f<c);do h=this.session.getLine(u);while(/[=:]/.test(h)&&--u>0);u<0&&(u=0),f>=c&&(f=c-1)}var p=this.session.removeFullLines(u,f);p=this.$reAlignText(p,l),this.session.insert({row:u,column:0},p.join("\n")+"\n"),l||(o.start.column=0,o.end.column=p[p.length-1].length),this.selection.setRange(o)}else{s.forEach(function(e){t.substractPoint(e.cursor)});var d=0,v=Infinity,m=n.map(function(t){var n=t.cursor,r=e.getLine(n.row),i=r.substr(n.column).search(/\S/g);return i==-1&&(i=0),n.column>d&&(d=n.column),i<v&&(v=i),i});n.forEach(function(t,n){var r=t.cursor,s=d-r.column,o=m[n]-v;s>o?e.insert(r,a.stringRepeat(" ",s-o)):e.remove(new i(r.row,r.column,r.row,r.column-s+o)),t.start.column=t.end.column=d,t.start.row=t.end.row=r.row,t.cursor=t.end}),t.fromOrientedRange(n[0]),this.renderer.updateCursor(),this.renderer.updateBackMarkers()}},this.$reAlignText=function(e,t){function u(e){return a.stringRepeat(" ",e)}function f(e){return e[2]?u(i)+e[2]+u(s-e[2].length+o)+e[4].replace(/^([=:])\s+/,"$1 "):e[0]}function l(e){return e[2]?u(i+s-e[2].length)+e[2]+u(o)+e[4].replace(/^([=:])\s+/,"$1 "):e[0]}function c(e){return e[2]?u(i)+e[2]+u(o)+e[4].replace(/^([=:])\s+/,"$1 "):e[0]}var n=!0,r=!0,i,s,o;return e.map(function(e){var t=e.match(/(\s*)(.*?)(\s*)([=:].*)/);return t?i==null?(i=t[1].length,s=t[2].length,o=t[3].length,t):(i+s+o!=t[1].length+t[2].length+t[3].length&&(r=!1),i!=t[1].length&&(n=!1),i>t[1].length&&(i=t[1].length),s<t[2].length&&(s=t[2].length),o>t[3].length&&(o=t[3].length),t):[e]}).map(t?f:n?r?l:f:c)}}).call(d.prototype),t.onSessionChange=function(e){var t=e.session;t&&!t.multiSelect&&(t.$selectionMarkers=[],t.selection.$initRangeList(),t.multiSelect=t.selection),this.multiSelect=t&&t.multiSelect;var n=e.oldSession;n&&(n.multiSelect.off("addRange",this.$onAddRange),n.multiSelect.off("removeRange",this.$onRemoveRange),n.multiSelect.off("multiSelect",this.$onMultiSelect),n.multiSelect.off("singleSelect",this.$onSingleSelect),n.multiSelect.lead.off("change",this.$checkMultiselectChange),n.multiSelect.anchor.off("change",this.$checkMultiselectChange)),t&&(t.multiSelect.on("addRange",this.$onAddRange),t.multiSelect.on("removeRange",this.$onRemoveRange),t.multiSelect.on("multiSelect",this.$onMultiSelect),t.multiSelect.on("singleSelect",this.$onSingleSelect),t.multiSelect.lead.on("change",this.$checkMultiselectChange),t.multiSelect.anchor.on("change",this.$checkMultiselectChange)),t&&this.inMultiSelectMode!=t.selection.inMultiSelectMode&&(t.selection.inMultiSelectMode?this.$onMultiSelect():this.$onSingleSelect())},t.MultiSelect=m,e("./config").defineOptions(d.prototype,"editor",{enableMultiselect:{set:function(e){m(this),e?(this.on("changeSession",this.$multiselectOnSessionChange),this.on("mousedown",o)):(this.off("changeSession",this.$multiselectOnSessionChange),this.off("mousedown",o))},value:!0},enableBlockSelect:{set:function(e){this.$blockSelectEnabled=e},value:!0}})}),ace.define("ace/mode/folding/fold_mode",["require","exports","module","ace/range"],function(e,t,n){"use strict";var r=e("../../range").Range,i=t.FoldMode=function(){};(function(){this.foldingStartMarker=null,this.foldingStopMarker=null,this.getFoldWidget=function(e,t,n){var r=e.getLine(n);return this.foldingStartMarker.test(r)?"start":t=="markbeginend"&&this.foldingStopMarker&&this.foldingStopMarker.test(r)?"end":""},this.getFoldWidgetRange=function(e,t,n){return null},this.indentationBlock=function(e,t,n){var i=/\S/,s=e.getLine(t),o=s.search(i);if(o==-1)return;var u=n||s.length,a=e.getLength(),f=t,l=t;while(++t<a){var c=e.getLine(t).search(i);if(c==-1)continue;if(c<=o){var h=e.getTokenAt(t,0);if(!h||h.type!=="string")break}l=t}if(l>f){var p=e.getLine(l).length;return new r(f,u,l,p)}},this.openingBracketBlock=function(e,t,n,i,s){var o={row:n,column:i+1},u=e.$findClosingBracket(t,o,s);if(!u)return;var a=e.foldWidgets[u.row];return a==null&&(a=e.getFoldWidget(u.row)),a=="start"&&u.row>o.row&&(u.row--,u.column=e.getLine(u.row).length),r.fromPoints(o,u)},this.closingBracketBlock=function(e,t,n,i,s){var o={row:n,column:i},u=e.$findOpeningBracket(t,o);if(!u)return;return u.column++,o.column--,r.fromPoints(u,o)}}).call(i.prototype)}),ace.define("ace/theme/textmate",["require","exports","module","ace/lib/dom"],function(e,t,n){"use strict";t.isDark=!1,t.cssClass="ace-tm",t.cssText='.ace-tm .ace_gutter {background: #f0f0f0;color: #333;}.ace-tm .ace_print-margin {width: 1px;background: #e8e8e8;}.ace-tm .ace_fold {background-color: #6B72E6;}.ace-tm {background-color: #FFFFFF;color: black;}.ace-tm .ace_cursor {color: black;}.ace-tm .ace_invisible {color: rgb(191, 191, 191);}.ace-tm .ace_storage,.ace-tm .ace_keyword {color: blue;}.ace-tm .ace_constant {color: rgb(197, 6, 11);}.ace-tm .ace_constant.ace_buildin {color: rgb(88, 72, 246);}.ace-tm .ace_constant.ace_language {color: rgb(88, 92, 246);}.ace-tm .ace_constant.ace_library {color: rgb(6, 150, 14);}.ace-tm .ace_invalid {background-color: rgba(255, 0, 0, 0.1);color: red;}.ace-tm .ace_support.ace_function {color: rgb(60, 76, 114);}.ace-tm .ace_support.ace_constant {color: rgb(6, 150, 14);}.ace-tm .ace_support.ace_type,.ace-tm .ace_support.ace_class {color: rgb(109, 121, 222);}.ace-tm .ace_keyword.ace_operator {color: rgb(104, 118, 135);}.ace-tm .ace_string {color: rgb(3, 106, 7);}.ace-tm .ace_comment {color: rgb(76, 136, 107);}.ace-tm .ace_comment.ace_doc {color: rgb(0, 102, 255);}.ace-tm .ace_comment.ace_doc.ace_tag {color: rgb(128, 159, 191);}.ace-tm .ace_constant.ace_numeric {color: rgb(0, 0, 205);}.ace-tm .ace_variable {color: rgb(49, 132, 149);}.ace-tm .ace_xml-pe {color: rgb(104, 104, 91);}.ace-tm .ace_entity.ace_name.ace_function {color: #0000A2;}.ace-tm .ace_heading {color: rgb(12, 7, 255);}.ace-tm .ace_list {color:rgb(185, 6, 144);}.ace-tm .ace_meta.ace_tag {color:rgb(0, 22, 142);}.ace-tm .ace_string.ace_regex {color: rgb(255, 0, 0)}.ace-tm .ace_marker-layer .ace_selection {background: rgb(181, 213, 255);}.ace-tm.ace_multiselect .ace_selection.ace_start {box-shadow: 0 0 3px 0px white;}.ace-tm .ace_marker-layer .ace_step {background: rgb(252, 255, 0);}.ace-tm .ace_marker-layer .ace_stack {background: rgb(164, 229, 101);}.ace-tm .ace_marker-layer .ace_bracket {margin: -1px 0 0 -1px;border: 1px solid rgb(192, 192, 192);}.ace-tm .ace_marker-layer .ace_active-line {background: rgba(0, 0, 0, 0.07);}.ace-tm .ace_gutter-active-line {background-color : #dcdcdc;}.ace-tm .ace_marker-layer .ace_selected-word {background: rgb(250, 250, 255);border: 1px solid rgb(200, 200, 250);}.ace-tm .ace_indent-guide {background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAE0lEQVQImWP4////f4bLly//BwAmVgd1/w11/gAAAABJRU5ErkJggg==") right repeat-y;}',t.$id="ace/theme/textmate";var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)}),ace.define("ace/line_widgets",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/range"],function(e,t,n){"use strict";function o(e){this.session=e,this.session.widgetManager=this,this.session.getRowLength=this.getRowLength,this.session.$getWidgetScreenLength=this.$getWidgetScreenLength,this.updateOnChange=this.updateOnChange.bind(this),this.renderWidgets=this.renderWidgets.bind(this),this.measureWidgets=this.measureWidgets.bind(this),this.session._changedWidgets=[],this.$onChangeEditor=this.$onChangeEditor.bind(this),this.session.on("change",this.updateOnChange),this.session.on("changeFold",this.updateOnFold),this.session.on("changeEditor",this.$onChangeEditor)}var r=e("./lib/oop"),i=e("./lib/dom"),s=e("./range").Range;(function(){this.getRowLength=function(e){var t;return this.lineWidgets?t=this.lineWidgets[e]&&this.lineWidgets[e].rowCount||0:t=0,!this.$useWrapMode||!this.$wrapData[e]?1+t:this.$wrapData[e].length+1+t},this.$getWidgetScreenLength=function(){var e=0;return this.lineWidgets.forEach(function(t){t&&t.rowCount&&!t.hidden&&(e+=t.rowCount)}),e},this.$onChangeEditor=function(e){this.attach(e.editor)},this.attach=function(e){e&&e.widgetManager&&e.widgetManager!=this&&e.widgetManager.detach();if(this.editor==e)return;this.detach(),this.editor=e,e&&(e.widgetManager=this,e.renderer.on("beforeRender",this.measureWidgets),e.renderer.on("afterRender",this.renderWidgets))},this.detach=function(e){var t=this.editor;if(!t)return;this.editor=null,t.widgetManager=null,t.renderer.off("beforeRender",this.measureWidgets),t.renderer.off("afterRender",this.renderWidgets);var n=this.session.lineWidgets;n&&n.forEach(function(e){e&&e.el&&e.el.parentNode&&(e._inDocument=!1,e.el.parentNode.removeChild(e.el))})},this.updateOnFold=function(e,t){var n=t.lineWidgets;if(!n||!e.action)return;var r=e.data,i=r.start.row,s=r.end.row,o=e.action=="add";for(var u=i+1;u<s;u++)n[u]&&(n[u].hidden=o);n[s]&&(o?n[i]?n[s].hidden=o:n[i]=n[s]:(n[i]==n[s]&&(n[i]=undefined),n[s].hidden=o))},this.updateOnChange=function(e){var t=this.session.lineWidgets;if(!t)return;var n=e.start.row,r=e.end.row-n;if(r!==0)if(e.action=="remove"){var i=t.splice(n+1,r);i.forEach(function(e){e&&this.removeLineWidget(e)},this),this.$updateRows()}else{var s=new Array(r);s.unshift(n,0),t.splice.apply(t,s),this.$updateRows()}},this.$updateRows=function(){var e=this.session.lineWidgets;if(!e)return;var t=!0;e.forEach(function(e,n){if(e){t=!1,e.row=n;while(e.$oldWidget)e.$oldWidget.row=n,e=e.$oldWidget}}),t&&(this.session.lineWidgets=null)},this.addLineWidget=function(e){this.session.lineWidgets||(this.session.lineWidgets=new Array(this.session.getLength()));var t=this.session.lineWidgets[e.row];t&&(e.$oldWidget=t,t.el&&t.el.parentNode&&(t.el.parentNode.removeChild(t.el),t._inDocument=!1)),this.session.lineWidgets[e.row]=e,e.session=this.session;var n=this.editor.renderer;e.html&&!e.el&&(e.el=i.createElement("div"),e.el.innerHTML=e.html),e.el&&(i.addCssClass(e.el,"ace_lineWidgetContainer"),e.el.style.position="absolute",e.el.style.zIndex=5,n.container.appendChild(e.el),e._inDocument=!0),e.coverGutter||(e.el.style.zIndex=3),e.pixelHeight==null&&(e.pixelHeight=e.el.offsetHeight),e.rowCount==null&&(e.rowCount=e.pixelHeight/n.layerConfig.lineHeight);var r=this.session.getFoldAt(e.row,0);e.$fold=r;if(r){var s=this.session.lineWidgets;e.row==r.end.row&&!s[r.start.row]?s[r.start.row]=e:e.hidden=!0}return this.session._emit("changeFold",{data:{start:{row:e.row}}}),this.$updateRows(),this.renderWidgets(null,n),this.onWidgetChanged(e),e},this.removeLineWidget=function(e){e._inDocument=!1,e.session=null,e.el&&e.el.parentNode&&e.el.parentNode.removeChild(e.el);if(e.editor&&e.editor.destroy)try{e.editor.destroy()}catch(t){}if(this.session.lineWidgets){var n=this.session.lineWidgets[e.row];if(n==e)this.session.lineWidgets[e.row]=e.$oldWidget,e.$oldWidget&&this.onWidgetChanged(e.$oldWidget);else while(n){if(n.$oldWidget==e){n.$oldWidget=e.$oldWidget;break}n=n.$oldWidget}}this.session._emit("changeFold",{data:{start:{row:e.row}}}),this.$updateRows()},this.getWidgetsAtRow=function(e){var t=this.session.lineWidgets,n=t&&t[e],r=[];while(n)r.push(n),n=n.$oldWidget;return r},this.onWidgetChanged=function(e){this.session._changedWidgets.push(e),this.editor&&this.editor.renderer.updateFull()},this.measureWidgets=function(e,t){var n=this.session._changedWidgets,r=t.layerConfig;if(!n||!n.length)return;var i=Infinity;for(var s=0;s<n.length;s++){var o=n[s];if(!o||!o.el)continue;if(o.session!=this.session)continue;if(!o._inDocument){if(this.session.lineWidgets[o.row]!=o)continue;o._inDocument=!0,t.container.appendChild(o.el)}o.h=o.el.offsetHeight,o.fixedWidth||(o.w=o.el.offsetWidth,o.screenWidth=Math.ceil(o.w/r.characterWidth));var u=o.h/r.lineHeight;o.coverLine&&(u-=this.session.getRowLineCount(o.row),u<0&&(u=0)),o.rowCount!=u&&(o.rowCount=u,o.row<i&&(i=o.row))}i!=Infinity&&(this.session._emit("changeFold",{data:{start:{row:i}}}),this.session.lineWidgetWidth=null),this.session._changedWidgets=[]},this.renderWidgets=function(e,t){var n=t.layerConfig,r=this.session.lineWidgets;if(!r)return;var i=Math.min(this.firstRow,n.firstRow),s=Math.max(this.lastRow,n.lastRow,r.length);while(i>0&&!r[i])i--;this.firstRow=n.firstRow,this.lastRow=n.lastRow,t.$cursorLayer.config=n;for(var o=i;o<=s;o++){var u=r[o];if(!u||!u.el)continue;if(u.hidden){u.el.style.top=-100-(u.pixelHeight||0)+"px";continue}u._inDocument||(u._inDocument=!0,t.container.appendChild(u.el));var a=t.$cursorLayer.getPixelPosition({row:o,column:0},!0).top;u.coverLine||(a+=n.lineHeight*this.session.getRowLineCount(u.row)),u.el.style.top=a-n.offset+"px";var f=u.coverGutter?0:t.gutterWidth;u.fixedWidth||(f-=t.scrollLeft),u.el.style.left=f+"px",u.fullWidth&&u.screenWidth&&(u.el.style.minWidth=n.width+2*n.padding+"px"),u.fixedWidth?u.el.style.right=t.scrollBar.getWidth()+"px":u.el.style.right=""}}}).call(o.prototype),t.LineWidgets=o}),ace.define("ace/ext/error_marker",["require","exports","module","ace/line_widgets","ace/lib/dom","ace/range"],function(e,t,n){"use strict";function o(e,t,n){var r=0,i=e.length-1;while(r<=i){var s=r+i>>1,o=n(t,e[s]);if(o>0)r=s+1;else{if(!(o<0))return s;i=s-1}}return-(r+1)}function u(e,t,n){var r=e.getAnnotations().sort(s.comparePoints);if(!r.length)return;var i=o(r,{row:t,column:-1},s.comparePoints);i<0&&(i=-i-1),i>=r.length?i=n>0?0:r.length-1:i===0&&n<0&&(i=r.length-1);var u=r[i];if(!u||!n)return;if(u.row===t){do u=r[i+=n];while(u&&u.row===t);if(!u)return r.slice()}var a=[];t=u.row;do a[n<0?"unshift":"push"](u),u=r[i+=n];while(u&&u.row==t);return a.length&&a}var r=e("../line_widgets").LineWidgets,i=e("../lib/dom"),s=e("../range").Range;t.showErrorMarker=function(e,t){var n=e.session;n.widgetManager||(n.widgetManager=new r(n),n.widgetManager.attach(e));var s=e.getCursorPosition(),o=s.row,a=n.widgetManager.getWidgetsAtRow(o).filter(function(e){return e.type=="errorMarker"})[0];a?a.destroy():o-=t;var f=u(n,o,t),l;if(f){var c=f[0];s.column=(c.pos&&typeof c.column!="number"?c.pos.sc:c.column)||0,s.row=c.row,l=e.renderer.$gutterLayer.$annotations[s.row]}else{if(a)return;l={text:["Looks good!"],className:"ace_ok"}}e.session.unfold(s.row),e.selection.moveToPosition(s);var h={row:s.row,fixedWidth:!0,coverGutter:!0,el:i.createElement("div"),type:"errorMarker"},p=h.el.appendChild(i.createElement("div")),d=h.el.appendChild(i.createElement("div"));d.className="error_widget_arrow "+l.className;var v=e.renderer.$cursorLayer.getPixelPosition(s).left;d.style.left=v+e.renderer.gutterWidth-5+"px",h.el.className="error_widget_wrapper",p.className="error_widget "+l.className,p.innerHTML=l.text.join("<br>"),p.appendChild(i.createElement("div"));var m=function(e,t,n){if(t===0&&(n==="esc"||n==="return"))return h.destroy(),{command:"null"}};h.destroy=function(){if(e.$mouseHandler.isMousePressed)return;e.keyBinding.removeKeyboardHandler(m),n.widgetManager.removeLineWidget(h),e.off("changeSelection",h.destroy),e.off("changeSession",h.destroy),e.off("mouseup",h.destroy),e.off("change",h.destroy)},e.keyBinding.addKeyboardHandler(m),e.on("changeSelection",h.destroy),e.on("changeSession",h.destroy),e.on("mouseup",h.destroy),e.on("change",h.destroy),e.session.widgetManager.addLineWidget(h),h.el.onmousedown=e.focus.bind(e),e.renderer.scrollCursorIntoView(null,.5,{bottom:h.el.offsetHeight})},i.importCssString("    .error_widget_wrapper {        background: inherit;        color: inherit;        border:none    }    .error_widget {        border-top: solid 2px;        border-bottom: solid 2px;        margin: 5px 0;        padding: 10px 40px;        white-space: pre-wrap;    }    .error_widget.ace_error, .error_widget_arrow.ace_error{        border-color: #ff5a5a    }    .error_widget.ace_warning, .error_widget_arrow.ace_warning{        border-color: #F1D817    }    .error_widget.ace_info, .error_widget_arrow.ace_info{        border-color: #5a5a5a    }    .error_widget.ace_ok, .error_widget_arrow.ace_ok{        border-color: #5aaa5a    }    .error_widget_arrow {        position: absolute;        border: solid 5px;        border-top-color: transparent!important;        border-right-color: transparent!important;        border-left-color: transparent!important;        top: -5px;    }","")}),ace.define("ace/ace",["require","exports","module","ace/lib/fixoldbrowsers","ace/lib/dom","ace/lib/event","ace/range","ace/editor","ace/edit_session","ace/undomanager","ace/virtual_renderer","ace/worker/worker_client","ace/keyboard/hash_handler","ace/placeholder","ace/multi_select","ace/mode/folding/fold_mode","ace/theme/textmate","ace/ext/error_marker","ace/config"],function(e,t,n){"use strict";e("./lib/fixoldbrowsers");var r=e("./lib/dom"),i=e("./lib/event"),s=e("./range").Range,o=e("./editor").Editor,u=e("./edit_session").EditSession,a=e("./undomanager").UndoManager,f=e("./virtual_renderer").VirtualRenderer;e("./worker/worker_client"),e("./keyboard/hash_handler"),e("./placeholder"),e("./multi_select"),e("./mode/folding/fold_mode"),e("./theme/textmate"),e("./ext/error_marker"),t.config=e("./config"),t.require=e,typeof define=="function"&&(t.define=define),t.edit=function(e,n){if(typeof e=="string"){var s=e;e=document.getElementById(s);if(!e)throw new Error("ace.edit can't find div #"+s)}if(e&&e.env&&e.env.editor instanceof o)return e.env.editor;var u="";if(e&&/input|textarea/i.test(e.tagName)){var a=e;u=a.value,e=r.createElement("pre"),a.parentNode.replaceChild(e,a)}else e&&(u=e.textContent,e.innerHTML="");var l=t.createEditSession(u),c=new o(new f(e),l,n),h={document:l,editor:c,onResize:c.resize.bind(c,null)};return a&&(h.textarea=a),i.addListener(window,"resize",h.onResize),c.on("destroy",function(){i.removeListener(window,"resize",h.onResize),h.editor.container.env=null}),c.container.env=c.env=h,c},t.createEditSession=function(e,t){var n=new u(e,t);return n.setUndoManager(new a),n},t.Range=s,t.Editor=o,t.EditSession=u,t.UndoManager=a,t.VirtualRenderer=f,t.version=t.config.version});            (function() {
                ace.require(["ace/ace"], function(a) {
                    if (a) {
                        a.config.init(true);
                        a.define = ace.define;
                    }
                    if (!window.ace)
                        window.ace = a;
                    for (var key in a) if (a.hasOwnProperty(key))
                        window.ace[key] = a[key];
                    window.ace["default"] = window.ace;
                    if (typeof module == "object" && typeof exports == "object" && module) {
                        module.exports = window.ace;
                    }
                });
            })();",
{"status":false}
],

[
"ace.mode-javascript.js_2018-11-21",
"// https://github.com/ajaxorg/ace-builds/blob/master/src-min-noconflict/mode-javascript.js
ace.define("ace/mode/doc_comment_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("./text_highlight_rules").TextHighlightRules,s=function(){this.$rules={start:[{token:"comment.doc.tag",regex:"@[\\w\\d_]+"},s.getTagRule(),{defaultToken:"comment.doc",caseInsensitive:!0}]}};r.inherits(s,i),s.getTagRule=function(e){return{token:"comment.doc.tag.storage.type",regex:"\\b(?:TODO|FIXME|XXX|HACK)\\b"}},s.getStartRule=function(e){return{token:"comment.doc",regex:"\\/\\*(?=\\*)",next:e}},s.getEndRule=function(e){return{token:"comment.doc",regex:"\\*\\/",next:e}},t.DocCommentHighlightRules=s}),ace.define("ace/mode/javascript_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/doc_comment_highlight_rules","ace/mode/text_highlight_rules"],function(e,t,n){"use strict";function a(){var e=o.replace("\\d","\\d\\-"),t={onMatch:function(e,t,n){var r=e.charAt(1)=="/"?2:1;if(r==1)t!=this.nextState?n.unshift(this.next,this.nextState,0):n.unshift(this.next),n[2]++;else if(r==2&&t==this.nextState){n[1]--;if(!n[1]||n[1]<0)n.shift(),n.shift()}return[{type:"meta.tag.punctuation."+(r==1?"":"end-")+"tag-open.xml",value:e.slice(0,r)},{type:"meta.tag.tag-name.xml",value:e.substr(r)}]},regex:"</?"+e+"",next:"jsxAttributes",nextState:"jsx"};this.$rules.start.unshift(t);var n={regex:"{",token:"paren.quasi.start",push:"start"};this.$rules.jsx=[n,t,{include:"reference"},{defaultToken:"string"}],this.$rules.jsxAttributes=[{token:"meta.tag.punctuation.tag-close.xml",regex:"/?>",onMatch:function(e,t,n){return t==n[0]&&n.shift(),e.length==2&&(n[0]==this.nextState&&n[1]--,(!n[1]||n[1]<0)&&n.splice(0,2)),this.next=n[0]||"start",[{type:this.token,value:e}]},nextState:"jsx"},n,f("jsxAttributes"),{token:"entity.other.attribute-name.xml",regex:e},{token:"keyword.operator.attribute-equals.xml",regex:"="},{token:"text.tag-whitespace.xml",regex:"\\s+"},{token:"string.attribute-value.xml",regex:"'",stateName:"jsx_attr_q",push:[{token:"string.attribute-value.xml",regex:"'",next:"pop"},{include:"reference"},{defaultToken:"string.attribute-value.xml"}]},{token:"string.attribute-value.xml",regex:'"',stateName:"jsx_attr_qq",push:[{token:"string.attribute-value.xml",regex:'"',next:"pop"},{include:"reference"},{defaultToken:"string.attribute-value.xml"}]},t],this.$rules.reference=[{token:"constant.language.escape.reference.xml",regex:"(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)"}]}function f(e){return[{token:"comment",regex:/\/\*/,next:[i.getTagRule(),{token:"comment",regex:"\\*\\/",next:e||"pop"},{defaultToken:"comment",caseInsensitive:!0}]},{token:"comment",regex:"\\/\\/",next:[i.getTagRule(),{token:"comment",regex:"$|^",next:e||"pop"},{defaultToken:"comment",caseInsensitive:!0}]}]}var r=e("../lib/oop"),i=e("./doc_comment_highlight_rules").DocCommentHighlightRules,s=e("./text_highlight_rules").TextHighlightRules,o="[a-zA-Z\\$_\u00a1-\uffff][a-zA-Z\\d\\$_\u00a1-\uffff]*",u=function(e){var t=this.createKeywordMapper({"variable.language":"Array|Boolean|Date|Function|Iterator|Number|Object|RegExp|String|Proxy|Namespace|QName|XML|XMLList|ArrayBuffer|Float32Array|Float64Array|Int16Array|Int32Array|Int8Array|Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray|Error|EvalError|InternalError|RangeError|ReferenceError|StopIteration|SyntaxError|TypeError|URIError|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|isNaN|parseFloat|parseInt|JSON|Math|this|arguments|prototype|window|document",keyword:"const|yield|import|get|set|async|await|break|case|catch|continue|default|delete|do|else|finally|for|function|if|in|of|instanceof|new|return|switch|throw|try|typeof|let|var|while|with|debugger|__parent__|__count__|escape|unescape|with|__proto__|class|enum|extends|super|export|implements|private|public|interface|package|protected|static","storage.type":"const|let|var|function","constant.language":"null|Infinity|NaN|undefined","support.function":"alert","constant.language.boolean":"true|false"},"identifier"),n="case|do|else|finally|in|instanceof|return|throw|try|typeof|yield|void",r="\\\\(?:x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|u{[0-9a-fA-F]{1,6}}|[0-2][0-7]{0,2}|3[0-7][0-7]?|[4-7][0-7]?|.)";this.$rules={no_regex:[i.getStartRule("doc-start"),f("no_regex"),{token:"string",regex:"'(?=.)",next:"qstring"},{token:"string",regex:'"(?=.)',next:"qqstring"},{token:"constant.numeric",regex:/0(?:[xX][0-9a-fA-F]+|[oO][0-7]+|[bB][01]+)\b/},{token:"constant.numeric",regex:/(?:\d\d*(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+\b)?/},{token:["storage.type","punctuation.operator","support.function","punctuation.operator","entity.name.function","text","keyword.operator"],regex:"("+o+")(\\.)(prototype)(\\.)("+o+")(\\s*)(=)",next:"function_arguments"},{token:["storage.type","punctuation.operator","entity.name.function","text","keyword.operator","text","storage.type","text","paren.lparen"],regex:"("+o+")(\\.)("+o+")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",next:"function_arguments"},{token:["entity.name.function","text","keyword.operator","text","storage.type","text","paren.lparen"],regex:"("+o+")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",next:"function_arguments"},{token:["storage.type","punctuation.operator","entity.name.function","text","keyword.operator","text","storage.type","text","entity.name.function","text","paren.lparen"],regex:"("+o+")(\\.)("+o+")(\\s*)(=)(\\s*)(function)(\\s+)(\\w+)(\\s*)(\\()",next:"function_arguments"},{token:["storage.type","text","entity.name.function","text","paren.lparen"],regex:"(function)(\\s+)("+o+")(\\s*)(\\()",next:"function_arguments"},{token:["entity.name.function","text","punctuation.operator","text","storage.type","text","paren.lparen"],regex:"("+o+")(\\s*)(:)(\\s*)(function)(\\s*)(\\()",next:"function_arguments"},{token:["text","text","storage.type","text","paren.lparen"],regex:"(:)(\\s*)(function)(\\s*)(\\()",next:"function_arguments"},{token:"keyword",regex:"from(?=\\s*('|\"))"},{token:"keyword",regex:"(?:"+n+")\\b",next:"start"},{token:["support.constant"],regex:/that\b/},{token:["storage.type","punctuation.operator","support.function.firebug"],regex:/(console)(\.)(warn|info|log|error|time|trace|timeEnd|assert)\b/},{token:t,regex:o},{token:"punctuation.operator",regex:/[.](?![.])/,next:"property"},{token:"storage.type",regex:/=>/,next:"start"},{token:"keyword.operator",regex:/--|\+\+|\.{3}|===|==|=|!=|!==|<+=?|>+=?|!|&&|\|\||\?:|[!$%&*+\-~\/^]=?/,next:"start"},{token:"punctuation.operator",regex:/[?:,;.]/,next:"start"},{token:"paren.lparen",regex:/[\[({]/,next:"start"},{token:"paren.rparen",regex:/[\])}]/},{token:"comment",regex:/^#!.*$/}],property:[{token:"text",regex:"\\s+"},{token:["storage.type","punctuation.operator","entity.name.function","text","keyword.operator","text","storage.type","text","entity.name.function","text","paren.lparen"],regex:"("+o+")(\\.)("+o+")(\\s*)(=)(\\s*)(function)(?:(\\s+)(\\w+))?(\\s*)(\\()",next:"function_arguments"},{token:"punctuation.operator",regex:/[.](?![.])/},{token:"support.function",regex:/(s(?:h(?:ift|ow(?:Mod(?:elessDialog|alDialog)|Help))|croll(?:X|By(?:Pages|Lines)?|Y|To)?|t(?:op|rike)|i(?:n|zeToContent|debar|gnText)|ort|u(?:p|b(?:str(?:ing)?)?)|pli(?:ce|t)|e(?:nd|t(?:Re(?:sizable|questHeader)|M(?:i(?:nutes|lliseconds)|onth)|Seconds|Ho(?:tKeys|urs)|Year|Cursor|Time(?:out)?|Interval|ZOptions|Date|UTC(?:M(?:i(?:nutes|lliseconds)|onth)|Seconds|Hours|Date|FullYear)|FullYear|Active)|arch)|qrt|lice|avePreferences|mall)|h(?:ome|andleEvent)|navigate|c(?:har(?:CodeAt|At)|o(?:s|n(?:cat|textual|firm)|mpile)|eil|lear(?:Timeout|Interval)?|a(?:ptureEvents|ll)|reate(?:StyleSheet|Popup|EventObject))|t(?:o(?:GMTString|S(?:tring|ource)|U(?:TCString|pperCase)|Lo(?:caleString|werCase))|est|a(?:n|int(?:Enabled)?))|i(?:s(?:NaN|Finite)|ndexOf|talics)|d(?:isableExternalCapture|ump|etachEvent)|u(?:n(?:shift|taint|escape|watch)|pdateCommands)|j(?:oin|avaEnabled)|p(?:o(?:p|w)|ush|lugins.refresh|a(?:ddings|rse(?:Int|Float)?)|r(?:int|ompt|eference))|e(?:scape|nableExternalCapture|val|lementFromPoint|x(?:p|ec(?:Script|Command)?))|valueOf|UTC|queryCommand(?:State|Indeterm|Enabled|Value)|f(?:i(?:nd|le(?:ModifiedDate|Size|CreatedDate|UpdatedDate)|xed)|o(?:nt(?:size|color)|rward)|loor|romCharCode)|watch|l(?:ink|o(?:ad|g)|astIndexOf)|a(?:sin|nchor|cos|t(?:tachEvent|ob|an(?:2)?)|pply|lert|b(?:s|ort))|r(?:ou(?:nd|teEvents)|e(?:size(?:By|To)|calc|turnValue|place|verse|l(?:oad|ease(?:Capture|Events)))|andom)|g(?:o|et(?:ResponseHeader|M(?:i(?:nutes|lliseconds)|onth)|Se(?:conds|lection)|Hours|Year|Time(?:zoneOffset)?|Da(?:y|te)|UTC(?:M(?:i(?:nutes|lliseconds)|onth)|Seconds|Hours|Da(?:y|te)|FullYear)|FullYear|A(?:ttention|llResponseHeaders)))|m(?:in|ove(?:B(?:y|elow)|To(?:Absolute)?|Above)|ergeAttributes|a(?:tch|rgins|x))|b(?:toa|ig|o(?:ld|rderWidths)|link|ack))\b(?=\()/},{token:"support.function.dom",regex:/(s(?:ub(?:stringData|mit)|plitText|e(?:t(?:NamedItem|Attribute(?:Node)?)|lect))|has(?:ChildNodes|Feature)|namedItem|c(?:l(?:ick|o(?:se|neNode))|reate(?:C(?:omment|DATASection|aption)|T(?:Head|extNode|Foot)|DocumentFragment|ProcessingInstruction|E(?:ntityReference|lement)|Attribute))|tabIndex|i(?:nsert(?:Row|Before|Cell|Data)|tem)|open|delete(?:Row|C(?:ell|aption)|T(?:Head|Foot)|Data)|focus|write(?:ln)?|a(?:dd|ppend(?:Child|Data))|re(?:set|place(?:Child|Data)|move(?:NamedItem|Child|Attribute(?:Node)?)?)|get(?:NamedItem|Element(?:sBy(?:Name|TagName|ClassName)|ById)|Attribute(?:Node)?)|blur)\b(?=\()/},{token:"support.constant",regex:/(s(?:ystemLanguage|cr(?:ipts|ollbars|een(?:X|Y|Top|Left))|t(?:yle(?:Sheets)?|atus(?:Text|bar)?)|ibling(?:Below|Above)|ource|uffixes|e(?:curity(?:Policy)?|l(?:ection|f)))|h(?:istory|ost(?:name)?|as(?:h|Focus))|y|X(?:MLDocument|SLDocument)|n(?:ext|ame(?:space(?:s|URI)|Prop))|M(?:IN_VALUE|AX_VALUE)|c(?:haracterSet|o(?:n(?:structor|trollers)|okieEnabled|lorDepth|mp(?:onents|lete))|urrent|puClass|l(?:i(?:p(?:boardData)?|entInformation)|osed|asses)|alle(?:e|r)|rypto)|t(?:o(?:olbar|p)|ext(?:Transform|Indent|Decoration|Align)|ags)|SQRT(?:1_2|2)|i(?:n(?:ner(?:Height|Width)|put)|ds|gnoreCase)|zIndex|o(?:scpu|n(?:readystatechange|Line)|uter(?:Height|Width)|p(?:sProfile|ener)|ffscreenBuffering)|NEGATIVE_INFINITY|d(?:i(?:splay|alog(?:Height|Top|Width|Left|Arguments)|rectories)|e(?:scription|fault(?:Status|Ch(?:ecked|arset)|View)))|u(?:ser(?:Profile|Language|Agent)|n(?:iqueID|defined)|pdateInterval)|_content|p(?:ixelDepth|ort|ersonalbar|kcs11|l(?:ugins|atform)|a(?:thname|dding(?:Right|Bottom|Top|Left)|rent(?:Window|Layer)?|ge(?:X(?:Offset)?|Y(?:Offset)?))|r(?:o(?:to(?:col|type)|duct(?:Sub)?|mpter)|e(?:vious|fix)))|e(?:n(?:coding|abledPlugin)|x(?:ternal|pando)|mbeds)|v(?:isibility|endor(?:Sub)?|Linkcolor)|URLUnencoded|P(?:I|OSITIVE_INFINITY)|f(?:ilename|o(?:nt(?:Size|Family|Weight)|rmName)|rame(?:s|Element)|gColor)|E|whiteSpace|l(?:i(?:stStyleType|n(?:eHeight|kColor))|o(?:ca(?:tion(?:bar)?|lName)|wsrc)|e(?:ngth|ft(?:Context)?)|a(?:st(?:M(?:odified|atch)|Index|Paren)|yer(?:s|X)|nguage))|a(?:pp(?:MinorVersion|Name|Co(?:deName|re)|Version)|vail(?:Height|Top|Width|Left)|ll|r(?:ity|guments)|Linkcolor|bove)|r(?:ight(?:Context)?|e(?:sponse(?:XML|Text)|adyState))|global|x|m(?:imeTypes|ultiline|enubar|argin(?:Right|Bottom|Top|Left))|L(?:N(?:10|2)|OG(?:10E|2E))|b(?:o(?:ttom|rder(?:Width|RightWidth|BottomWidth|Style|Color|TopWidth|LeftWidth))|ufferDepth|elow|ackground(?:Color|Image)))\b/},{token:"identifier",regex:o},{regex:"",token:"empty",next:"no_regex"}],start:[i.getStartRule("doc-start"),f("start"),{token:"string.regexp",regex:"\\/",next:"regex"},{token:"text",regex:"\\s+|^$",next:"start"},{token:"empty",regex:"",next:"no_regex"}],regex:[{token:"regexp.keyword.operator",regex:"\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"},{token:"string.regexp",regex:"/[sxngimy]*",next:"no_regex"},{token:"invalid",regex:/\{\d+\b,?\d*\}[+*]|[+*$^?][+*]|[$^][?]|\?{3,}/},{token:"constant.language.escape",regex:/\(\?[:=!]|\)|\{\d+\b,?\d*\}|[+*]\?|[()$^+*?.]/},{token:"constant.language.delimiter",regex:/\|/},{token:"constant.language.escape",regex:/\[\^?/,next:"regex_character_class"},{token:"empty",regex:"$",next:"no_regex"},{defaultToken:"string.regexp"}],regex_character_class:[{token:"regexp.charclass.keyword.operator",regex:"\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"},{token:"constant.language.escape",regex:"]",next:"regex"},{token:"constant.language.escape",regex:"-"},{token:"empty",regex:"$",next:"no_regex"},{defaultToken:"string.regexp.charachterclass"}],function_arguments:[{token:"variable.parameter",regex:o},{token:"punctuation.operator",regex:"[, ]+"},{token:"punctuation.operator",regex:"$"},{token:"empty",regex:"",next:"no_regex"}],qqstring:[{token:"constant.language.escape",regex:r},{token:"string",regex:"\\\\$",consumeLineEnd:!0},{token:"string",regex:'"|$',next:"no_regex"},{defaultToken:"string"}],qstring:[{token:"constant.language.escape",regex:r},{token:"string",regex:"\\\\$",consumeLineEnd:!0},{token:"string",regex:"'|$",next:"no_regex"},{defaultToken:"string"}]};if(!e||!e.noES6)this.$rules.no_regex.unshift({regex:"[{}]",onMatch:function(e,t,n){this.next=e=="{"?this.nextState:"";if(e=="{"&&n.length)n.unshift("start",t);else if(e=="}"&&n.length){n.shift(),this.next=n.shift();if(this.next.indexOf("string")!=-1||this.next.indexOf("jsx")!=-1)return"paren.quasi.end"}return e=="{"?"paren.lparen":"paren.rparen"},nextState:"start"},{token:"string.quasi.start",regex:/`/,push:[{token:"constant.language.escape",regex:r},{token:"paren.quasi.start",regex:/\${/,push:"start"},{token:"string.quasi.end",regex:/`/,next:"pop"},{defaultToken:"string.quasi"}]}),(!e||e.jsx!=0)&&a.call(this);this.embedRules(i,"doc-",[i.getEndRule("no_regex")]),this.normalizeRules()};r.inherits(u,s),t.JavaScriptHighlightRules=u}),ace.define("ace/mode/matching_brace_outdent",["require","exports","module","ace/range"],function(e,t,n){"use strict";var r=e("../range").Range,i=function(){};(function(){this.checkOutdent=function(e,t){return/^\s+$/.test(e)?/^\s*\}/.test(t):!1},this.autoOutdent=function(e,t){var n=e.getLine(t),i=n.match(/^(\s*\})/);if(!i)return 0;var s=i[1].length,o=e.findMatchingBracket({row:t,column:s});if(!o||o.row==t)return 0;var u=this.$getIndent(e.getLine(o.row));e.replace(new r(t,0,t,s-1),u)},this.$getIndent=function(e){return e.match(/^\s*/)[0]}}).call(i.prototype),t.MatchingBraceOutdent=i}),ace.define("ace/mode/folding/cstyle",["require","exports","module","ace/lib/oop","ace/range","ace/mode/folding/fold_mode"],function(e,t,n){"use strict";var r=e("../../lib/oop"),i=e("../../range").Range,s=e("./fold_mode").FoldMode,o=t.FoldMode=function(e){e&&(this.foldingStartMarker=new RegExp(this.foldingStartMarker.source.replace(/\|[^|]*?$/,"|"+e.start)),this.foldingStopMarker=new RegExp(this.foldingStopMarker.source.replace(/\|[^|]*?$/,"|"+e.end)))};r.inherits(o,s),function(){this.foldingStartMarker=/([\{\[\(])[^\}\]\)]*$|^\s*(\/\*)/,this.foldingStopMarker=/^[^\[\{\(]*([\}\]\)])|^[\s\*]*(\*\/)/,this.singleLineBlockCommentRe=/^\s*(\/\*).*\*\/\s*$/,this.tripleStarBlockCommentRe=/^\s*(\/\*\*\*).*\*\/\s*$/,this.startRegionRe=/^\s*(\/\*|\/\/)#?region\b/,this._getFoldWidgetBase=this.getFoldWidget,this.getFoldWidget=function(e,t,n){var r=e.getLine(n);if(this.singleLineBlockCommentRe.test(r)&&!this.startRegionRe.test(r)&&!this.tripleStarBlockCommentRe.test(r))return"";var i=this._getFoldWidgetBase(e,t,n);return!i&&this.startRegionRe.test(r)?"start":i},this.getFoldWidgetRange=function(e,t,n,r){var i=e.getLine(n);if(this.startRegionRe.test(i))return this.getCommentRegionBlock(e,i,n);var s=i.match(this.foldingStartMarker);if(s){var o=s.index;if(s[1])return this.openingBracketBlock(e,s[1],n,o);var u=e.getCommentFoldRange(n,o+s[0].length,1);return u&&!u.isMultiLine()&&(r?u=this.getSectionRange(e,n):t!="all"&&(u=null)),u}if(t==="markbegin")return;var s=i.match(this.foldingStopMarker);if(s){var o=s.index+s[0].length;return s[1]?this.closingBracketBlock(e,s[1],n,o):e.getCommentFoldRange(n,o,-1)}},this.getSectionRange=function(e,t){var n=e.getLine(t),r=n.search(/\S/),s=t,o=n.length;t+=1;var u=t,a=e.getLength();while(++t<a){n=e.getLine(t);var f=n.search(/\S/);if(f===-1)continue;if(r>f)break;var l=this.getFoldWidgetRange(e,"all",t);if(l){if(l.start.row<=s)break;if(l.isMultiLine())t=l.end.row;else if(r==f)break}u=t}return new i(s,o,u,e.getLine(u).length)},this.getCommentRegionBlock=function(e,t,n){var r=t.search(/\s*$/),s=e.getLength(),o=n,u=/^\s*(?:\/\*|\/\/|--)#?(end)?region\b/,a=1;while(++n<s){t=e.getLine(n);var f=u.exec(t);if(!f)continue;f[1]?a--:a++;if(!a)break}var l=n;if(l>o)return new i(o,r,l,t.length)}}.call(o.prototype)}),ace.define("ace/mode/javascript",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/javascript_highlight_rules","ace/mode/matching_brace_outdent","ace/worker/worker_client","ace/mode/behaviour/cstyle","ace/mode/folding/cstyle"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("./text").Mode,s=e("./javascript_highlight_rules").JavaScriptHighlightRules,o=e("./matching_brace_outdent").MatchingBraceOutdent,u=e("../worker/worker_client").WorkerClient,a=e("./behaviour/cstyle").CstyleBehaviour,f=e("./folding/cstyle").FoldMode,l=function(){this.HighlightRules=s,this.$outdent=new o,this.$behaviour=new a,this.foldingRules=new f};r.inherits(l,i),function(){this.lineCommentStart="//",this.blockComment={start:"/*",end:"*/"},this.$quotes={'"':'"',"'":"'","`":"`"},this.getNextLineIndent=function(e,t,n){var r=this.$getIndent(t),i=this.getTokenizer().getLineTokens(t,e),s=i.tokens,o=i.state;if(s.length&&s[s.length-1].type=="comment")return r;if(e=="start"||e=="no_regex"){var u=t.match(/^.*(?:\bcase\b.*:|[\{\(\[])\s*$/);u&&(r+=n)}else if(e=="doc-start"){if(o=="start"||o=="no_regex")return"";var u=t.match(/^\s*(\/?)\*/);u&&(u[1]&&(r+=" "),r+="* ")}return r},this.checkOutdent=function(e,t,n){return this.$outdent.checkOutdent(t,n)},this.autoOutdent=function(e,t,n){this.$outdent.autoOutdent(t,n)},this.createWorker=function(e){var t=new u(["ace"],"ace/mode/javascript_worker","JavaScriptWorker");return t.attachToDocument(e.getDocument()),t.on("annotate",function(t){e.setAnnotations(t.data)}),t.on("terminate",function(){e.clearAnnotations()}),t},this.$id="ace/mode/javascript"}.call(l.prototype),t.Mode=l});                (function() {
                    ace.require(["ace/mode/javascript"], function(m) {
                        if (typeof module == "object" && typeof exports == "object" && module) {
                            module.exports = m;
                        }
                    });
                })();",
{"status":false}
],

[
"three.min.js_r110",
"// r110
// threejs.org/license
(function(k,Aa){"object"===typeof exports&&"undefined"!==typeof module?Aa(exports):"function"===typeof define&&define.amd?define(["exports"],Aa):(k=k||self,Aa(k.THREE={}))})(this,function(k){function Aa(){}function B(a,b){this.x=a||0;this.y=b||0}function wa(a,b,c,d){this._x=a||0;this._y=b||0;this._z=c||0;this._w=void 0!==d?d:1}function n(a,b,c){this.x=a||0;this.y=b||0;this.z=c||0}function Z(){this.elements=[1,0,0,0,1,0,0,0,1];0<arguments.length&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}
function Y(a,b,c,d,e,f,g,h,l,m){Object.defineProperty(this,"id",{value:Si++});this.uuid=P.generateUUID();this.name="";this.image=void 0!==a?a:Y.DEFAULT_IMAGE;this.mipmaps=[];this.mapping=void 0!==b?b:Y.DEFAULT_MAPPING;this.wrapS=void 0!==c?c:1001;this.wrapT=void 0!==d?d:1001;this.magFilter=void 0!==e?e:1006;this.minFilter=void 0!==f?f:1008;this.anisotropy=void 0!==l?l:1;this.format=void 0!==g?g:1023;this.type=void 0!==h?h:1009;this.offset=new B(0,0);this.repeat=new B(1,1);this.center=new B(0,0);this.rotation=
0;this.matrixAutoUpdate=!0;this.matrix=new Z;this.generateMipmaps=!0;this.premultiplyAlpha=!1;this.flipY=!0;this.unpackAlignment=4;this.encoding=void 0!==m?m:3E3;this.version=0;this.onUpdate=null}function da(a,b,c,d){this.x=a||0;this.y=b||0;this.z=c||0;this.w=void 0!==d?d:1}function Ba(a,b,c){this.width=a;this.height=b;this.scissor=new da(0,0,a,b);this.scissorTest=!1;this.viewport=new da(0,0,a,b);c=c||{};this.texture=new Y(void 0,void 0,c.wrapS,c.wrapT,c.magFilter,c.minFilter,c.format,c.type,c.anisotropy,
c.encoding);this.texture.image={};this.texture.image.width=a;this.texture.image.height=b;this.texture.generateMipmaps=void 0!==c.generateMipmaps?c.generateMipmaps:!1;this.texture.minFilter=void 0!==c.minFilter?c.minFilter:1006;this.depthBuffer=void 0!==c.depthBuffer?c.depthBuffer:!0;this.stencilBuffer=void 0!==c.stencilBuffer?c.stencilBuffer:!0;this.depthTexture=void 0!==c.depthTexture?c.depthTexture:null}function Sf(a,b,c){Ba.call(this,a,b,c);this.samples=4}function Q(){this.elements=[1,0,0,0,0,
1,0,0,0,0,1,0,0,0,0,1];0<arguments.length&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}function Pb(a,b,c,d){this._x=a||0;this._y=b||0;this._z=c||0;this._order=d||Pb.DefaultOrder}function Tf(){this.mask=1}function E(){Object.defineProperty(this,"id",{value:Ti++});this.uuid=P.generateUUID();this.name="";this.type="Object3D";this.parent=null;this.children=[];this.up=E.DefaultUp.clone();var a=new n,b=new Pb,c=new wa,d=new n(1,1,1);b._onChange(function(){c.setFromEuler(b,
!1)});c._onChange(function(){b.setFromQuaternion(c,void 0,!1)});Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:a},rotation:{configurable:!0,enumerable:!0,value:b},quaternion:{configurable:!0,enumerable:!0,value:c},scale:{configurable:!0,enumerable:!0,value:d},modelViewMatrix:{value:new Q},normalMatrix:{value:new Z}});this.matrix=new Q;this.matrixWorld=new Q;this.matrixAutoUpdate=E.DefaultMatrixAutoUpdate;this.matrixWorldNeedsUpdate=!1;this.layers=new Tf;this.visible=!0;
this.receiveShadow=this.castShadow=!1;this.frustumCulled=!0;this.renderOrder=0;this.userData={}}function vd(){E.call(this);this.type="Scene";this.overrideMaterial=this.fog=this.background=null;this.autoUpdate=!0;"undefined"!==typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}function ab(a,b){this.min=void 0!==a?a:new n(Infinity,Infinity,Infinity);this.max=void 0!==b?b:new n(-Infinity,-Infinity,-Infinity)}function Uf(a,b,c,d,e){var f;var g=0;for(f=
a.length-3;g<=f;g+=3){Qb.fromArray(a,g);var h=e.x*Math.abs(Qb.x)+e.y*Math.abs(Qb.y)+e.z*Math.abs(Qb.z),l=b.dot(Qb),m=c.dot(Qb),r=d.dot(Qb);if(Math.max(-Math.max(l,m,r),Math.min(l,m,r))>h)return!1}return!0}function mb(a,b){this.center=void 0!==a?a:new n;this.radius=void 0!==b?b:0}function Rb(a,b){this.origin=void 0!==a?a:new n;this.direction=void 0!==b?b:new n}function Oa(a,b){this.normal=void 0!==a?a:new n(1,0,0);this.constant=void 0!==b?b:0}function ba(a,b,c){this.a=void 0!==a?a:new n;this.b=void 0!==
b?b:new n;this.c=void 0!==c?c:new n}function J(a,b,c){return void 0===b&&void 0===c?this.set(a):this.setRGB(a,b,c)}function Vf(a,b,c){0>c&&(c+=1);1<c&&--c;return c<1/6?a+6*(b-a)*c:.5>c?b:c<2/3?a+6*(b-a)*(2/3-c):a}function Wf(a){return.04045>a?.0773993808*a:Math.pow(.9478672986*a+.0521327014,2.4)}function Xf(a){return.0031308>a?12.92*a:1.055*Math.pow(a,.41666)-.055}function xc(a,b,c,d,e,f){this.a=a;this.b=b;this.c=c;this.normal=d&&d.isVector3?d:new n;this.vertexNormals=Array.isArray(d)?d:[];this.color=
e&&e.isColor?e:new J;this.vertexColors=Array.isArray(e)?e:[];this.materialIndex=void 0!==f?f:0}function O(){Object.defineProperty(this,"id",{value:Ui++});this.uuid=P.generateUUID();this.name="";this.type="Material";this.fog=!0;this.blending=1;this.side=0;this.vertexTangents=this.flatShading=!1;this.vertexColors=0;this.opacity=1;this.transparent=!1;this.blendSrc=204;this.blendDst=205;this.blendEquation=100;this.blendEquationAlpha=this.blendDstAlpha=this.blendSrcAlpha=null;this.depthFunc=3;this.depthWrite=
this.depthTest=!0;this.stencilWriteMask=255;this.stencilFunc=519;this.stencilRef=0;this.stencilFuncMask=255;this.stencilZPass=this.stencilZFail=this.stencilFail=7680;this.stencilWrite=!1;this.clippingPlanes=null;this.clipShadows=this.clipIntersection=!1;this.shadowSide=null;this.colorWrite=!0;this.precision=null;this.polygonOffset=!1;this.polygonOffsetUnits=this.polygonOffsetFactor=0;this.dithering=!1;this.alphaTest=0;this.premultipliedAlpha=!1;this.toneMapped=this.visible=!0;this.userData={};this.needsUpdate=
!0}function Ga(a){O.call(this);this.type="MeshBasicMaterial";this.color=new J(16777215);this.lightMap=this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.envMap=this.alphaMap=this.specularMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap="round";this.morphTargets=this.skinning=!1;this.setValues(a)}function N(a,b,c){if(Array.isArray(a))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");
this.name="";this.array=a;this.itemSize=b;this.count=void 0!==a?a.length/b:0;this.normalized=!0===c;this.usage=35044;this.updateRange={offset:0,count:-1};this.version=0}function wd(a,b,c){N.call(this,new Int8Array(a),b,c)}function xd(a,b,c){N.call(this,new Uint8Array(a),b,c)}function yd(a,b,c){N.call(this,new Uint8ClampedArray(a),b,c)}function zd(a,b,c){N.call(this,new Int16Array(a),b,c)}function Sb(a,b,c){N.call(this,new Uint16Array(a),b,c)}function Ad(a,b,c){N.call(this,new Int32Array(a),b,c)}function Tb(a,
b,c){N.call(this,new Uint32Array(a),b,c)}function A(a,b,c){N.call(this,new Float32Array(a),b,c)}function Bd(a,b,c){N.call(this,new Float64Array(a),b,c)}function ih(){this.vertices=[];this.normals=[];this.colors=[];this.uvs=[];this.uvs2=[];this.groups=[];this.morphTargets={};this.skinWeights=[];this.skinIndices=[];this.boundingSphere=this.boundingBox=null;this.groupsNeedUpdate=this.uvsNeedUpdate=this.colorsNeedUpdate=this.normalsNeedUpdate=this.verticesNeedUpdate=!1}function jh(a){if(0===a.length)return-Infinity;
for(var b=a[0],c=1,d=a.length;c<d;++c)a[c]>b&&(b=a[c]);return b}function D(){Object.defineProperty(this,"id",{value:Vi+=2});this.uuid=P.generateUUID();this.name="";this.type="BufferGeometry";this.index=null;this.attributes={};this.morphAttributes={};this.groups=[];this.boundingSphere=this.boundingBox=null;this.drawRange={start:0,count:Infinity};this.userData={}}function ea(a,b){E.call(this);this.type="Mesh";this.geometry=void 0!==a?a:new D;this.material=void 0!==b?b:new Ga({color:16777215*Math.random()});
this.drawMode=0;this.updateMorphTargets()}function kh(a,b,c,d,e,f,g,h){if(null===(1===b.side?d.intersectTriangle(g,f,e,!0,h):d.intersectTriangle(e,f,g,2!==b.side,h)))return null;Ee.copy(h);Ee.applyMatrix4(a.matrixWorld);b=c.ray.origin.distanceTo(Ee);return b<c.near||b>c.far?null:{distance:b,point:Ee.clone(),object:a}}function Fe(a,b,c,d,e,f,g,h,l,m,r){Ub.fromBufferAttribute(e,l);Vb.fromBufferAttribute(e,m);Wb.fromBufferAttribute(e,r);e=a.morphTargetInfluences;if(b.morphTargets&&f&&e){Yf.set(0,0,0);
Zf.set(0,0,0);$f.set(0,0,0);for(var q=0,u=f.length;q<u;q++){var p=e[q],k=f[q];0!==p&&(lh.fromBufferAttribute(k,l),mh.fromBufferAttribute(k,m),nh.fromBufferAttribute(k,r),Yf.addScaledVector(lh.sub(Ub),p),Zf.addScaledVector(mh.sub(Vb),p),$f.addScaledVector(nh.sub(Wb),p))}Ub.add(Yf);Vb.add(Zf);Wb.add($f)}if(a=kh(a,b,c,d,Ub,Vb,Wb,Cd))g&&(yc.fromBufferAttribute(g,l),zc.fromBufferAttribute(g,m),Ac.fromBufferAttribute(g,r),a.uv=ba.getUV(Cd,Ub,Vb,Wb,yc,zc,Ac,new B)),h&&(yc.fromBufferAttribute(h,l),zc.fromBufferAttribute(h,
m),Ac.fromBufferAttribute(h,r),a.uv2=ba.getUV(Cd,Ub,Vb,Wb,yc,zc,Ac,new B)),g=new xc(l,m,r),ba.getNormal(Ub,Vb,Wb,g.normal),a.face=g;return a}function G(){Object.defineProperty(this,"id",{value:Wi+=2});this.uuid=P.generateUUID();this.name="";this.type="Geometry";this.vertices=[];this.colors=[];this.faces=[];this.faceVertexUvs=[[]];this.morphTargets=[];this.morphNormals=[];this.skinWeights=[];this.skinIndices=[];this.lineDistances=[];this.boundingSphere=this.boundingBox=null;this.groupsNeedUpdate=this.lineDistancesNeedUpdate=
this.colorsNeedUpdate=this.normalsNeedUpdate=this.uvsNeedUpdate=this.verticesNeedUpdate=this.elementsNeedUpdate=!1}function Xb(a){var b={},c;for(c in a){b[c]={};for(var d in a[c]){var e=a[c][d];e&&(e.isColor||e.isMatrix3||e.isMatrix4||e.isVector2||e.isVector3||e.isVector4||e.isTexture)?b[c][d]=e.clone():Array.isArray(e)?b[c][d]=e.slice():b[c][d]=e}}return b}function ua(a){for(var b={},c=0;c<a.length;c++){var d=Xb(a[c]),e;for(e in d)b[e]=d[e]}return b}function va(a){O.call(this);this.type="ShaderMaterial";
this.defines={};this.uniforms={};this.vertexShader="void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}";this.fragmentShader="void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}";this.linewidth=1;this.wireframe=!1;this.wireframeLinewidth=1;this.morphNormals=this.morphTargets=this.skinning=this.clipping=this.lights=this.fog=!1;this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1};this.defaultAttributeValues={color:[1,1,
1],uv:[0,0],uv2:[0,0]};this.index0AttributeName=void 0;this.uniformsNeedUpdate=!1;void 0!==a&&(void 0!==a.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(a))}function bb(){E.call(this);this.type="Camera";this.matrixWorldInverse=new Q;this.projectionMatrix=new Q;this.projectionMatrixInverse=new Q}function U(a,b,c,d){bb.call(this);this.type="PerspectiveCamera";this.fov=void 0!==a?a:50;this.zoom=1;this.near=void 0!==
c?c:.1;this.far=void 0!==d?d:2E3;this.focus=10;this.aspect=void 0!==b?b:1;this.view=null;this.filmGauge=35;this.filmOffset=0;this.updateProjectionMatrix()}function Bc(a,b,c,d){E.call(this);this.type="CubeCamera";var e=new U(90,1,a,b);e.up.set(0,-1,0);e.lookAt(new n(1,0,0));this.add(e);var f=new U(90,1,a,b);f.up.set(0,-1,0);f.lookAt(new n(-1,0,0));this.add(f);var g=new U(90,1,a,b);g.up.set(0,0,1);g.lookAt(new n(0,1,0));this.add(g);var h=new U(90,1,a,b);h.up.set(0,0,-1);h.lookAt(new n(0,-1,0));this.add(h);
var l=new U(90,1,a,b);l.up.set(0,-1,0);l.lookAt(new n(0,0,1));this.add(l);var m=new U(90,1,a,b);m.up.set(0,-1,0);m.lookAt(new n(0,0,-1));this.add(m);d=d||{format:1022,magFilter:1006,minFilter:1006};this.renderTarget=new Bb(c,c,d);this.renderTarget.texture.name="CubeCamera";this.update=function(a,b){null===this.parent&&this.updateMatrixWorld();var c=a.getRenderTarget(),d=this.renderTarget,r=d.texture.generateMipmaps;d.texture.generateMipmaps=!1;a.setRenderTarget(d,0);a.render(b,e);a.setRenderTarget(d,
1);a.render(b,f);a.setRenderTarget(d,2);a.render(b,g);a.setRenderTarget(d,3);a.render(b,h);a.setRenderTarget(d,4);a.render(b,l);d.texture.generateMipmaps=r;a.setRenderTarget(d,5);a.render(b,m);a.setRenderTarget(c)};this.clear=function(a,b,c,d){for(var e=a.getRenderTarget(),f=this.renderTarget,g=0;6>g;g++)a.setRenderTarget(f,g),a.clear(b,c,d);a.setRenderTarget(e)}}function Bb(a,b,c){Ba.call(this,a,b,c)}function Yb(a,b,c,d,e,f,g,h,l,m,r,q){Y.call(this,null,f,g,h,l,m,d,e,r,q);this.image={data:a||null,
width:b||1,height:c||1};this.magFilter=void 0!==l?l:1003;this.minFilter=void 0!==m?m:1003;this.flipY=this.generateMipmaps=!1;this.unpackAlignment=1;this.needsUpdate=!0}function Dd(a,b,c,d,e,f){this.planes=[void 0!==a?a:new Oa,void 0!==b?b:new Oa,void 0!==c?c:new Oa,void 0!==d?d:new Oa,void 0!==e?e:new Oa,void 0!==f?f:new Oa]}function ag(){function a(e,f){!1!==c&&(d(e,f),b.requestAnimationFrame(a))}var b=null,c=!1,d=null;return{start:function(){!0!==c&&null!==d&&(b.requestAnimationFrame(a),c=!0)},
stop:function(){c=!1},setAnimationLoop:function(a){d=a},setContext:function(a){b=a}}}function Xi(a){function b(b,c){var d=b.array,e=b.usage,h=a.createBuffer();a.bindBuffer(c,h);a.bufferData(c,d,e);b.onUploadCallback();c=5126;d instanceof Float32Array?c=5126:d instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):d instanceof Uint16Array?c=5123:d instanceof Int16Array?c=5122:d instanceof Uint32Array?c=5125:d instanceof Int32Array?c=5124:d instanceof
Int8Array?c=5120:d instanceof Uint8Array&&(c=5121);return{buffer:h,type:c,bytesPerElement:d.BYTES_PER_ELEMENT,version:b.version}}var c=new WeakMap;return{get:function(a){a.isInterleavedBufferAttribute&&(a=a.data);return c.get(a)},remove:function(b){b.isInterleavedBufferAttribute&&(b=b.data);var d=c.get(b);d&&(a.deleteBuffer(d.buffer),c.delete(b))},update:function(d,e){d.isInterleavedBufferAttribute&&(d=d.data);var f=c.get(d);if(void 0===f)c.set(d,b(d,e));else if(f.version<d.version){var g=d.array,
h=d.updateRange;a.bindBuffer(e,f.buffer);-1===h.count?a.bufferSubData(e,0,g):(a.bufferSubData(e,h.offset*g.BYTES_PER_ELEMENT,g.subarray(h.offset,h.offset+h.count)),h.count=-1);f.version=d.version}}}}function Ed(a,b,c,d){G.call(this);this.type="PlaneGeometry";this.parameters={width:a,height:b,widthSegments:c,heightSegments:d};this.fromBufferGeometry(new Zb(a,b,c,d));this.mergeVertices()}function Zb(a,b,c,d){D.call(this);this.type="PlaneBufferGeometry";this.parameters={width:a,height:b,widthSegments:c,
heightSegments:d};a=a||1;b=b||1;var e=a/2,f=b/2;c=Math.floor(c)||1;d=Math.floor(d)||1;var g=c+1,h=d+1,l=a/c,m=b/d,r=[],q=[],u=[],p=[];for(a=0;a<h;a++){var k=a*m-f;for(b=0;b<g;b++)q.push(b*l-e,-k,0),u.push(0,0,1),p.push(b/c),p.push(1-a/d)}for(a=0;a<d;a++)for(b=0;b<c;b++)e=b+g*(a+1),f=b+1+g*(a+1),h=b+1+g*a,r.push(b+g*a,e,h),r.push(e,f,h);this.setIndex(r);this.setAttribute("position",new A(q,3));this.setAttribute("normal",new A(u,3));this.setAttribute("uv",new A(p,2))}function Yi(a,b,c,d){function e(a,
c){b.buffers.color.setClear(a.r,a.g,a.b,c,d)}var f=new J(0),g=0,h,l,m=null,r=0;return{getClearColor:function(){return f},setClearColor:function(a,b){f.set(a);g=void 0!==b?b:1;e(f,g)},getClearAlpha:function(){return g},setClearAlpha:function(a){g=a;e(f,g)},render:function(b,d,p,k){d=d.background;p=a.vr;(p=p.getSession&&p.getSession())&&"additive"===p.environmentBlendMode&&(d=null);null===d?(e(f,g),m=null,r=0):d&&d.isColor&&(e(d,1),k=!0,m=null,r=0);(a.autoClear||k)&&a.clear(a.autoClearColor,a.autoClearDepth,
a.autoClearStencil);if(d&&(d.isCubeTexture||d.isWebGLRenderTargetCube)){void 0===l&&(l=new ea(new Fd(1,1,1),new va({type:"BackgroundCubeMaterial",uniforms:Xb(cb.cube.uniforms),vertexShader:cb.cube.vertexShader,fragmentShader:cb.cube.fragmentShader,side:1,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),l.geometry.deleteAttribute("uv"),l.onBeforeRender=function(a,b,c){this.matrixWorld.copyPosition(c.matrixWorld)},Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.tCube.value}}),
c.update(l));k=d.isWebGLRenderTargetCube?d.texture:d;l.material.uniforms.tCube.value=k;l.material.uniforms.tFlip.value=d.isWebGLRenderTargetCube?1:-1;if(m!==d||r!==k.version)l.material.needsUpdate=!0,m=d,r=k.version;b.unshift(l,l.geometry,l.material,0,0,null)}else if(d&&d.isTexture){void 0===h&&(h=new ea(new Zb(2,2),new va({type:"BackgroundMaterial",uniforms:Xb(cb.background.uniforms),vertexShader:cb.background.vertexShader,fragmentShader:cb.background.fragmentShader,side:0,depthTest:!1,depthWrite:!1,
fog:!1})),h.geometry.deleteAttribute("normal"),Object.defineProperty(h.material,"map",{get:function(){return this.uniforms.t2D.value}}),c.update(h));h.material.uniforms.t2D.value=d;!0===d.matrixAutoUpdate&&d.updateMatrix();h.material.uniforms.uvTransform.value.copy(d.matrix);if(m!==d||r!==d.version)h.material.needsUpdate=!0,m=d,r=d.version;b.unshift(h,h.geometry,h.material,0,0,null)}}}}function Zi(a,b,c,d){var e=d.isWebGL2,f;this.setMode=function(a){f=a};this.render=function(b,d){a.drawArrays(f,b,
d);c.update(d,f)};this.renderInstances=function(d,h,l,m){if(0!==m){if(e){d=a;var g="drawArraysInstanced"}else if(d=b.get("ANGLE_instanced_arrays"),g="drawArraysInstancedANGLE",null===d){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}d[g](f,h,l,m);c.update(l,f,m)}}}function $i(a,b,c){function d(b){if("highp"===b){if(0<a.getShaderPrecisionFormat(35633,36338).precision&&0<a.getShaderPrecisionFormat(35632,
36338).precision)return"highp";b="mediump"}return"mediump"===b&&0<a.getShaderPrecisionFormat(35633,36337).precision&&0<a.getShaderPrecisionFormat(35632,36337).precision?"mediump":"lowp"}var e,f="undefined"!==typeof WebGL2RenderingContext&&a instanceof WebGL2RenderingContext||"undefined"!==typeof WebGL2ComputeRenderingContext&&a instanceof WebGL2ComputeRenderingContext,g=void 0!==c.precision?c.precision:"highp",h=d(g);h!==g&&(console.warn("THREE.WebGLRenderer:",g,"not supported, using",h,"instead."),
g=h);c=!0===c.logarithmicDepthBuffer;h=a.getParameter(34930);var l=a.getParameter(35660),m=a.getParameter(3379),r=a.getParameter(34076),q=a.getParameter(34921),k=a.getParameter(36347),p=a.getParameter(36348),t=a.getParameter(36349),v=0<l,y=f||!!b.get("OES_texture_float"),n=v&&y,x=f?a.getParameter(36183):0;return{isWebGL2:f,getMaxAnisotropy:function(){if(void 0!==e)return e;var c=b.get("EXT_texture_filter_anisotropic");return e=null!==c?a.getParameter(c.MAX_TEXTURE_MAX_ANISOTROPY_EXT):0},getMaxPrecision:d,
precision:g,logarithmicDepthBuffer:c,maxTextures:h,maxVertexTextures:l,maxTextureSize:m,maxCubemapSize:r,maxAttributes:q,maxVertexUniforms:k,maxVaryings:p,maxFragmentUniforms:t,vertexTextures:v,floatFragmentTextures:y,floatVertexTextures:n,maxSamples:x}}function aj(){function a(){m.value!==d&&(m.value=d,m.needsUpdate=0<e);c.numPlanes=e;c.numIntersection=0}function b(a,b,d,e){var f=null!==a?a.length:0,g=null;if(0!==f){g=m.value;if(!0!==e||null===g){e=d+4*f;b=b.matrixWorldInverse;l.getNormalMatrix(b);
if(null===g||g.length<e)g=new Float32Array(e);for(e=0;e!==f;++e,d+=4)h.copy(a[e]).applyMatrix4(b,l),h.normal.toArray(g,d),g[d+3]=h.constant}m.value=g;m.needsUpdate=!0}c.numPlanes=f;return g}var c=this,d=null,e=0,f=!1,g=!1,h=new Oa,l=new Z,m={value:null,needsUpdate:!1};this.uniform=m;this.numIntersection=this.numPlanes=0;this.init=function(a,c,g){var h=0!==a.length||c||0!==e||f;f=c;d=b(a,g,0);e=a.length;return h};this.beginShadows=function(){g=!0;b(null)};this.endShadows=function(){g=!1;a()};this.setState=
function(c,h,l,p,k,v){if(!f||null===c||0===c.length||g&&!l)g?b(null):a();else{l=g?0:e;var r=4*l,q=k.clippingState||null;m.value=q;q=b(c,p,r,v);for(c=0;c!==r;++c)q[c]=d[c];k.clippingState=q;this.numIntersection=h?this.numPlanes:0;this.numPlanes+=l}}}function bj(a){var b={};return{get:function(c){if(void 0!==b[c])return b[c];switch(c){case "WEBGL_depth_texture":var d=a.getExtension("WEBGL_depth_texture")||a.getExtension("MOZ_WEBGL_depth_texture")||a.getExtension("WEBKIT_WEBGL_depth_texture");break;
case "EXT_texture_filter_anisotropic":d=a.getExtension("EXT_texture_filter_anisotropic")||a.getExtension("MOZ_EXT_texture_filter_anisotropic")||a.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case "WEBGL_compressed_texture_s3tc":d=a.getExtension("WEBGL_compressed_texture_s3tc")||a.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||a.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case "WEBGL_compressed_texture_pvrtc":d=a.getExtension("WEBGL_compressed_texture_pvrtc")||a.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");
break;default:d=a.getExtension(c)}null===d&&console.warn("THREE.WebGLRenderer: "+c+" extension not supported.");return b[c]=d}}}function cj(a,b,c){function d(a){var e=a.target;a=f.get(e);null!==a.index&&b.remove(a.index);for(var h in a.attributes)b.remove(a.attributes[h]);e.removeEventListener("dispose",d);f.delete(e);if(h=g.get(a))b.remove(h),g.delete(a);c.memory.geometries--}function e(a){var c=[],d=a.index,e=a.attributes.position;if(null!==d){var f=d.array;d=d.version;e=0;for(var h=f.length;e<
h;e+=3){var k=f[e+0],t=f[e+1],v=f[e+2];c.push(k,t,t,v,v,k)}}else for(f=e.array,d=e.version,e=0,h=f.length/3-1;e<h;e+=3)k=e+0,t=e+1,v=e+2,c.push(k,t,t,v,v,k);c=new (65535<jh(c)?Tb:Sb)(c,1);c.version=d;b.update(c,34963);(f=g.get(a))&&b.remove(f);g.set(a,c)}var f=new WeakMap,g=new WeakMap;return{get:function(a,b){var e=f.get(b);if(e)return e;b.addEventListener("dispose",d);b.isBufferGeometry?e=b:b.isGeometry&&(void 0===b._bufferGeometry&&(b._bufferGeometry=(new D).setFromObject(a)),e=b._bufferGeometry);
f.set(b,e);c.memory.geometries++;return e},update:function(a){var c=a.index,d=a.attributes;null!==c&&b.update(c,34963);for(var e in d)b.update(d[e],34962);a=a.morphAttributes;for(e in a){c=a[e];d=0;for(var f=c.length;d<f;d++)b.update(c[d],34962)}},getWireframeAttribute:function(a){var b=g.get(a);if(b){var c=a.index;null!==c&&b.version<c.version&&e(a)}else e(a);return g.get(a)}}}function dj(a,b,c,d){var e=d.isWebGL2,f,g,h;this.setMode=function(a){f=a};this.setIndex=function(a){g=a.type;h=a.bytesPerElement};
this.render=function(b,d){a.drawElements(f,d,g,b*h);c.update(d,f)};this.renderInstances=function(d,m,r,q){if(0!==q){if(e){d=a;var l="drawElementsInstanced"}else if(d=b.get("ANGLE_instanced_arrays"),l="drawElementsInstancedANGLE",null===d){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}d[l](f,r,g,m*h,q);c.update(r,f,q)}}}function ej(a){var b={frame:0,calls:0,triangles:0,points:0,lines:0};
return{memory:{geometries:0,textures:0},render:b,programs:null,autoReset:!0,reset:function(){b.frame++;b.calls=0;b.triangles=0;b.points=0;b.lines=0},update:function(a,d,e){e=e||1;b.calls++;switch(d){case 4:b.triangles+=a/3*e;break;case 5:case 6:b.triangles+=e*(a-2);break;case 1:b.lines+=a/2*e;break;case 3:b.lines+=e*(a-1);break;case 2:b.lines+=e*a;break;case 0:b.points+=e*a;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",d)}}}}function fj(a,b){return Math.abs(b[1])-Math.abs(a[1])}
function gj(a){var b={},c=new Float32Array(8);return{update:function(d,e,f,g){var h=d.morphTargetInfluences,l=h.length;d=b[e.id];if(void 0===d){d=[];for(var m=0;m<l;m++)d[m]=[m,0];b[e.id]=d}var r=f.morphTargets&&e.morphAttributes.position;f=f.morphNormals&&e.morphAttributes.normal;for(m=0;m<l;m++){var q=d[m];0!==q[1]&&(r&&e.deleteAttribute("morphTarget"+m),f&&e.deleteAttribute("morphNormal"+m))}for(m=0;m<l;m++)q=d[m],q[0]=m,q[1]=h[m];d.sort(fj);for(m=0;8>m;m++){if(q=d[m])if(h=q[0],l=q[1]){r&&e.setAttribute("morphTarget"+
m,r[h]);f&&e.setAttribute("morphNormal"+m,f[h]);c[m]=l;continue}c[m]=0}g.getUniforms().setValue(a,"morphTargetInfluences",c)}}}function hj(a,b,c,d){var e={};return{update:function(a){var f=d.render.frame,h=a.geometry,l=b.get(a,h);e[l.id]!==f&&(h.isGeometry&&l.updateFromObject(a),b.update(l),e[l.id]=f);a.isInstancedMesh&&c.update(a.instanceMatrix,34962);return l},dispose:function(){e={}}}}function nb(a,b,c,d,e,f,g,h,l,m){a=void 0!==a?a:[];Y.call(this,a,void 0!==b?b:301,c,d,e,f,void 0!==g?g:1022,h,
l,m);this.flipY=!1}function Cc(a,b,c,d){Y.call(this,null);this.image={data:a||null,width:b||1,height:c||1,depth:d||1};this.minFilter=this.magFilter=1003;this.wrapR=1001;this.flipY=this.generateMipmaps=!1;this.needsUpdate=!0}function Dc(a,b,c,d){Y.call(this,null);this.image={data:a||null,width:b||1,height:c||1,depth:d||1};this.minFilter=this.magFilter=1003;this.wrapR=1001;this.flipY=this.generateMipmaps=!1;this.needsUpdate=!0}function Ec(a,b,c){var d=a[0];if(0>=d||0<d)return a;var e=b*c,f=oh[e];void 0===
f&&(f=new Float32Array(e),oh[e]=f);if(0!==b)for(d.toArray(f,0),d=1,e=0;d!==b;++d)e+=c,a[d].toArray(f,e);return f}function La(a,b){if(a.length!==b.length)return!1;for(var c=0,d=a.length;c<d;c++)if(a[c]!==b[c])return!1;return!0}function Ha(a,b){for(var c=0,d=b.length;c<d;c++)a[c]=b[c]}function ph(a,b){var c=qh[b];void 0===c&&(c=new Int32Array(b),qh[b]=c);for(var d=0;d!==b;++d)c[d]=a.allocateTextureUnit();return c}function ij(a,b){var c=this.cache;c[0]!==b&&(a.uniform1f(this.addr,b),c[0]=b)}function jj(a,
b){var c=this.cache;if(void 0!==b.x){if(c[0]!==b.x||c[1]!==b.y)a.uniform2f(this.addr,b.x,b.y),c[0]=b.x,c[1]=b.y}else La(c,b)||(a.uniform2fv(this.addr,b),Ha(c,b))}function kj(a,b){var c=this.cache;if(void 0!==b.x){if(c[0]!==b.x||c[1]!==b.y||c[2]!==b.z)a.uniform3f(this.addr,b.x,b.y,b.z),c[0]=b.x,c[1]=b.y,c[2]=b.z}else if(void 0!==b.r){if(c[0]!==b.r||c[1]!==b.g||c[2]!==b.b)a.uniform3f(this.addr,b.r,b.g,b.b),c[0]=b.r,c[1]=b.g,c[2]=b.b}else La(c,b)||(a.uniform3fv(this.addr,b),Ha(c,b))}function lj(a,b){var c=
this.cache;if(void 0!==b.x){if(c[0]!==b.x||c[1]!==b.y||c[2]!==b.z||c[3]!==b.w)a.uniform4f(this.addr,b.x,b.y,b.z,b.w),c[0]=b.x,c[1]=b.y,c[2]=b.z,c[3]=b.w}else La(c,b)||(a.uniform4fv(this.addr,b),Ha(c,b))}function mj(a,b){var c=this.cache,d=b.elements;void 0===d?La(c,b)||(a.uniformMatrix2fv(this.addr,!1,b),Ha(c,b)):La(c,d)||(rh.set(d),a.uniformMatrix2fv(this.addr,!1,rh),Ha(c,d))}function nj(a,b){var c=this.cache,d=b.elements;void 0===d?La(c,b)||(a.uniformMatrix3fv(this.addr,!1,b),Ha(c,b)):La(c,d)||
(sh.set(d),a.uniformMatrix3fv(this.addr,!1,sh),Ha(c,d))}function oj(a,b){var c=this.cache,d=b.elements;void 0===d?La(c,b)||(a.uniformMatrix4fv(this.addr,!1,b),Ha(c,b)):La(c,d)||(th.set(d),a.uniformMatrix4fv(this.addr,!1,th),Ha(c,d))}function pj(a,b,c){var d=this.cache,e=c.allocateTextureUnit();d[0]!==e&&(a.uniform1i(this.addr,e),d[0]=e);c.safeSetTexture2D(b||uh,e)}function qj(a,b,c){var d=this.cache,e=c.allocateTextureUnit();d[0]!==e&&(a.uniform1i(this.addr,e),d[0]=e);c.setTexture2DArray(b||rj,e)}
function sj(a,b,c){var d=this.cache,e=c.allocateTextureUnit();d[0]!==e&&(a.uniform1i(this.addr,e),d[0]=e);c.setTexture3D(b||tj,e)}function uj(a,b,c){var d=this.cache,e=c.allocateTextureUnit();d[0]!==e&&(a.uniform1i(this.addr,e),d[0]=e);c.safeSetTextureCube(b||vh,e)}function vj(a,b){var c=this.cache;c[0]!==b&&(a.uniform1i(this.addr,b),c[0]=b)}function wj(a,b){var c=this.cache;La(c,b)||(a.uniform2iv(this.addr,b),Ha(c,b))}function xj(a,b){var c=this.cache;La(c,b)||(a.uniform3iv(this.addr,b),Ha(c,b))}
function yj(a,b){var c=this.cache;La(c,b)||(a.uniform4iv(this.addr,b),Ha(c,b))}function zj(a){switch(a){case 5126:return ij;case 35664:return jj;case 35665:return kj;case 35666:return lj;case 35674:return mj;case 35675:return nj;case 35676:return oj;case 35678:case 36198:return pj;case 35679:return sj;case 35680:return uj;case 36289:return qj;case 5124:case 35670:return vj;case 35667:case 35671:return wj;case 35668:case 35672:return xj;case 35669:case 35673:return yj}}function Aj(a,b){a.uniform1fv(this.addr,
b)}function Bj(a,b){a.uniform1iv(this.addr,b)}function Cj(a,b){a.uniform2iv(this.addr,b)}function Dj(a,b){a.uniform3iv(this.addr,b)}function Ej(a,b){a.uniform4iv(this.addr,b)}function Fj(a,b){b=Ec(b,this.size,2);a.uniform2fv(this.addr,b)}function Gj(a,b){b=Ec(b,this.size,3);a.uniform3fv(this.addr,b)}function Hj(a,b){b=Ec(b,this.size,4);a.uniform4fv(this.addr,b)}function Ij(a,b){b=Ec(b,this.size,4);a.uniformMatrix2fv(this.addr,!1,b)}function Jj(a,b){b=Ec(b,this.size,9);a.uniformMatrix3fv(this.addr,
!1,b)}function Kj(a,b){b=Ec(b,this.size,16);a.uniformMatrix4fv(this.addr,!1,b)}function Lj(a,b,c){var d=b.length,e=ph(c,d);a.uniform1iv(this.addr,e);for(a=0;a!==d;++a)c.safeSetTexture2D(b[a]||uh,e[a])}function Mj(a,b,c){var d=b.length,e=ph(c,d);a.uniform1iv(this.addr,e);for(a=0;a!==d;++a)c.safeSetTextureCube(b[a]||vh,e[a])}function Nj(a){switch(a){case 5126:return Aj;case 35664:return Fj;case 35665:return Gj;case 35666:return Hj;case 35674:return Ij;case 35675:return Jj;case 35676:return Kj;case 35678:return Lj;
case 35680:return Mj;case 5124:case 35670:return Bj;case 35667:case 35671:return Cj;case 35668:case 35672:return Dj;case 35669:case 35673:return Ej}}function Oj(a,b,c){this.id=a;this.addr=c;this.cache=[];this.setValue=zj(b.type)}function wh(a,b,c){this.id=a;this.addr=c;this.cache=[];this.size=b.size;this.setValue=Nj(b.type)}function xh(a){this.id=a;this.seq=[];this.map={}}function Cb(a,b){this.seq=[];this.map={};for(var c=a.getProgramParameter(b,35718),d=0;d<c;++d){var e=a.getActiveUniform(b,d),f=
a.getUniformLocation(b,e.name),g=this,h=e.name,l=h.length;for(bg.lastIndex=0;;){var m=bg.exec(h),r=bg.lastIndex,q=m[1],k=m[3];"]"===m[2]&&(q|=0);if(void 0===k||"["===k&&r+2===l){h=g;e=void 0===k?new Oj(q,e,f):new wh(q,e,f);h.seq.push(e);h.map[e.id]=e;break}else k=g.map[q],void 0===k&&(k=new xh(q),q=g,g=k,q.seq.push(g),q.map[g.id]=g),g=k}}}function yh(a,b,c){b=a.createShader(b);a.shaderSource(b,c);a.compileShader(b);return b}function zh(a){switch(a){case 3E3:return["Linear","( value )"];case 3001:return["sRGB",
"( value )"];case 3002:return["RGBE","( value )"];case 3004:return["RGBM","( value, 7.0 )"];case 3005:return["RGBM","( value, 16.0 )"];case 3006:return["RGBD","( value, 256.0 )"];case 3007:return["Gamma","( value, float( GAMMA_FACTOR ) )"];case 3003:return["LogLuv","( value )"];default:throw Error("unsupported encoding: "+a);}}function Ah(a,b,c){var d=a.getShaderParameter(b,35713),e=a.getShaderInfoLog(b).trim();if(d&&""===e)return"";a=a.getShaderSource(b).split("\n");for(b=0;b<a.length;b++)a[b]=b+
1+": "+a[b];a=a.join("\n");return"THREE.WebGLShader: gl.getShaderInfoLog() "+c+"\n"+e+a}function Ge(a,b){b=zh(b);return"vec4 "+a+"( vec4 value ) { return "+b[0]+"ToLinear"+b[1]+"; }"}function Pj(a,b){b=zh(b);return"vec4 "+a+"( vec4 value ) { return LinearTo"+b[0]+b[1]+"; }"}function Qj(a,b){switch(b){case 1:b="Linear";break;case 2:b="Reinhard";break;case 3:b="Uncharted2";break;case 4:b="OptimizedCineon";break;case 5:b="ACESFilmic";break;default:throw Error("unsupported toneMapping: "+b);}return"vec3 "+
a+"( vec3 color ) { return "+b+"ToneMapping( color ); }"}function Rj(a,b,c){a=a||{};return[a.derivatives||b.envMapCubeUV||b.bumpMap||b.tangentSpaceNormalMap||b.clearcoatNormalMap||b.flatShading?"#extension GL_OES_standard_derivatives : enable":"",(a.fragDepth||b.logarithmicDepthBuffer)&&c.get("EXT_frag_depth")?"#extension GL_EXT_frag_depth : enable":"",a.drawBuffers&&c.get("WEBGL_draw_buffers")?"#extension GL_EXT_draw_buffers : require":"",(a.shaderTextureLOD||b.envMap)&&c.get("EXT_shader_texture_lod")?
"#extension GL_EXT_shader_texture_lod : enable":""].filter(Gd).join("\n")}function Sj(a){var b=[],c;for(c in a){var d=a[c];!1!==d&&b.push("#define "+c+" "+d)}return b.join("\n")}function Gd(a){return""!==a}function Bh(a,b){return a.replace(/NUM_DIR_LIGHTS/g,b.numDirLights).replace(/NUM_SPOT_LIGHTS/g,b.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,b.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,b.numPointLights).replace(/NUM_HEMI_LIGHTS/g,b.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,b.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,
b.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,b.numPointLightShadows)}function Ch(a,b){return a.replace(/NUM_CLIPPING_PLANES/g,b.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,b.numClippingPlanes-b.numClipIntersection)}function cg(a,b){a=S[b];if(void 0===a)throw Error("Can not resolve #include <"+b+">");return a.replace(dg,cg)}function Dh(a,b,c,d){a="";for(b=parseInt(b);b<parseInt(c);b++)a+=d.replace(/\[ i \]/g,"[ "+b+" ]").replace(/UNROLLED_LOOP_INDEX/g,b);return a}function Eh(a){var b=
"precision "+a.precision+" float;\nprecision "+a.precision+" int;";"highp"===a.precision?b+="\n#define HIGH_PRECISION":"mediump"===a.precision?b+="\n#define MEDIUM_PRECISION":"lowp"===a.precision&&(b+="\n#define LOW_PRECISION");return b}function Tj(a){var b="SHADOWMAP_TYPE_BASIC";1===a.shadowMapType?b="SHADOWMAP_TYPE_PCF":2===a.shadowMapType?b="SHADOWMAP_TYPE_PCF_SOFT":3===a.shadowMapType&&(b="SHADOWMAP_TYPE_VSM");return b}function Uj(a){var b="ENVMAP_TYPE_CUBE";if(a.envMap)switch(a.envMapMode){case 301:case 302:b=
"ENVMAP_TYPE_CUBE";break;case 306:case 307:b="ENVMAP_TYPE_CUBE_UV";break;case 303:case 304:b="ENVMAP_TYPE_EQUIREC";break;case 305:b="ENVMAP_TYPE_SPHERE"}return b}function Vj(a){var b="ENVMAP_MODE_REFLECTION";if(a.envMap)switch(a.envMapMode){case 302:case 304:b="ENVMAP_MODE_REFRACTION"}return b}function Wj(a){var b="ENVMAP_BLENDING_MULTIPLY";if(a.envMap)switch(a.combine){case 0:b="ENVMAP_BLENDING_MULTIPLY";break;case 1:b="ENVMAP_BLENDING_MIX";break;case 2:b="ENVMAP_BLENDING_ADD"}return b}function Xj(a,
b,c,d,e,f){var g=a.getContext(),h=d.defines,l=e.vertexShader,m=e.fragmentShader,r=Tj(f),q=Uj(f),k=Vj(f),p=Wj(f),t=0<a.gammaFactor?a.gammaFactor:1,v=f.isWebGL2?"":Rj(d.extensions,f,b),n=Sj(h),w=g.createProgram(),x=f.numMultiviewViews;d.isRawShaderMaterial?(h=[n].filter(Gd).join("\n"),0<h.length&&(h+="\n"),b=[v,n].filter(Gd).join("\n"),0<b.length&&(b+="\n")):(h=[Eh(f),"#define SHADER_NAME "+e.name,n,f.instancing?"#define USE_INSTANCING":"",f.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define GAMMA_FACTOR "+
t,"#define MAX_BONES "+f.maxBones,f.useFog&&f.fog?"#define USE_FOG":"",f.useFog&&f.fogExp2?"#define FOG_EXP2":"",f.map?"#define USE_MAP":"",f.envMap?"#define USE_ENVMAP":"",f.envMap?"#define "+k:"",f.lightMap?"#define USE_LIGHTMAP":"",f.aoMap?"#define USE_AOMAP":"",f.emissiveMap?"#define USE_EMISSIVEMAP":"",f.bumpMap?"#define USE_BUMPMAP":"",f.normalMap?"#define USE_NORMALMAP":"",f.normalMap&&f.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",f.normalMap&&f.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":
"",f.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",f.displacementMap&&f.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",f.specularMap?"#define USE_SPECULARMAP":"",f.roughnessMap?"#define USE_ROUGHNESSMAP":"",f.metalnessMap?"#define USE_METALNESSMAP":"",f.alphaMap?"#define USE_ALPHAMAP":"",f.vertexTangents?"#define USE_TANGENT":"",f.vertexColors?"#define USE_COLOR":"",f.vertexUvs?"#define USE_UV":"",f.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",f.flatShading?"#define FLAT_SHADED":
"",f.skinning?"#define USE_SKINNING":"",f.useVertexTexture?"#define BONE_TEXTURE":"",f.morphTargets?"#define USE_MORPHTARGETS":"",f.morphNormals&&!1===f.flatShading?"#define USE_MORPHNORMALS":"",f.doubleSided?"#define DOUBLE_SIDED":"",f.flipSided?"#define FLIP_SIDED":"",f.shadowMapEnabled?"#define USE_SHADOWMAP":"",f.shadowMapEnabled?"#define "+r:"",f.sizeAttenuation?"#define USE_SIZEATTENUATION":"",f.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",f.logarithmicDepthBuffer&&(f.isWebGL2||b.get("EXT_frag_depth"))?
"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING"," attribute mat4 instanceMatrix;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#ifdef USE_COLOR","\tattribute vec3 color;","#endif","#ifdef USE_MORPHTARGETS",
"\tattribute vec3 morphTarget0;","\tattribute vec3 morphTarget1;","\tattribute vec3 morphTarget2;","\tattribute vec3 morphTarget3;","\t#ifdef USE_MORPHNORMALS","\t\tattribute vec3 morphNormal0;","\t\tattribute vec3 morphNormal1;","\t\tattribute vec3 morphNormal2;","\t\tattribute vec3 morphNormal3;","\t#else","\t\tattribute vec3 morphTarget4;","\t\tattribute vec3 morphTarget5;","\t\tattribute vec3 morphTarget6;","\t\tattribute vec3 morphTarget7;","\t#endif","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;",
"\tattribute vec4 skinWeight;","#endif","\n"].filter(Gd).join("\n"),b=[v,Eh(f),"#define SHADER_NAME "+e.name,n,f.alphaTest?"#define ALPHATEST "+f.alphaTest+(f.alphaTest%1?"":".0"):"","#define GAMMA_FACTOR "+t,f.useFog&&f.fog?"#define USE_FOG":"",f.useFog&&f.fogExp2?"#define FOG_EXP2":"",f.map?"#define USE_MAP":"",f.matcap?"#define USE_MATCAP":"",f.envMap?"#define USE_ENVMAP":"",f.envMap?"#define "+q:"",f.envMap?"#define "+k:"",f.envMap?"#define "+p:"",f.lightMap?"#define USE_LIGHTMAP":"",f.aoMap?
"#define USE_AOMAP":"",f.emissiveMap?"#define USE_EMISSIVEMAP":"",f.bumpMap?"#define USE_BUMPMAP":"",f.normalMap?"#define USE_NORMALMAP":"",f.normalMap&&f.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",f.normalMap&&f.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",f.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",f.specularMap?"#define USE_SPECULARMAP":"",f.roughnessMap?"#define USE_ROUGHNESSMAP":"",f.metalnessMap?"#define USE_METALNESSMAP":"",f.alphaMap?"#define USE_ALPHAMAP":
"",f.sheen?"#define USE_SHEEN":"",f.vertexTangents?"#define USE_TANGENT":"",f.vertexColors?"#define USE_COLOR":"",f.vertexUvs?"#define USE_UV":"",f.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",f.gradientMap?"#define USE_GRADIENTMAP":"",f.flatShading?"#define FLAT_SHADED":"",f.doubleSided?"#define DOUBLE_SIDED":"",f.flipSided?"#define FLIP_SIDED":"",f.shadowMapEnabled?"#define USE_SHADOWMAP":"",f.shadowMapEnabled?"#define "+r:"",f.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",f.physicallyCorrectLights?
"#define PHYSICALLY_CORRECT_LIGHTS":"",f.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",f.logarithmicDepthBuffer&&(f.isWebGL2||b.get("EXT_frag_depth"))?"#define USE_LOGDEPTHBUF_EXT":"",(d.extensions&&d.extensions.shaderTextureLOD||f.envMap)&&(f.isWebGL2||b.get("EXT_shader_texture_lod"))?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",0!==f.toneMapping?"#define TONE_MAPPING":"",0!==f.toneMapping?S.tonemapping_pars_fragment:
"",0!==f.toneMapping?Qj("toneMapping",f.toneMapping):"",f.dithering?"#define DITHERING":"",f.outputEncoding||f.mapEncoding||f.matcapEncoding||f.envMapEncoding||f.emissiveMapEncoding?S.encodings_pars_fragment:"",f.mapEncoding?Ge("mapTexelToLinear",f.mapEncoding):"",f.matcapEncoding?Ge("matcapTexelToLinear",f.matcapEncoding):"",f.envMapEncoding?Ge("envMapTexelToLinear",f.envMapEncoding):"",f.emissiveMapEncoding?Ge("emissiveMapTexelToLinear",f.emissiveMapEncoding):"",f.outputEncoding?Pj("linearToOutputTexel",
f.outputEncoding):"",f.depthPacking?"#define DEPTH_PACKING "+d.depthPacking:"","\n"].filter(Gd).join("\n"));l=l.replace(dg,cg);l=Bh(l,f);l=Ch(l,f);m=m.replace(dg,cg);m=Bh(m,f);m=Ch(m,f);l=l.replace(Fh,Dh);m=m.replace(Fh,Dh);f.isWebGL2&&!d.isRawShaderMaterial&&(r=!1,q=/^\s*#version\s+300\s+es\s*\n/,d.isShaderMaterial&&null!==l.match(q)&&null!==m.match(q)&&(r=!0,l=l.replace(q,""),m=m.replace(q,"")),h="#version 300 es\n\n#define attribute in\n#define varying out\n#define texture2D texture\n"+h,b=["#version 300 es\n\n#define varying in",
r?"":"out highp vec4 pc_fragColor;",r?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth\n#define texture2D texture\n#define textureCube texture\n#define texture2DProj textureProj\n#define texture2DLodEXT textureLod\n#define texture2DProjLodEXT textureProjLod\n#define textureCubeLodEXT textureLod\n#define texture2DGradEXT textureGrad\n#define texture2DProjGradEXT textureProjGrad\n#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+b,0<x&&(h=h.replace("#version 300 es\n",
["#version 300 es\n\n#extension GL_OVR_multiview2 : require","layout(num_views = "+x+") in;","#define VIEW_ID gl_ViewID_OVR"].join("\n")),h=h.replace("uniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform mat4 viewMatrix;\nuniform mat3 normalMatrix;",["uniform mat4 modelViewMatrices["+x+"];","uniform mat4 projectionMatrices["+x+"];","uniform mat4 viewMatrices["+x+"];","uniform mat3 normalMatrices["+x+"];","#define modelViewMatrix modelViewMatrices[VIEW_ID]\n#define projectionMatrix projectionMatrices[VIEW_ID]\n#define viewMatrix viewMatrices[VIEW_ID]\n#define normalMatrix normalMatrices[VIEW_ID]"].join("\n")),
b=b.replace("#version 300 es\n","#version 300 es\n\n#extension GL_OVR_multiview2 : require\n#define VIEW_ID gl_ViewID_OVR"),b=b.replace("uniform mat4 viewMatrix;",["uniform mat4 viewMatrices["+x+"];","#define viewMatrix viewMatrices[VIEW_ID]"].join("\n"))));m=b+m;l=yh(g,35633,h+l);m=yh(g,35632,m);g.attachShader(w,l);g.attachShader(w,m);void 0!==d.index0AttributeName?g.bindAttribLocation(w,0,d.index0AttributeName):!0===f.morphTargets&&g.bindAttribLocation(w,0,"position");g.linkProgram(w);if(a.debug.checkShaderErrors){a=
g.getProgramInfoLog(w).trim();f=g.getShaderInfoLog(l).trim();r=g.getShaderInfoLog(m).trim();k=q=!0;if(!1===g.getProgramParameter(w,35714))q=!1,p=Ah(g,l,"vertex"),t=Ah(g,m,"fragment"),console.error("THREE.WebGLProgram: shader error: ",g.getError(),"35715",g.getProgramParameter(w,35715),"gl.getProgramInfoLog",a,p,t);else if(""!==a)console.warn("THREE.WebGLProgram: gl.getProgramInfoLog()",a);else if(""===f||""===r)k=!1;k&&(this.diagnostics={runnable:q,material:d,programLog:a,vertexShader:{log:f,prefix:h},
fragmentShader:{log:r,prefix:b}})}g.deleteShader(l);g.deleteShader(m);var F;this.getUniforms=function(){void 0===F&&(F=new Cb(g,w));return F};var I;this.getAttributes=function(){if(void 0===I){for(var a={},b=g.getProgramParameter(w,35721),c=0;c<b;c++){var d=g.getActiveAttrib(w,c).name;a[d]=g.getAttribLocation(w,d)}I=a}return I};this.destroy=function(){g.deleteProgram(w);this.program=void 0};this.name=e.name;this.id=Yj++;this.cacheKey=c;this.usedTimes=1;this.program=w;this.vertexShader=l;this.fragmentShader=
m;this.numMultiviewViews=x;return this}function Zj(a,b,c){function d(a,b){if(a)a.isTexture?c=a.encoding:a.isWebGLRenderTarget&&(console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead."),c=a.texture.encoding);else var c=3E3;3E3===c&&b&&(c=3007);return c}var e=[],f=c.isWebGL2,g=c.logarithmicDepthBuffer,h=c.floatVertexTextures,l=c.precision,m=c.maxVertexUniforms,r=c.vertexTextures,q={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",
MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"phong",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"},k="precision isWebGL2 supportsVertexTextures outputEncoding instancing numMultiviewViews map mapEncoding matcap matcapEncoding envMap envMapMode envMapEncoding envMapCubeUV lightMap aoMap emissiveMap emissiveMapEncoding bumpMap normalMap objectSpaceNormalMap tangentSpaceNormalMap clearcoatNormalMap displacementMap specularMap roughnessMap metalnessMap gradientMap alphaMap combine vertexColors vertexTangents vertexUvs uvsVertexOnly fog useFog fogExp2 flatShading sizeAttenuation logarithmicDepthBuffer skinning maxBones useVertexTexture morphTargets morphNormals maxMorphTargets maxMorphNormals premultipliedAlpha numDirLights numPointLights numSpotLights numHemiLights numRectAreaLights numDirLightShadows numPointLightShadows numSpotLightShadows shadowMapEnabled shadowMapType toneMapping physicallyCorrectLights alphaTest doubleSided flipSided numClippingPlanes numClipIntersection depthPacking dithering sheen".split(" ");
this.getParameters=function(b,e,k,u,n,x,F){var t=q[b.type];if(F.isSkinnedMesh){var p=F.skeleton.bones;if(h)p=1024;else{var v=Math.min(Math.floor((m-20)/4),p.length);v<p.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+p.length+" bones. This GPU supports "+v+"."),p=0):p=v}}else p=0;null!==b.precision&&(l=c.getMaxPrecision(b.precision),l!==b.precision&&console.warn("THREE.WebGLProgram.getParameters:",b.precision,"not supported, using",l,"instead."));v=a.getRenderTarget();return{isWebGL2:f,
shaderID:t,precision:l,instancing:!0===F.isInstancedMesh,supportsVertexTextures:r,numMultiviewViews:v&&v.isWebGLMultiviewRenderTarget?v.numViews:0,outputEncoding:d(v?v.texture:null,a.gammaOutput),map:!!b.map,mapEncoding:d(b.map,a.gammaInput),matcap:!!b.matcap,matcapEncoding:d(b.matcap,a.gammaInput),envMap:!!b.envMap,envMapMode:b.envMap&&b.envMap.mapping,envMapEncoding:d(b.envMap,a.gammaInput),envMapCubeUV:!!b.envMap&&(306===b.envMap.mapping||307===b.envMap.mapping),lightMap:!!b.lightMap,aoMap:!!b.aoMap,
emissiveMap:!!b.emissiveMap,emissiveMapEncoding:d(b.emissiveMap,a.gammaInput),bumpMap:!!b.bumpMap,normalMap:!!b.normalMap,objectSpaceNormalMap:1===b.normalMapType,tangentSpaceNormalMap:0===b.normalMapType,clearcoatNormalMap:!!b.clearcoatNormalMap,displacementMap:!!b.displacementMap,roughnessMap:!!b.roughnessMap,metalnessMap:!!b.metalnessMap,specularMap:!!b.specularMap,alphaMap:!!b.alphaMap,gradientMap:!!b.gradientMap,sheen:!!b.sheen,combine:b.combine,vertexTangents:b.normalMap&&b.vertexTangents,vertexColors:b.vertexColors,
vertexUvs:!!b.map||!!b.bumpMap||!!b.normalMap||!!b.specularMap||!!b.alphaMap||!!b.emissiveMap||!!b.roughnessMap||!!b.metalnessMap||!!b.clearcoatNormalMap||!!b.displacementMap,uvsVertexOnly:!(b.map||b.bumpMap||b.normalMap||b.specularMap||b.alphaMap||b.emissiveMap||b.roughnessMap||b.metalnessMap||b.clearcoatNormalMap)&&!!b.displacementMap,fog:!!u,useFog:b.fog,fogExp2:u&&u.isFogExp2,flatShading:b.flatShading,sizeAttenuation:b.sizeAttenuation,logarithmicDepthBuffer:g,skinning:b.skinning&&0<p,maxBones:p,
useVertexTexture:h,morphTargets:b.morphTargets,morphNormals:b.morphNormals,maxMorphTargets:a.maxMorphTargets,maxMorphNormals:a.maxMorphNormals,numDirLights:e.directional.length,numPointLights:e.point.length,numSpotLights:e.spot.length,numRectAreaLights:e.rectArea.length,numHemiLights:e.hemi.length,numDirLightShadows:e.directionalShadowMap.length,numPointLightShadows:e.pointShadowMap.length,numSpotLightShadows:e.spotShadowMap.length,numClippingPlanes:n,numClipIntersection:x,dithering:b.dithering,shadowMapEnabled:a.shadowMap.enabled&&
0<k.length,shadowMapType:a.shadowMap.type,toneMapping:b.toneMapped?a.toneMapping:0,physicallyCorrectLights:a.physicallyCorrectLights,premultipliedAlpha:b.premultipliedAlpha,alphaTest:b.alphaTest,doubleSided:2===b.side,flipSided:1===b.side,depthPacking:void 0!==b.depthPacking?b.depthPacking:!1}};this.getProgramCacheKey=function(b,c){var d=[];c.shaderID?d.push(c.shaderID):(d.push(b.fragmentShader),d.push(b.vertexShader));if(void 0!==b.defines)for(var e in b.defines)d.push(e),d.push(b.defines[e]);for(e=
0;e<k.length;e++)d.push(c[k[e]]);d.push(b.onBeforeCompile.toString());d.push(a.gammaOutput);d.push(a.gammaFactor);return d.join()};this.acquireProgram=function(c,d,f,g){for(var h,l=0,m=e.length;l<m;l++){var r=e[l];if(r.cacheKey===g){h=r;++h.usedTimes;break}}void 0===h&&(h=new Xj(a,b,g,c,d,f),e.push(h));return h};this.releaseProgram=function(a){if(0===--a.usedTimes){var b=e.indexOf(a);e[b]=e[e.length-1];e.pop();a.destroy()}};this.programs=e}function ak(){var a=new WeakMap;return{get:function(b){var c=
a.get(b);void 0===c&&(c={},a.set(b,c));return c},remove:function(b){a.delete(b)},update:function(b,c,d){a.get(b)[c]=d},dispose:function(){a=new WeakMap}}}function bk(a,b){return a.groupOrder!==b.groupOrder?a.groupOrder-b.groupOrder:a.renderOrder!==b.renderOrder?a.renderOrder-b.renderOrder:a.program!==b.program?a.program.id-b.program.id:a.material.id!==b.material.id?a.material.id-b.material.id:a.z!==b.z?a.z-b.z:a.id-b.id}function ck(a,b){return a.groupOrder!==b.groupOrder?a.groupOrder-b.groupOrder:
a.renderOrder!==b.renderOrder?a.renderOrder-b.renderOrder:a.z!==b.z?b.z-a.z:a.id-b.id}function Gh(){function a(a,d,e,m,r,q){var g=b[c];void 0===g?(g={id:a.id,object:a,geometry:d,material:e,program:e.program||f,groupOrder:m,renderOrder:a.renderOrder,z:r,group:q},b[c]=g):(g.id=a.id,g.object=a,g.geometry=d,g.material=e,g.program=e.program||f,g.groupOrder=m,g.renderOrder=a.renderOrder,g.z=r,g.group=q);c++;return g}var b=[],c=0,d=[],e=[],f={id:-1};return{opaque:d,transparent:e,init:function(){c=0;d.length=
0;e.length=0},push:function(b,c,f,m,r,q){b=a(b,c,f,m,r,q);(!0===f.transparent?e:d).push(b)},unshift:function(b,c,f,m,r,q){b=a(b,c,f,m,r,q);(!0===f.transparent?e:d).unshift(b)},sort:function(){1<d.length&&d.sort(bk);1<e.length&&e.sort(ck)}}}function dk(){function a(c){c=c.target;c.removeEventListener("dispose",a);b.delete(c)}var b=new WeakMap;return{get:function(c,d){var e=b.get(c);if(void 0===e){var f=new Gh;b.set(c,new WeakMap);b.get(c).set(d,f);c.addEventListener("dispose",a)}else f=e.get(d),void 0===
f&&(f=new Gh,e.set(d,f));return f},dispose:function(){b=new WeakMap}}}function ek(){var a={};return{get:function(b){if(void 0!==a[b.id])return a[b.id];switch(b.type){case "DirectionalLight":var c={direction:new n,color:new J,shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new B};break;case "SpotLight":c={position:new n,direction:new n,color:new J,distance:0,coneCos:0,penumbraCos:0,decay:0,shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new B};break;case "PointLight":c={position:new n,color:new J,
distance:0,decay:0,shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new B,shadowCameraNear:1,shadowCameraFar:1E3};break;case "HemisphereLight":c={direction:new n,skyColor:new J,groundColor:new J};break;case "RectAreaLight":c={color:new J,position:new n,halfWidth:new n,halfHeight:new n}}return a[b.id]=c}}}function fk(a,b){return(b.castShadow?1:0)-(a.castShadow?1:0)}function gk(){for(var a=new ek,b={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,
numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],point:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[],numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},c=0;9>c;c++)b.probe.push(new n);var d=new n,e=new Q,f=new Q;return{setup:function(c,h,l){for(var g=0,r=0,q=0,k=0;9>k;k++)b.probe[k].set(0,0,0);var p=h=0,t=0,v=0,n=0,w=0,x=
0,F=0;l=l.matrixWorldInverse;c.sort(fk);k=0;for(var I=c.length;k<I;k++){var z=c[k],Ca=z.color,ia=z.intensity,B=z.distance,la=z.shadow&&z.shadow.map?z.shadow.map.texture:null;if(z.isAmbientLight)g+=Ca.r*ia,r+=Ca.g*ia,q+=Ca.b*ia;else if(z.isLightProbe)for(la=0;9>la;la++)b.probe[la].addScaledVector(z.sh.coefficients[la],ia);else if(z.isDirectionalLight){var H=a.get(z);H.color.copy(z.color).multiplyScalar(z.intensity);H.direction.setFromMatrixPosition(z.matrixWorld);d.setFromMatrixPosition(z.target.matrixWorld);
H.direction.sub(d);H.direction.transformDirection(l);if(H.shadow=z.castShadow)ia=z.shadow,H.shadowBias=ia.bias,H.shadowRadius=ia.radius,H.shadowMapSize=ia.mapSize,b.directionalShadowMap[h]=la,b.directionalShadowMatrix[h]=z.shadow.matrix,w++;b.directional[h]=H;h++}else if(z.isSpotLight){H=a.get(z);H.position.setFromMatrixPosition(z.matrixWorld);H.position.applyMatrix4(l);H.color.copy(Ca).multiplyScalar(ia);H.distance=B;H.direction.setFromMatrixPosition(z.matrixWorld);d.setFromMatrixPosition(z.target.matrixWorld);
H.direction.sub(d);H.direction.transformDirection(l);H.coneCos=Math.cos(z.angle);H.penumbraCos=Math.cos(z.angle*(1-z.penumbra));H.decay=z.decay;if(H.shadow=z.castShadow)ia=z.shadow,H.shadowBias=ia.bias,H.shadowRadius=ia.radius,H.shadowMapSize=ia.mapSize,b.spotShadowMap[t]=la,b.spotShadowMatrix[t]=z.shadow.matrix,F++;b.spot[t]=H;t++}else if(z.isRectAreaLight)H=a.get(z),H.color.copy(Ca).multiplyScalar(ia),H.position.setFromMatrixPosition(z.matrixWorld),H.position.applyMatrix4(l),f.identity(),e.copy(z.matrixWorld),
e.premultiply(l),f.extractRotation(e),H.halfWidth.set(.5*z.width,0,0),H.halfHeight.set(0,.5*z.height,0),H.halfWidth.applyMatrix4(f),H.halfHeight.applyMatrix4(f),b.rectArea[v]=H,v++;else if(z.isPointLight){H=a.get(z);H.position.setFromMatrixPosition(z.matrixWorld);H.position.applyMatrix4(l);H.color.copy(z.color).multiplyScalar(z.intensity);H.distance=z.distance;H.decay=z.decay;if(H.shadow=z.castShadow)ia=z.shadow,H.shadowBias=ia.bias,H.shadowRadius=ia.radius,H.shadowMapSize=ia.mapSize,H.shadowCameraNear=
ia.camera.near,H.shadowCameraFar=ia.camera.far,b.pointShadowMap[p]=la,b.pointShadowMatrix[p]=z.shadow.matrix,x++;b.point[p]=H;p++}else z.isHemisphereLight&&(H=a.get(z),H.direction.setFromMatrixPosition(z.matrixWorld),H.direction.transformDirection(l),H.direction.normalize(),H.skyColor.copy(z.color).multiplyScalar(ia),H.groundColor.copy(z.groundColor).multiplyScalar(ia),b.hemi[n]=H,n++)}b.ambient[0]=g;b.ambient[1]=r;b.ambient[2]=q;c=b.hash;if(c.directionalLength!==h||c.pointLength!==p||c.spotLength!==
t||c.rectAreaLength!==v||c.hemiLength!==n||c.numDirectionalShadows!==w||c.numPointShadows!==x||c.numSpotShadows!==F)b.directional.length=h,b.spot.length=t,b.rectArea.length=v,b.point.length=p,b.hemi.length=n,b.directionalShadowMap.length=w,b.pointShadowMap.length=x,b.spotShadowMap.length=F,b.directionalShadowMatrix.length=w,b.pointShadowMatrix.length=x,b.spotShadowMatrix.length=F,c.directionalLength=h,c.pointLength=p,c.spotLength=t,c.rectAreaLength=v,c.hemiLength=n,c.numDirectionalShadows=w,c.numPointShadows=
x,c.numSpotShadows=F,b.version=hk++},state:b}}function Hh(){var a=new gk,b=[],c=[];return{init:function(){b.length=0;c.length=0},state:{lightsArray:b,shadowsArray:c,lights:a},setupLights:function(d){a.setup(b,c,d)},pushLight:function(a){b.push(a)},pushShadow:function(a){c.push(a)}}}function ik(){function a(c){c=c.target;c.removeEventListener("dispose",a);b.delete(c)}var b=new WeakMap;return{get:function(c,d){if(!1===b.has(c)){var e=new Hh;b.set(c,new WeakMap);b.get(c).set(d,e);c.addEventListener("dispose",
a)}else!1===b.get(c).has(d)?(e=new Hh,b.get(c).set(d,e)):e=b.get(c).get(d);return e},dispose:function(){b=new WeakMap}}}function Db(a){O.call(this);this.type="MeshDepthMaterial";this.depthPacking=3200;this.morphTargets=this.skinning=!1;this.displacementMap=this.alphaMap=this.map=null;this.displacementScale=1;this.displacementBias=0;this.wireframe=!1;this.wireframeLinewidth=1;this.fog=!1;this.setValues(a)}function Eb(a){O.call(this);this.type="MeshDistanceMaterial";this.referencePosition=new n;this.nearDistance=
1;this.farDistance=1E3;this.morphTargets=this.skinning=!1;this.displacementMap=this.alphaMap=this.map=null;this.displacementScale=1;this.displacementBias=0;this.fog=!1;this.setValues(a)}function Ih(a,b,c){function d(a,b,c){c=a<<0|b<<1|c<<2;var d=q[c];void 0===d&&(d=new Db({depthPacking:3201,morphTargets:a,skinning:b}),q[c]=d);return d}function e(a,b,c){c=a<<0|b<<1|c<<2;var d=k[c];void 0===d&&(d=new Eb({morphTargets:a,skinning:b}),k[c]=d);return d}function f(b,c,f,g,h,l){var m=b.geometry,r=d,q=b.customDepthMaterial;
!0===f.isPointLight&&(r=e,q=b.customDistanceMaterial);void 0===q?(q=!1,!0===c.morphTargets&&(!0===m.isBufferGeometry?q=m.morphAttributes&&m.morphAttributes.position&&0<m.morphAttributes.position.length:!0===m.isGeometry&&(q=m.morphTargets&&0<m.morphTargets.length)),m=!1,!0===b.isSkinnedMesh&&(!0===c.skinning?m=!0:console.warn("THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:",b)),b=r(q,m,!0===b.isInstancedMesh)):b=q;a.localClippingEnabled&&!0===c.clipShadows&&0!==c.clippingPlanes.length&&
(q=b.uuid,r=c.uuid,m=p[q],void 0===m&&(m={},p[q]=m),q=m[r],void 0===q&&(q=b.clone(),m[r]=q),b=q);b.visible=c.visible;b.wireframe=c.wireframe;b.side=3===l?null!==c.shadowSide?c.shadowSide:c.side:null!==c.shadowSide?c.shadowSide:t[c.side];b.clipShadows=c.clipShadows;b.clippingPlanes=c.clippingPlanes;b.clipIntersection=c.clipIntersection;b.wireframeLinewidth=c.wireframeLinewidth;b.linewidth=c.linewidth;!0===f.isPointLight&&!0===b.isMeshDistanceMaterial&&(b.referencePosition.setFromMatrixPosition(f.matrixWorld),
b.nearDistance=g,b.farDistance=h);return b}function g(c,d,e,l,m){if(!1!==c.visible){if(c.layers.test(d.layers)&&(c.isMesh||c.isLine||c.isPoints)&&(c.castShadow||c.receiveShadow&&3===m)&&(!c.frustumCulled||h.intersectsObject(c))){c.modelViewMatrix.multiplyMatrices(e.matrixWorldInverse,c.matrixWorld);var r=b.update(c),q=c.material;if(Array.isArray(q))for(var k=r.groups,u=0,t=k.length;u<t;u++){var p=k[u],v=q[p.materialIndex];v&&v.visible&&(v=f(c,v,l,e.near,e.far,m),a.renderBufferDirect(e,null,r,v,c,
p))}else q.visible&&(v=f(c,q,l,e.near,e.far,m),a.renderBufferDirect(e,null,r,v,c,null))}c=c.children;r=0;for(q=c.length;r<q;r++)g(c[r],d,e,l,m)}}var h=new Dd,l=new B,m=new B,r=new da,q=[],k=[],p={},t={0:1,1:0,2:2},v=new va({defines:{SAMPLE_RATE:.25,HALF_SAMPLE_RATE:.125},uniforms:{shadow_pass:{value:null},resolution:{value:new B},radius:{value:4}},vertexShader:"void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",fragmentShader:"uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n  float mean = 0.0;\n  float squared_mean = 0.0;\n  \n\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy  ) / resolution ) );\n  for ( float i = -1.0; i < 1.0 ; i += SAMPLE_RATE) {\n    #ifdef HORIZONAL_PASS\n      vec2 distribution = decodeHalfRGBA ( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( i, 0.0 ) * radius ) / resolution ) );\n      mean += distribution.x;\n      squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n    #else\n      float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0,  i )  * radius ) / resolution ) );\n      mean += depth;\n      squared_mean += depth * depth;\n    #endif\n  }\n  mean = mean * HALF_SAMPLE_RATE;\n  squared_mean = squared_mean * HALF_SAMPLE_RATE;\n  float std_dev = pow( squared_mean - mean * mean, 0.5 );\n  gl_FragColor = encodeHalfRGBA( vec2( mean, std_dev ) );\n}"}),
n=v.clone();n.defines.HORIZONAL_PASS=1;var w=new D;w.setAttribute("position",new N(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));var x=new ea(w,v),F=this;this.enabled=!1;this.autoUpdate=!0;this.needsUpdate=!1;this.type=1;this.render=function(d,e,f){if(!1!==F.enabled&&(!1!==F.autoUpdate||!1!==F.needsUpdate)&&0!==d.length){var q=a.getRenderTarget(),k=a.getActiveCubeFace(),u=a.getActiveMipmapLevel(),t=a.state;t.setBlending(0);t.buffers.color.setClear(1,1,1,1);t.buffers.depth.setTest(!0);t.setScissorTest(!1);
for(var p=0,y=d.length;p<y;p++){var w=d[p],z=w.shadow;if(void 0===z)console.warn("THREE.WebGLShadowMap:",w,"has no shadow.");else{l.copy(z.mapSize);var I=z.getFrameExtents();l.multiply(I);m.copy(z.mapSize);if(l.x>c||l.y>c)console.warn("THREE.WebGLShadowMap:",w,"has shadow exceeding max texture size, reducing"),l.x>c&&(m.x=Math.floor(c/I.x),l.x=m.x*I.x,z.mapSize.x=m.x),l.y>c&&(m.y=Math.floor(c/I.y),l.y=m.y*I.y,z.mapSize.y=m.y);null!==z.map||z.isPointLightShadow||3!==this.type||(I={minFilter:1006,magFilter:1006,
format:1023},z.map=new Ba(l.x,l.y,I),z.map.texture.name=w.name+".shadowMap",z.mapPass=new Ba(l.x,l.y,I),z.camera.updateProjectionMatrix());null===z.map&&(I={minFilter:1003,magFilter:1003,format:1023},z.map=new Ba(l.x,l.y,I),z.map.texture.name=w.name+".shadowMap",z.camera.updateProjectionMatrix());a.setRenderTarget(z.map);a.clear();I=z.getViewportCount();for(var Ca=0;Ca<I;Ca++){var B=z.getViewport(Ca);r.set(m.x*B.x,m.y*B.y,m.x*B.z,m.y*B.w);t.viewport(r);z.updateMatrices(w,Ca);h=z.getFrustum();g(e,
f,z.camera,w,this.type)}z.isPointLightShadow||3!==this.type||(w=z,z=f,I=b.update(x),v.uniforms.shadow_pass.value=w.map.texture,v.uniforms.resolution.value=w.mapSize,v.uniforms.radius.value=w.radius,a.setRenderTarget(w.mapPass),a.clear(),a.renderBufferDirect(z,null,I,v,x,null),n.uniforms.shadow_pass.value=w.mapPass.texture,n.uniforms.resolution.value=w.mapSize,n.uniforms.radius.value=w.radius,a.setRenderTarget(w.map),a.clear(),a.renderBufferDirect(z,null,I,n,x,null))}}F.needsUpdate=!1;a.setRenderTarget(q,
k,u)}}}function jk(a,b,c){function d(b,c,d){var e=new Uint8Array(4),f=a.createTexture();a.bindTexture(b,f);a.texParameteri(b,10241,9728);a.texParameteri(b,10240,9728);for(b=0;b<d;b++)a.texImage2D(c+b,0,6408,1,1,0,6408,5121,e);return f}function e(c,d){n[c]=1;0===w[c]&&(a.enableVertexAttribArray(c),w[c]=1);x[c]!==d&&((k?a:b.get("ANGLE_instanced_arrays"))[k?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](c,d),x[c]=d)}function f(b){!0!==F[b]&&(a.enable(b),F[b]=!0)}function g(b){!1!==F[b]&&(a.disable(b),
F[b]=!1)}function h(b,c,d,e,h,l,m,r){if(0===b)z&&(g(3042),z=!1);else if(z||(f(3042),z=!0),5!==b){if(b!==Ca||r!==D){if(100!==B||100!==H)a.blendEquation(32774),H=B=100;if(r)switch(b){case 1:a.blendFuncSeparate(1,771,1,771);break;case 2:a.blendFunc(1,1);break;case 3:a.blendFuncSeparate(0,0,769,771);break;case 4:a.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",b)}else switch(b){case 1:a.blendFuncSeparate(770,771,1,771);break;case 2:a.blendFunc(770,1);
break;case 3:a.blendFunc(0,769);break;case 4:a.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",b)}E=Hd=la=A=null;Ca=b;D=r}}else{h=h||c;l=l||d;m=m||e;if(c!==B||h!==H)a.blendEquationSeparate(Fc[c],Fc[h]),B=c,H=h;if(d!==A||e!==la||l!==Hd||m!==E)a.blendFuncSeparate(M[d],M[e],M[l],M[m]),A=d,la=e,Hd=l,E=m;Ca=b;D=null}}function l(b){J!==b&&(b?a.frontFace(2304):a.frontFace(2305),J=b)}function m(b){0!==b?(f(2884),b!==L&&(1===b?a.cullFace(1029):2===b?a.cullFace(1028):a.cullFace(1032))):
g(2884);L=b}function r(b,c,d){if(b){if(f(32823),G!==c||N!==d)a.polygonOffset(c,d),G=c,N=d}else g(32823)}function q(b){void 0===b&&(b=33984+ha-1);P!==b&&(a.activeTexture(b),P=b)}var k=c.isWebGL2,p=new function(){var b=!1,c=new da,d=null,e=new da(0,0,0,0);return{setMask:function(c){d===c||b||(a.colorMask(c,c,c,c),d=c)},setLocked:function(a){b=a},setClear:function(b,d,f,g,h){!0===h&&(b*=g,d*=g,f*=g);c.set(b,d,f,g);!1===e.equals(c)&&(a.clearColor(b,d,f,g),e.copy(c))},reset:function(){b=!1;d=null;e.set(-1,
0,0,0)}}},t=new function(){var b=!1,c=null,d=null,e=null;return{setTest:function(a){a?f(2929):g(2929)},setMask:function(d){c===d||b||(a.depthMask(d),c=d)},setFunc:function(b){if(d!==b){if(b)switch(b){case 0:a.depthFunc(512);break;case 1:a.depthFunc(519);break;case 2:a.depthFunc(513);break;case 3:a.depthFunc(515);break;case 4:a.depthFunc(514);break;case 5:a.depthFunc(518);break;case 6:a.depthFunc(516);break;case 7:a.depthFunc(517);break;default:a.depthFunc(515)}else a.depthFunc(515);d=b}},setLocked:function(a){b=
a},setClear:function(b){e!==b&&(a.clearDepth(b),e=b)},reset:function(){b=!1;e=d=c=null}}},v=new function(){var b=!1,c=null,d=null,e=null,h=null,l=null,m=null,r=null,q=null;return{setTest:function(a){b||(a?f(2960):g(2960))},setMask:function(d){c===d||b||(a.stencilMask(d),c=d)},setFunc:function(b,c,f){if(d!==b||e!==c||h!==f)a.stencilFunc(b,c,f),d=b,e=c,h=f},setOp:function(b,c,d){if(l!==b||m!==c||r!==d)a.stencilOp(b,c,d),l=b,m=c,r=d},setLocked:function(a){b=a},setClear:function(b){q!==b&&(a.clearStencil(b),
q=b)},reset:function(){b=!1;q=r=m=l=h=e=d=c=null}}};c=a.getParameter(34921);var n=new Uint8Array(c),w=new Uint8Array(c),x=new Uint8Array(c),F={},I=null,z=null,Ca=null,B=null,A=null,la=null,H=null,Hd=null,E=null,D=!1,J=null,L=null,C=null,G=null,N=null,ha=a.getParameter(35661),O=!1;c=0;c=a.getParameter(7938);-1!==c.indexOf("WebGL")?(c=parseFloat(/^WebGL ([0-9])/.exec(c)[1]),O=1<=c):-1!==c.indexOf("OpenGL ES")&&(c=parseFloat(/^OpenGL ES ([0-9])/.exec(c)[1]),O=2<=c);var P=null,Ke={},$b=new da,Jh=new da,
ob={};ob[3553]=d(3553,3553,1);ob[34067]=d(34067,34069,6);p.setClear(0,0,0,1);t.setClear(1);v.setClear(0);f(2929);t.setFunc(3);l(!1);m(1);f(2884);h(0);var Fc={100:32774,101:32778,102:32779};k?(Fc[103]=32775,Fc[104]=32776):(c=b.get("EXT_blend_minmax"),null!==c&&(Fc[103]=c.MIN_EXT,Fc[104]=c.MIN_EXT));var M={200:0,201:1,202:768,204:770,210:776,208:774,206:772,203:769,205:771,209:775,207:773};return{buffers:{color:p,depth:t,stencil:v},initAttributes:function(){for(var a=0,b=n.length;a<b;a++)n[a]=0},enableAttribute:function(a){e(a,
0)},enableAttributeAndDivisor:e,disableUnusedAttributes:function(){for(var b=0,c=w.length;b!==c;++b)w[b]!==n[b]&&(a.disableVertexAttribArray(b),w[b]=0)},enable:f,disable:g,useProgram:function(b){return I!==b?(a.useProgram(b),I=b,!0):!1},setBlending:h,setMaterial:function(a,b){2===a.side?g(2884):f(2884);var c=1===a.side;b&&(c=!c);l(c);1===a.blending&&!1===a.transparent?h(0):h(a.blending,a.blendEquation,a.blendSrc,a.blendDst,a.blendEquationAlpha,a.blendSrcAlpha,a.blendDstAlpha,a.premultipliedAlpha);
t.setFunc(a.depthFunc);t.setTest(a.depthTest);t.setMask(a.depthWrite);p.setMask(a.colorWrite);b=a.stencilWrite;v.setTest(b);b&&(v.setMask(a.stencilWriteMask),v.setFunc(a.stencilFunc,a.stencilRef,a.stencilFuncMask),v.setOp(a.stencilFail,a.stencilZFail,a.stencilZPass));r(a.polygonOffset,a.polygonOffsetFactor,a.polygonOffsetUnits)},setFlipSided:l,setCullFace:m,setLineWidth:function(b){b!==C&&(O&&a.lineWidth(b),C=b)},setPolygonOffset:r,setScissorTest:function(a){a?f(3089):g(3089)},activeTexture:q,bindTexture:function(b,
c){null===P&&q();var d=Ke[P];void 0===d&&(d={type:void 0,texture:void 0},Ke[P]=d);if(d.type!==b||d.texture!==c)a.bindTexture(b,c||ob[b]),d.type=b,d.texture=c},unbindTexture:function(){var b=Ke[P];void 0!==b&&void 0!==b.type&&(a.bindTexture(b.type,null),b.type=void 0,b.texture=void 0)},compressedTexImage2D:function(){try{a.compressedTexImage2D.apply(a,arguments)}catch(W){console.error("THREE.WebGLState:",W)}},texImage2D:function(){try{a.texImage2D.apply(a,arguments)}catch(W){console.error("THREE.WebGLState:",
W)}},texImage3D:function(){try{a.texImage3D.apply(a,arguments)}catch(W){console.error("THREE.WebGLState:",W)}},scissor:function(b){!1===$b.equals(b)&&(a.scissor(b.x,b.y,b.z,b.w),$b.copy(b))},viewport:function(b){!1===Jh.equals(b)&&(a.viewport(b.x,b.y,b.z,b.w),Jh.copy(b))},reset:function(){for(var b=0;b<w.length;b++)1===w[b]&&(a.disableVertexAttribArray(b),w[b]=0);F={};P=null;Ke={};L=J=Ca=I=null;p.reset();t.reset();v.reset()}}}function kk(a,b,c,d,e,f,g){function h(a,b){return C?new OffscreenCanvas(a,
b):document.createElementNS("http://www.w3.org/1999/xhtml","canvas")}function l(a,b,c,d){var e=1;if(a.width>d||a.height>d)e=d/Math.max(a.width,a.height);if(1>e||!0===b){if("undefined"!==typeof HTMLImageElement&&a instanceof HTMLImageElement||"undefined"!==typeof HTMLCanvasElement&&a instanceof HTMLCanvasElement||"undefined"!==typeof ImageBitmap&&a instanceof ImageBitmap)return d=b?P.floorPowerOfTwo:Math.floor,b=d(e*a.width),e=d(e*a.height),void 0===L&&(L=h(b,e)),c=c?h(b,e):L,c.width=b,c.height=e,
c.getContext("2d").drawImage(a,0,0,b,e),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+a.width+"x"+a.height+") to ("+b+"x"+e+")."),c;"data"in a&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+a.width+"x"+a.height+").")}return a}function m(a){return P.isPowerOfTwo(a.width)&&P.isPowerOfTwo(a.height)}function r(a,b){return a.generateMipmaps&&b&&1003!==a.minFilter&&1006!==a.minFilter}function q(b,c,e,f){a.generateMipmap(b);d.get(c).__maxMipLevel=Math.log(Math.max(e,
f))*Math.LOG2E}function k(a,c){if(!1===la)return a;var d=a;6403===a&&(5126===c&&(d=33326),5131===c&&(d=33325),5121===c&&(d=33321));6407===a&&(5126===c&&(d=34837),5131===c&&(d=34843),5121===c&&(d=32849));6408===a&&(5126===c&&(d=34836),5131===c&&(d=34842),5121===c&&(d=32856));33325===d||33326===d||34842===d||34836===d?b.get("EXT_color_buffer_float"):(34843===d||34837===d)&&console.warn("THREE.WebGLRenderer: Floating point textures with RGB format not supported. Please use RGBA instead.");return d}function p(a){return 1003===
a||1004===a||1005===a?9728:9729}function t(b){b=b.target;b.removeEventListener("dispose",t);var c=d.get(b);void 0!==c.__webglInit&&(a.deleteTexture(c.__webglTexture),d.remove(b));b.isVideoTexture&&J.delete(b);g.memory.textures--}function v(b){b=b.target;b.removeEventListener("dispose",v);var c=d.get(b),e=d.get(b.texture);if(b){void 0!==e.__webglTexture&&a.deleteTexture(e.__webglTexture);b.depthTexture&&b.depthTexture.dispose();if(b.isWebGLRenderTargetCube)for(e=0;6>e;e++)a.deleteFramebuffer(c.__webglFramebuffer[e]),
c.__webglDepthbuffer&&a.deleteRenderbuffer(c.__webglDepthbuffer[e]);else a.deleteFramebuffer(c.__webglFramebuffer),c.__webglDepthbuffer&&a.deleteRenderbuffer(c.__webglDepthbuffer);if(b.isWebGLMultiviewRenderTarget){a.deleteTexture(c.__webglColorTexture);a.deleteTexture(c.__webglDepthStencilTexture);g.memory.textures-=2;e=0;for(var f=c.__webglViewFramebuffers.length;e<f;e++)a.deleteFramebuffer(c.__webglViewFramebuffers[e])}d.remove(b.texture);d.remove(b)}g.memory.textures--}function n(a,b){var e=d.get(a);
if(a.isVideoTexture){var f=g.render.frame;J.get(a)!==f&&(J.set(a,f),a.update())}if(0<a.version&&e.__version!==a.version)if(f=a.image,void 0===f)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if(!1===f.complete)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{z(e,a,b);return}c.activeTexture(33984+b);c.bindTexture(3553,e.__webglTexture)}function w(b,e){if(6===b.image.length){var g=d.get(b);if(0<b.version&&g.__version!==
b.version){I(g,b);c.activeTexture(33984+e);c.bindTexture(34067,g.__webglTexture);a.pixelStorei(37440,b.flipY);var h=b&&b.isCompressedTexture;e=b.image[0]&&b.image[0].isDataTexture;for(var t=[],u=0;6>u;u++)t[u]=h||e?e?b.image[u].image:b.image[u]:l(b.image[u],!1,!0,Hd);var p=t[0],v=m(p)||la,n=f.convert(b.format),y=f.convert(b.type),w=k(n,y);F(34067,b,v);if(h){for(u=0;6>u;u++){var z=t[u].mipmaps;for(h=0;h<z.length;h++){var x=z[h];1023!==b.format&&1022!==b.format?null!==n?c.compressedTexImage2D(34069+
u,h,w,x.width,x.height,0,x.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):c.texImage2D(34069+u,h,w,x.width,x.height,0,n,y,x.data)}}g.__maxMipLevel=z.length-1}else{z=b.mipmaps;for(u=0;6>u;u++)if(e)for(c.texImage2D(34069+u,0,w,t[u].width,t[u].height,0,n,y,t[u].data),h=0;h<z.length;h++)x=z[h],x=x.image[u].image,c.texImage2D(34069+u,h+1,w,x.width,x.height,0,n,y,x.data);else for(c.texImage2D(34069+u,0,w,n,y,t[u]),h=0;h<z.length;h++)x=
z[h],c.texImage2D(34069+u,h+1,w,n,y,x.image[u]);g.__maxMipLevel=z.length}r(b,v)&&q(34067,b,p.width,p.height);g.__version=b.version;if(b.onUpdate)b.onUpdate(b)}else c.activeTexture(33984+e),c.bindTexture(34067,g.__webglTexture)}}function x(a,b){c.activeTexture(33984+b);c.bindTexture(34067,d.get(a).__webglTexture)}function F(c,f,g){g?(a.texParameteri(c,10242,N[f.wrapS]),a.texParameteri(c,10243,N[f.wrapT]),32879!==c&&35866!==c||a.texParameteri(c,32882,N[f.wrapR]),a.texParameteri(c,10240,O[f.magFilter]),
a.texParameteri(c,10241,O[f.minFilter])):(a.texParameteri(c,10242,33071),a.texParameteri(c,10243,33071),32879!==c&&35866!==c||a.texParameteri(c,32882,33071),1001===f.wrapS&&1001===f.wrapT||console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),a.texParameteri(c,10240,p(f.magFilter)),a.texParameteri(c,10241,p(f.minFilter)),1003!==f.minFilter&&1006!==f.minFilter&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter."));
!(g=b.get("EXT_texture_filter_anisotropic"))||1015===f.type&&null===b.get("OES_texture_float_linear")||1016===f.type&&null===(la||b.get("OES_texture_half_float_linear"))||!(1<f.anisotropy||d.get(f).__currentAnisotropy)||(a.texParameterf(c,g.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(f.anisotropy,e.getMaxAnisotropy())),d.get(f).__currentAnisotropy=f.anisotropy)}function I(b,c){void 0===b.__webglInit&&(b.__webglInit=!0,c.addEventListener("dispose",t),b.__webglTexture=a.createTexture(),g.memory.textures++)}
function z(b,d,e){var g=3553;d.isDataTexture2DArray&&(g=35866);d.isDataTexture3D&&(g=32879);I(b,d);c.activeTexture(33984+e);c.bindTexture(g,b.__webglTexture);a.pixelStorei(37440,d.flipY);a.pixelStorei(37441,d.premultiplyAlpha);a.pixelStorei(3317,d.unpackAlignment);e=la?!1:1001!==d.wrapS||1001!==d.wrapT||1003!==d.minFilter&&1006!==d.minFilter;e=e&&!1===m(d.image);e=l(d.image,e,!1,E);var h=m(e)||la,u=f.convert(d.format),t=f.convert(d.type),p=k(u,t);F(g,d,h);var v=d.mipmaps;if(d.isDepthTexture){p=6402;
if(1015===d.type){if(!1===la)throw Error("Float Depth Texture only supported in WebGL2.0");p=36012}else la&&(p=33189);1026===d.format&&6402===p&&1012!==d.type&&1014!==d.type&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),d.type=1012,t=f.convert(d.type));1027===d.format&&(p=34041,1020!==d.type&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),d.type=1020,t=f.convert(d.type)));c.texImage2D(3553,
0,p,e.width,e.height,0,u,t,null)}else if(d.isDataTexture)if(0<v.length&&h){for(var n=0,y=v.length;n<y;n++)g=v[n],c.texImage2D(3553,n,p,g.width,g.height,0,u,t,g.data);d.generateMipmaps=!1;b.__maxMipLevel=v.length-1}else c.texImage2D(3553,0,p,e.width,e.height,0,u,t,e.data),b.__maxMipLevel=0;else if(d.isCompressedTexture){n=0;for(y=v.length;n<y;n++)g=v[n],1023!==d.format&&1022!==d.format?null!==u?c.compressedTexImage2D(3553,n,p,g.width,g.height,0,g.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):
c.texImage2D(3553,n,p,g.width,g.height,0,u,t,g.data);b.__maxMipLevel=v.length-1}else if(d.isDataTexture2DArray)c.texImage3D(35866,0,p,e.width,e.height,e.depth,0,u,t,e.data),b.__maxMipLevel=0;else if(d.isDataTexture3D)c.texImage3D(32879,0,p,e.width,e.height,e.depth,0,u,t,e.data),b.__maxMipLevel=0;else if(0<v.length&&h){n=0;for(y=v.length;n<y;n++)g=v[n],c.texImage2D(3553,n,p,u,t,g);d.generateMipmaps=!1;b.__maxMipLevel=v.length-1}else c.texImage2D(3553,0,p,u,t,e),b.__maxMipLevel=0;r(d,h)&&q(3553,d,e.width,
e.height);b.__version=d.version;if(d.onUpdate)d.onUpdate(d)}function B(b,e,g,h){var l=f.convert(e.texture.format),m=f.convert(e.texture.type),r=k(l,m);c.texImage2D(h,0,r,e.width,e.height,0,l,m,null);a.bindFramebuffer(36160,b);a.framebufferTexture2D(36160,g,h,d.get(e.texture).__webglTexture,0);a.bindFramebuffer(36160,null)}function ia(b,c,d){a.bindRenderbuffer(36161,b);if(c.depthBuffer&&!c.stencilBuffer)d?(d=A(c),a.renderbufferStorageMultisample(36161,d,33189,c.width,c.height)):a.renderbufferStorage(36161,
33189,c.width,c.height),a.framebufferRenderbuffer(36160,36096,36161,b);else if(c.depthBuffer&&c.stencilBuffer)d?(d=A(c),a.renderbufferStorageMultisample(36161,d,35056,c.width,c.height)):a.renderbufferStorage(36161,34041,c.width,c.height),a.framebufferRenderbuffer(36160,33306,36161,b);else{b=f.convert(c.texture.format);var e=f.convert(c.texture.type);b=k(b,e);d?(d=A(c),a.renderbufferStorageMultisample(36161,d,b,c.width,c.height)):a.renderbufferStorage(36161,b,c.width,c.height)}a.bindRenderbuffer(36161,
null)}function A(a){return la&&a.isWebGLMultisampleRenderTarget?Math.min(D,a.samples):0}var la=e.isWebGL2,H=e.maxTextures,Hd=e.maxCubemapSize,E=e.maxTextureSize,D=e.maxSamples,J=new WeakMap,L,C="undefined"!==typeof OffscreenCanvas&&null!==(new OffscreenCanvas(1,1)).getContext("2d"),G=0,N={1E3:10497,1001:33071,1002:33648},O={1003:9728,1004:9984,1005:9986,1006:9729,1007:9985,1008:9987},Q=!1,S=!1;this.allocateTextureUnit=function(){var a=G;a>=H&&console.warn("THREE.WebGLTextures: Trying to use "+a+" texture units while this GPU supports only "+
H);G+=1;return a};this.resetTextureUnits=function(){G=0};this.setTexture2D=n;this.setTexture2DArray=function(a,b){var e=d.get(a);0<a.version&&e.__version!==a.version?z(e,a,b):(c.activeTexture(33984+b),c.bindTexture(35866,e.__webglTexture))};this.setTexture3D=function(a,b){var e=d.get(a);0<a.version&&e.__version!==a.version?z(e,a,b):(c.activeTexture(33984+b),c.bindTexture(32879,e.__webglTexture))};this.setTextureCube=w;this.setTextureCubeDynamic=x;this.setupRenderTarget=function(e){var h=d.get(e),
l=d.get(e.texture);e.addEventListener("dispose",v);l.__webglTexture=a.createTexture();g.memory.textures++;var u=!0===e.isWebGLRenderTargetCube,t=!0===e.isWebGLMultisampleRenderTarget,p=!0===e.isWebGLMultiviewRenderTarget,y=m(e)||la;if(u){h.__webglFramebuffer=[];for(var w=0;6>w;w++)h.__webglFramebuffer[w]=a.createFramebuffer()}else if(h.__webglFramebuffer=a.createFramebuffer(),t)if(la){h.__webglMultisampledFramebuffer=a.createFramebuffer();h.__webglColorRenderbuffer=a.createRenderbuffer();a.bindRenderbuffer(36161,
h.__webglColorRenderbuffer);t=f.convert(e.texture.format);var z=f.convert(e.texture.type);t=k(t,z);z=A(e);a.renderbufferStorageMultisample(36161,z,t,e.width,e.height);a.bindFramebuffer(36160,h.__webglMultisampledFramebuffer);a.framebufferRenderbuffer(36160,36064,36161,h.__webglColorRenderbuffer);a.bindRenderbuffer(36161,null);e.depthBuffer&&(h.__webglDepthRenderbuffer=a.createRenderbuffer(),ia(h.__webglDepthRenderbuffer,e,!0));a.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");
else if(p){w=e.width;var x=e.height;t=e.numViews;a.bindFramebuffer(36160,h.__webglFramebuffer);var I=b.get("OVR_multiview2");g.memory.textures+=2;z=a.createTexture();a.bindTexture(35866,z);a.texParameteri(35866,10240,9728);a.texParameteri(35866,10241,9728);a.texImage3D(35866,0,32856,w,x,t,0,6408,5121,null);I.framebufferTextureMultiviewOVR(36160,36064,z,0,0,t);var H=a.createTexture();a.bindTexture(35866,H);a.texParameteri(35866,10240,9728);a.texParameteri(35866,10241,9728);a.texImage3D(35866,0,35056,
w,x,t,0,34041,34042,null);I.framebufferTextureMultiviewOVR(36160,33306,H,0,0,t);x=Array(t);for(w=0;w<t;++w)x[w]=a.createFramebuffer(),a.bindFramebuffer(36160,x[w]),a.framebufferTextureLayer(36160,36064,z,0,w);h.__webglColorTexture=z;h.__webglDepthStencilTexture=H;h.__webglViewFramebuffers=x;a.bindFramebuffer(36160,null);a.bindTexture(35866,null)}if(u){c.bindTexture(34067,l.__webglTexture);F(34067,e.texture,y);for(w=0;6>w;w++)B(h.__webglFramebuffer[w],e,36064,34069+w);r(e.texture,y)&&q(34067,e.texture,
e.width,e.height);c.bindTexture(34067,null)}else p||(c.bindTexture(3553,l.__webglTexture),F(3553,e.texture,y),B(h.__webglFramebuffer,e,36064,3553),r(e.texture,y)&&q(3553,e.texture,e.width,e.height),c.bindTexture(3553,null));if(e.depthBuffer){h=d.get(e);l=!0===e.isWebGLRenderTargetCube;if(e.depthTexture){if(l)throw Error("target.depthTexture not supported in Cube render targets");if(e&&e.isWebGLRenderTargetCube)throw Error("Depth Texture with cube render targets is not supported");a.bindFramebuffer(36160,
h.__webglFramebuffer);if(!e.depthTexture||!e.depthTexture.isDepthTexture)throw Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");d.get(e.depthTexture).__webglTexture&&e.depthTexture.image.width===e.width&&e.depthTexture.image.height===e.height||(e.depthTexture.image.width=e.width,e.depthTexture.image.height=e.height,e.depthTexture.needsUpdate=!0);n(e.depthTexture,0);h=d.get(e.depthTexture).__webglTexture;if(1026===e.depthTexture.format)a.framebufferTexture2D(36160,36096,
3553,h,0);else if(1027===e.depthTexture.format)a.framebufferTexture2D(36160,33306,3553,h,0);else throw Error("Unknown depthTexture format");}else if(l)for(h.__webglDepthbuffer=[],l=0;6>l;l++)a.bindFramebuffer(36160,h.__webglFramebuffer[l]),h.__webglDepthbuffer[l]=a.createRenderbuffer(),ia(h.__webglDepthbuffer[l],e);else a.bindFramebuffer(36160,h.__webglFramebuffer),h.__webglDepthbuffer=a.createRenderbuffer(),ia(h.__webglDepthbuffer,e);a.bindFramebuffer(36160,null)}};this.updateRenderTargetMipmap=
function(a){var b=a.texture,e=m(a)||la;if(r(b,e)){e=a.isWebGLRenderTargetCube?34067:3553;var f=d.get(b).__webglTexture;c.bindTexture(e,f);q(e,b,a.width,a.height);c.bindTexture(e,null)}};this.updateMultisampleRenderTarget=function(b){if(b.isWebGLMultisampleRenderTarget)if(la){var c=d.get(b);a.bindFramebuffer(36008,c.__webglMultisampledFramebuffer);a.bindFramebuffer(36009,c.__webglFramebuffer);c=b.width;var e=b.height,f=16384;b.depthBuffer&&(f|=256);b.stencilBuffer&&(f|=1024);a.blitFramebuffer(0,0,
c,e,0,0,c,e,f,9728)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")};this.safeSetTexture2D=function(a,b){a&&a.isWebGLRenderTarget&&(!1===Q&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),Q=!0),a=a.texture);n(a,b)};this.safeSetTextureCube=function(a,b){a&&a.isWebGLRenderTargetCube&&(!1===S&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),
S=!0),a=a.texture);a&&a.isCubeTexture||Array.isArray(a.image)&&6===a.image.length?w(a,b):x(a,b)}}function Kh(a,b,c){var d=c.isWebGL2;return{convert:function(a){if(1009===a)return 5121;if(1017===a)return 32819;if(1018===a)return 32820;if(1019===a)return 33635;if(1010===a)return 5120;if(1011===a)return 5122;if(1012===a)return 5123;if(1013===a)return 5124;if(1014===a)return 5125;if(1015===a)return 5126;if(1016===a){if(d)return 5131;var c=b.get("OES_texture_half_float");return null!==c?c.HALF_FLOAT_OES:
null}if(1021===a)return 6406;if(1022===a)return 6407;if(1023===a)return 6408;if(1024===a)return 6409;if(1025===a)return 6410;if(1026===a)return 6402;if(1027===a)return 34041;if(1028===a)return 6403;if(33776===a||33777===a||33778===a||33779===a)if(c=b.get("WEBGL_compressed_texture_s3tc"),null!==c){if(33776===a)return c.COMPRESSED_RGB_S3TC_DXT1_EXT;if(33777===a)return c.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(33778===a)return c.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(33779===a)return c.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;
if(35840===a||35841===a||35842===a||35843===a)if(c=b.get("WEBGL_compressed_texture_pvrtc"),null!==c){if(35840===a)return c.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(35841===a)return c.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(35842===a)return c.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(35843===a)return c.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(36196===a)return c=b.get("WEBGL_compressed_texture_etc1"),null!==c?c.COMPRESSED_RGB_ETC1_WEBGL:null;if(37808===a||37809===a||37810===a||37811===a||37812===a||37813===
a||37814===a||37815===a||37816===a||37817===a||37818===a||37819===a||37820===a||37821===a)return c=b.get("WEBGL_compressed_texture_astc"),null!==c?a:null;if(1020===a){if(d)return 34042;c=b.get("WEBGL_depth_texture");return null!==c?c.UNSIGNED_INT_24_8_WEBGL:null}}}}function fg(a,b,c,d){Ba.call(this,a,b,d);this.stencilBuffer=this.depthBuffer=!1;this.numViews=c}function lk(a,b){function c(a){if(a.isArrayCamera)return a.cameras;r[0]=a;return r}function d(a){if(void 0===a.isArrayCamera)return!0;a=a.cameras;
if(a.length>p)return!1;for(var b=1,c=a.length;b<c;b++)if(a[0].viewport.z!==a[b].viewport.z||a[0].viewport.w!==a[b].viewport.w)return!1;return!0}var e=a.extensions,f=a.properties,g,h,l,m,r,q,k,p=0;this.isAvailable=function(){if(void 0===k){var a=e.get("OVR_multiview2");if(k=null!==a&&!1===b.getContextAttributes().antialias)for(p=b.getParameter(a.MAX_VIEWS_OVR),g=new fg(0,0,2),q=new B,m=[],l=[],r=[],a=0;a<p;a++)m[a]=new Q,l[a]=new Z}return k};this.attachCamera=function(b){if(!1!==d(b)){(h=a.getRenderTarget())?
q.set(h.width,h.height):a.getDrawingBufferSize(q);if(b.isArrayCamera){var c=b.cameras[0].viewport;g.setSize(c.z,c.w);g.setNumViews(b.cameras.length)}else g.setSize(q.x,q.y),g.setNumViews(2);a.setRenderTarget(g)}};this.detachCamera=function(c){if(g===a.getRenderTarget()){a.setRenderTarget(h);var d=g,e=d.numViews,l=f.get(d).__webglViewFramebuffers,m=d.width;d=d.height;if(c.isArrayCamera)for(var r=0;r<e;r++){var k=c.cameras[r].viewport,u=k.x,p=k.y,t=u+k.z;k=p+k.w;b.bindFramebuffer(36008,l[r]);b.blitFramebuffer(0,
0,m,d,u,p,t,k,16384,9728)}else b.bindFramebuffer(36008,l[0]),b.blitFramebuffer(0,0,m,d,0,0,q.x,q.y,16384,9728)}};this.updateCameraProjectionMatricesUniform=function(a,d){a=c(a);for(var e=0;e<a.length;e++)m[e].copy(a[e].projectionMatrix);d.setValue(b,"projectionMatrices",m)};this.updateCameraViewMatricesUniform=function(a,d){a=c(a);for(var e=0;e<a.length;e++)m[e].copy(a[e].matrixWorldInverse);d.setValue(b,"viewMatrices",m)};this.updateObjectMatricesUniforms=function(a,d,e){d=c(d);for(var f=0;f<d.length;f++)m[f].multiplyMatrices(d[f].matrixWorldInverse,
a.matrixWorld),l[f].getNormalMatrix(m[f]);e.setValue(b,"modelViewMatrices",m);e.setValue(b,"normalMatrices",l)}}function Gc(){E.call(this);this.type="Group"}function Jd(a){U.call(this);this.cameras=a||[]}function Lh(a,b,c){Mh.setFromMatrixPosition(b.matrixWorld);Nh.setFromMatrixPosition(c.matrixWorld);var d=Mh.distanceTo(Nh),e=b.projectionMatrix.elements,f=c.projectionMatrix.elements,g=e[14]/(e[10]-1);c=e[14]/(e[10]+1);var h=(e[9]+1)/e[5],l=(e[9]-1)/e[5],m=(e[8]-1)/e[0],r=(f[8]+1)/f[0];e=g*m;f=g*
r;r=d/(-m+r);m=r*-m;b.matrixWorld.decompose(a.position,a.quaternion,a.scale);a.translateX(m);a.translateZ(r);a.matrixWorld.compose(a.position,a.quaternion,a.scale);a.matrixWorldInverse.getInverse(a.matrixWorld);b=g+r;g=c+r;a.projectionMatrix.makePerspective(e-m,f+(d-m),h*c/g*b,l*c/g*b,b,g)}function gg(a){function b(){return null!==h&&!0===h.isPresenting}function c(){if(b()){var c=h.getEyeParameters("left");e=2*c.renderWidth*p;f=c.renderHeight*p;Ca=a.getPixelRatio();a.getSize(z);a.setDrawingBufferSize(e,
f,1);x.viewport.set(0,0,e/2,f);F.viewport.set(e/2,0,e/2,f);A.start();g.dispatchEvent({type:"sessionstart"})}else g.enabled&&a.setDrawingBufferSize(z.width,z.height,Ca),A.stop(),g.dispatchEvent({type:"sessionend"})}function d(a,b){null!==b&&4===b.length&&a.set(b[0]*e,b[1]*f,b[2]*e,b[3]*f)}var e,f,g=this,h=null,l=null,m=null,r=[],q=new Q,k=new Q,p=1,t="local-floor";"undefined"!==typeof window&&"VRFrameData"in window&&(l=new window.VRFrameData,window.addEventListener("vrdisplaypresentchange",c,!1));
var v=new Q,y=new wa,w=new n,x=new U;x.viewport=new da;x.layers.enable(1);var F=new U;F.viewport=new da;F.layers.enable(2);var I=new Jd([x,F]);I.layers.enable(1);I.layers.enable(2);var z=new B,Ca,ia=[];this.enabled=!1;this.getController=function(a){var b=r[a];void 0===b&&(b=new Gc,b.matrixAutoUpdate=!1,b.visible=!1,r[a]=b);return b};this.getDevice=function(){return h};this.setDevice=function(a){void 0!==a&&(h=a);A.setContext(a)};this.setFramebufferScaleFactor=function(a){p=a};this.setReferenceSpaceType=
function(a){t=a};this.setPoseTarget=function(a){void 0!==a&&(m=a)};this.getCamera=function(a){var c="local-floor"===t?1.6:0;if(!1===b())return a.position.set(0,c,0),a.rotation.set(0,0,0),a;h.depthNear=a.near;h.depthFar=a.far;h.getFrameData(l);if("local-floor"===t){var e=h.stageParameters;e?q.fromArray(e.sittingToStandingTransform):q.makeTranslation(0,c,0)}c=l.pose;e=null!==m?m:a;e.matrix.copy(q);e.matrix.decompose(e.position,e.quaternion,e.scale);null!==c.orientation&&(y.fromArray(c.orientation),
e.quaternion.multiply(y));null!==c.position&&(y.setFromRotationMatrix(q),w.fromArray(c.position),w.applyQuaternion(y),e.position.add(w));e.updateMatrixWorld();x.near=a.near;F.near=a.near;x.far=a.far;F.far=a.far;x.matrixWorldInverse.fromArray(l.leftViewMatrix);F.matrixWorldInverse.fromArray(l.rightViewMatrix);k.getInverse(q);"local-floor"===t&&(x.matrixWorldInverse.multiply(k),F.matrixWorldInverse.multiply(k));a=e.parent;null!==a&&(v.getInverse(a.matrixWorld),x.matrixWorldInverse.multiply(v),F.matrixWorldInverse.multiply(v));
x.matrixWorld.getInverse(x.matrixWorldInverse);F.matrixWorld.getInverse(F.matrixWorldInverse);x.projectionMatrix.fromArray(l.leftProjectionMatrix);F.projectionMatrix.fromArray(l.rightProjectionMatrix);Lh(I,x,F);a=h.getLayers();a.length&&(a=a[0],d(x.viewport,a.leftBounds),d(F.viewport,a.rightBounds));a:for(a=0;a<r.length;a++){c=r[a];b:{e=a;for(var f=navigator.getGamepads&&navigator.getGamepads(),g=0,u=f.length;g<u;g++){var p=f[g];if(p&&("Daydream Controller"===p.id||"Gear VR Controller"===p.id||"Oculus Go Controller"===
p.id||"OpenVR Gamepad"===p.id||p.id.startsWith("Oculus Touch")||p.id.startsWith("HTC Vive Focus")||p.id.startsWith("Spatial Controller"))){var n=p.hand;if(0===e&&(""===n||"right"===n)||1===e&&"left"===n){e=p;break b}}}e=void 0}if(void 0!==e&&void 0!==e.pose){if(null===e.pose)break a;f=e.pose;!1===f.hasPosition&&c.position.set(.2,-.6,-.05);null!==f.position&&c.position.fromArray(f.position);null!==f.orientation&&c.quaternion.fromArray(f.orientation);c.matrix.compose(c.position,c.quaternion,c.scale);
c.matrix.premultiply(q);c.matrix.decompose(c.position,c.quaternion,c.scale);c.matrixWorldNeedsUpdate=!0;c.visible=!0;f="Daydream Controller"===e.id?0:1;void 0===ia[a]&&(ia[a]=!1);ia[a]!==e.buttons[f].pressed&&(ia[a]=e.buttons[f].pressed,!0===ia[a]?c.dispatchEvent({type:"selectstart"}):(c.dispatchEvent({type:"selectend"}),c.dispatchEvent({type:"select"})))}else c.visible=!1}return I};this.getStandingMatrix=function(){return q};this.isPresenting=b;var A=new ag;this.setAnimationLoop=function(a){A.setAnimationLoop(a);
b()&&A.start()};this.submitFrame=function(){b()&&h.submitFrame()};this.dispose=function(){"undefined"!==typeof window&&window.removeEventListener("vrdisplaypresentchange",c)};this.setFrameOfReferenceType=function(){console.warn("THREE.WebVRManager: setFrameOfReferenceType() has been deprecated.")}}function Oh(a,b){function c(){return null!==m&&null!==r}function d(a){for(var b=0;b<p.length;b++)t[b]===a.inputSource&&p[b].dispatchEvent({type:a.type})}function e(){a.setFramebuffer(null);a.setRenderTarget(a.getRenderTarget());
F.stop();l.dispatchEvent({type:"sessionend"})}function f(a){r=a;F.setContext(m);F.start();l.dispatchEvent({type:"sessionstart"})}function g(){for(var a=0;a<p.length;a++){var b=a;a:{var c=m.inputSources;for(var d=0;d<c.length;d++){var e=c[d],f=e.handedness;if(0===a&&("none"===f||"right"===f)){c=e;break a}if(1===a&&"left"===f){c=e;break a}}c=void 0}t[b]=c}}function h(a,b){null===b?a.matrixWorld.copy(a.matrix):a.matrixWorld.multiplyMatrices(b.matrixWorld,a.matrix);a.matrixWorldInverse.getInverse(a.matrixWorld)}
var l=this,m=null,r=null,q="local-floor",k=null,p=[],t=[],n=new U;n.layers.enable(1);n.viewport=new da;var y=new U;y.layers.enable(2);y.viewport=new da;var w=new Jd([n,y]);w.layers.enable(1);w.layers.enable(2);this.enabled=!1;this.getController=function(a){var b=p[a];void 0===b&&(b=new Gc,b.matrixAutoUpdate=!1,b.visible=!1,p[a]=b);return b};this.setFramebufferScaleFactor=function(){};this.setReferenceSpaceType=function(a){q=a};this.getSession=function(){return m};this.setSession=function(a){m=a;null!==
m&&(m.addEventListener("select",d),m.addEventListener("selectstart",d),m.addEventListener("selectend",d),m.addEventListener("end",e),m.updateRenderState({baseLayer:new XRWebGLLayer(m,b)}),m.requestReferenceSpace(q).then(f),m.addEventListener("inputsourceschange",g),g())};this.getCamera=function(a){if(c()){var b=a.parent,d=w.cameras;h(w,b);for(var e=0;e<d.length;e++)h(d[e],b);a.matrixWorld.copy(w.matrixWorld);a=a.children;e=0;for(b=a.length;e<b;e++)a[e].updateMatrixWorld(!0);Lh(w,n,y);return w}return a};
this.isPresenting=c;var x=null,F=new ag;F.setAnimationLoop(function(b,c){k=c.getViewerPose(r);if(null!==k){var d=k.views,e=m.renderState.baseLayer;a.setFramebuffer(e.framebuffer);for(var f=0;f<d.length;f++){var g=d[f],h=e.getViewport(g),l=w.cameras[f];l.matrix.fromArray(g.transform.inverse.matrix).getInverse(l.matrix);l.projectionMatrix.fromArray(g.projectionMatrix);l.viewport.set(h.x,h.y,h.width,h.height);0===f&&w.matrix.copy(l.matrix)}}for(f=0;f<p.length;f++){d=p[f];if(e=t[f])if(e=c.getPose(e.targetRaySpace,
r),null!==e){d.matrix.fromArray(e.transform.matrix);d.matrix.decompose(d.position,d.rotation,d.scale);d.visible=!0;continue}d.visible=!1}x&&x(b)});this.setAnimationLoop=function(a){x=a};this.dispose=function(){};this.getStandingMatrix=function(){console.warn("THREE.WebXRManager: getStandingMatrix() is no longer needed.");return new Q};this.getDevice=function(){console.warn("THREE.WebXRManager: getDevice() has been deprecated.")};this.setDevice=function(){console.warn("THREE.WebXRManager: setDevice() has been deprecated.")};
this.setFrameOfReferenceType=function(){console.warn("THREE.WebXRManager: setFrameOfReferenceType() has been deprecated.")};this.submitFrame=function(){}}function hg(a){var b;function c(){qa=new bj(K);Fa=new $i(K,qa,a);!1===Fa.isWebGL2&&(qa.get("WEBGL_depth_texture"),qa.get("OES_texture_float"),qa.get("OES_texture_half_float"),qa.get("OES_texture_half_float_linear"),qa.get("OES_standard_derivatives"),qa.get("OES_element_index_uint"),qa.get("ANGLE_instanced_arrays"));qa.get("OES_texture_float_linear");
pa=new Kh(K,qa,Fa);aa=new jk(K,qa,Fa);aa.scissor(ob.copy(U).multiplyScalar(fa).floor());aa.viewport(T.copy(ea).multiplyScalar(fa).floor());ca=new ej(K);Z=new ak;ba=new kk(K,qa,aa,Z,Fa,pa,ca);ra=new Xi(K);xa=new cj(K,ra,ca);sa=new hj(K,xa,ra,ca);ya=new gj(K);oa=new Zj(G,qa,Fa);wa=new dk;va=new ik;ma=new Yi(G,aa,sa,A);Aa=new Zi(K,qa,ca,Fa);Ba=new dj(K,qa,ca,Fa);ca.programs=oa.programs;G.capabilities=Fa;G.extensions=qa;G.properties=Z;G.renderLists=wa;G.state=aa;G.info=ca}function d(a){a.preventDefault();
console.log("THREE.WebGLRenderer: Context Lost.");N=!0}function e(){console.log("THREE.WebGLRenderer: Context Restored.");N=!1;c()}function f(a){a=a.target;a.removeEventListener("dispose",f);g(a);Z.remove(a)}function g(a){var b=Z.get(a).program;a.program=void 0;void 0!==b&&oa.releaseProgram(b)}function h(a,b){a.render(function(a){G.renderBufferImmediate(a,b)})}function l(a,b,c,d){if(!1!==a.visible){if(a.layers.test(b.layers))if(a.isGroup)c=a.renderOrder;else if(a.isLOD)!0===a.autoUpdate&&a.update(b);
else if(a.isLight)C.pushLight(a),a.castShadow&&C.pushShadow(a);else if(a.isSprite){if(!a.frustumCulled||eg.intersectsSprite(a)){d&&Fb.setFromMatrixPosition(a.matrixWorld).applyMatrix4(Id);var e=sa.update(a),f=a.material;f.visible&&H.push(a,e,f,c,Fb.z,null)}}else if(a.isImmediateRenderObject)d&&Fb.setFromMatrixPosition(a.matrixWorld).applyMatrix4(Id),H.push(a,null,a.material,c,Fb.z,null);else if(a.isMesh||a.isLine||a.isPoints)if(a.isSkinnedMesh&&a.skeleton.frame!==ca.render.frame&&(a.skeleton.update(),
a.skeleton.frame=ca.render.frame),!a.frustumCulled||eg.intersectsObject(a))if(d&&Fb.setFromMatrixPosition(a.matrixWorld).applyMatrix4(Id),e=sa.update(a),f=a.material,Array.isArray(f))for(var g=e.groups,h=0,m=g.length;h<m;h++){var r=g[h],q=f[r.materialIndex];q&&q.visible&&H.push(a,e,q,c,Fb.z,r)}else f.visible&&H.push(a,e,f,c,Fb.z,null);a=a.children;h=0;for(m=a.length;h<m;h++)l(a[h],b,c,d)}}function m(a,b,c,d){for(var e=0,f=a.length;e<f;e++){var g=a[e],h=g.object,l=g.geometry,m=void 0===d?g.material:
d;g=g.group;if(c.isArrayCamera)if($b=c,ja.enabled&&ua.isAvailable())r(h,b,c,l,m,g);else for(var q=c.cameras,k=0,p=q.length;k<p;k++){var u=q[k];h.layers.test(u.layers)&&(aa.viewport(T.copy(u.viewport)),C.setupLights(u),r(h,b,u,l,m,g))}else $b=null,r(h,b,c,l,m,g)}}function r(a,c,d,e,f,g){a.onBeforeRender(G,c,d,e,f,g);C=va.get(c,$b||d);a.modelViewMatrix.multiplyMatrices(d.matrixWorldInverse,a.matrixWorld);a.normalMatrix.getNormalMatrix(a.modelViewMatrix);if(a.isImmediateRenderObject){aa.setMaterial(f);
var l=k(d,c.fog,f,a);Je=b=null;Y=!1;h(a,l)}else G.renderBufferDirect(d,c.fog,e,f,a,g);a.onAfterRender(G,c,d,e,f,g);C=va.get(c,$b||d)}function q(a,b,c){var d=Z.get(a),e=C.state.lights,h=e.state.version;c=oa.getParameters(a,e.state,C.state.shadowsArray,b,Pa.numPlanes,Pa.numIntersection,c);var l=oa.getProgramCacheKey(a,c),m=d.program,r=!0;if(void 0===m)a.addEventListener("dispose",f);else if(m.cacheKey!==l)g(a);else{if(d.lightsStateVersion!==h)d.lightsStateVersion=h;else if(void 0!==c.shaderID)return;
r=!1}r&&(c.shaderID?(l=cb[c.shaderID],d.shader={name:a.type,uniforms:Xb(l.uniforms),vertexShader:l.vertexShader,fragmentShader:l.fragmentShader}):d.shader={name:a.type,uniforms:a.uniforms,vertexShader:a.vertexShader,fragmentShader:a.fragmentShader},a.onBeforeCompile(d.shader,G),l=oa.getProgramCacheKey(a,c),m=oa.acquireProgram(a,d.shader,c,l),d.program=m,a.program=m);c=m.getAttributes();if(a.morphTargets)for(l=a.numSupportedMorphTargets=0;l<G.maxMorphTargets;l++)0<=c["morphTarget"+l]&&a.numSupportedMorphTargets++;
if(a.morphNormals)for(l=a.numSupportedMorphNormals=0;l<G.maxMorphNormals;l++)0<=c["morphNormal"+l]&&a.numSupportedMorphNormals++;c=d.shader.uniforms;if(!a.isShaderMaterial&&!a.isRawShaderMaterial||!0===a.clipping)d.numClippingPlanes=Pa.numPlanes,d.numIntersection=Pa.numIntersection,c.clippingPlanes=Pa.uniform;d.fog=b;d.needsLights=a.isMeshLambertMaterial||a.isMeshPhongMaterial||a.isMeshStandardMaterial||a.isShadowMaterial||a.isShaderMaterial&&!0===a.lights;d.lightsStateVersion=h;d.needsLights&&(c.ambientLightColor.value=
e.state.ambient,c.lightProbe.value=e.state.probe,c.directionalLights.value=e.state.directional,c.spotLights.value=e.state.spot,c.rectAreaLights.value=e.state.rectArea,c.pointLights.value=e.state.point,c.hemisphereLights.value=e.state.hemi,c.directionalShadowMap.value=e.state.directionalShadowMap,c.directionalShadowMatrix.value=e.state.directionalShadowMatrix,c.spotShadowMap.value=e.state.spotShadowMap,c.spotShadowMatrix.value=e.state.spotShadowMatrix,c.pointShadowMap.value=e.state.pointShadowMap,
c.pointShadowMatrix.value=e.state.pointShadowMatrix);a=d.program.getUniforms();a=Cb.seqWithValue(a.seq,c);d.uniformsList=a}function k(a,b,c,d){ba.resetTextureUnits();var e=Z.get(c),f=C.state.lights;He&&(ta||a!==X)&&Pa.setState(c.clippingPlanes,c.clipIntersection,c.clipShadows,a,e,a===X&&c.id===ha);!1===c.needsUpdate&&(void 0===e.program?c.needsUpdate=!0:c.fog&&e.fog!==b?c.needsUpdate=!0:e.needsLights&&e.lightsStateVersion!==f.state.version?c.needsUpdate=!0:void 0===e.numClippingPlanes||e.numClippingPlanes===
Pa.numPlanes&&e.numIntersection===Pa.numIntersection||(c.needsUpdate=!0));c.needsUpdate&&(q(c,b,d),c.needsUpdate=!1);var g=!1,h=!1,l=!1;f=e.program;var m=f.getUniforms(),r=e.shader.uniforms;aa.useProgram(f.program)&&(l=h=g=!0);c.id!==ha&&(ha=c.id,h=!0);if(g||X!==a){0<f.numMultiviewViews?ua.updateCameraProjectionMatricesUniform(a,m):m.setValue(K,"projectionMatrix",a.projectionMatrix);Fa.logarithmicDepthBuffer&&m.setValue(K,"logDepthBufFC",2/(Math.log(a.far+1)/Math.LN2));X!==a&&(X=a,l=h=!0);if(c.isShaderMaterial||
c.isMeshPhongMaterial||c.isMeshStandardMaterial||c.envMap)g=m.map.cameraPosition,void 0!==g&&g.setValue(K,Fb.setFromMatrixPosition(a.matrixWorld));(c.isMeshPhongMaterial||c.isMeshLambertMaterial||c.isMeshBasicMaterial||c.isMeshStandardMaterial||c.isShaderMaterial)&&m.setValue(K,"isOrthographic",!0===a.isOrthographicCamera);if(c.isMeshPhongMaterial||c.isMeshLambertMaterial||c.isMeshBasicMaterial||c.isMeshStandardMaterial||c.isShaderMaterial||c.skinning)0<f.numMultiviewViews?ua.updateCameraViewMatricesUniform(a,
m):m.setValue(K,"viewMatrix",a.matrixWorldInverse)}if(c.skinning&&(m.setOptional(K,d,"bindMatrix"),m.setOptional(K,d,"bindMatrixInverse"),g=d.skeleton)){var k=g.bones;if(Fa.floatVertexTextures){if(void 0===g.boneTexture){k=Math.sqrt(4*k.length);k=P.ceilPowerOfTwo(k);k=Math.max(k,4);var u=new Float32Array(k*k*4);u.set(g.boneMatrices);var n=new Yb(u,k,k,1023,1015);g.boneMatrices=u;g.boneTexture=n;g.boneTextureSize=k}m.setValue(K,"boneTexture",g.boneTexture,ba);m.setValue(K,"boneTextureSize",g.boneTextureSize)}else m.setOptional(K,
g,"boneMatrices")}if(h||e.receiveShadow!==d.receiveShadow)e.receiveShadow=d.receiveShadow,m.setValue(K,"receiveShadow",d.receiveShadow);if(h){m.setValue(K,"toneMappingExposure",G.toneMappingExposure);m.setValue(K,"toneMappingWhitePoint",G.toneMappingWhitePoint);e.needsLights&&(h=l,r.ambientLightColor.needsUpdate=h,r.lightProbe.needsUpdate=h,r.directionalLights.needsUpdate=h,r.pointLights.needsUpdate=h,r.spotLights.needsUpdate=h,r.rectAreaLights.needsUpdate=h,r.hemisphereLights.needsUpdate=h);b&&c.fog&&
(r.fogColor.value.copy(b.color),b.isFog?(r.fogNear.value=b.near,r.fogFar.value=b.far):b.isFogExp2&&(r.fogDensity.value=b.density));if(c.isMeshBasicMaterial)p(r,c);else if(c.isMeshLambertMaterial)p(r,c),c.emissiveMap&&(r.emissiveMap.value=c.emissiveMap);else if(c.isMeshPhongMaterial)p(r,c),c.isMeshToonMaterial?(t(r,c),c.gradientMap&&(r.gradientMap.value=c.gradientMap)):t(r,c);else if(c.isMeshStandardMaterial)p(r,c),c.isMeshPhysicalMaterial?(v(r,c),r.reflectivity.value=c.reflectivity,r.clearcoat.value=
c.clearcoat,r.clearcoatRoughness.value=c.clearcoatRoughness,c.sheen&&r.sheen.value.copy(c.sheen),c.clearcoatNormalMap&&(r.clearcoatNormalScale.value.copy(c.clearcoatNormalScale),r.clearcoatNormalMap.value=c.clearcoatNormalMap,1===c.side&&r.clearcoatNormalScale.value.negate()),r.transparency.value=c.transparency):v(r,c);else if(c.isMeshMatcapMaterial)p(r,c),c.matcap&&(r.matcap.value=c.matcap),c.bumpMap&&(r.bumpMap.value=c.bumpMap,r.bumpScale.value=c.bumpScale,1===c.side&&(r.bumpScale.value*=-1)),c.normalMap&&
(r.normalMap.value=c.normalMap,r.normalScale.value.copy(c.normalScale),1===c.side&&r.normalScale.value.negate()),c.displacementMap&&(r.displacementMap.value=c.displacementMap,r.displacementScale.value=c.displacementScale,r.displacementBias.value=c.displacementBias);else if(c.isMeshDepthMaterial)p(r,c),c.displacementMap&&(r.displacementMap.value=c.displacementMap,r.displacementScale.value=c.displacementScale,r.displacementBias.value=c.displacementBias);else if(c.isMeshDistanceMaterial)p(r,c),c.displacementMap&&
(r.displacementMap.value=c.displacementMap,r.displacementScale.value=c.displacementScale,r.displacementBias.value=c.displacementBias),r.referencePosition.value.copy(c.referencePosition),r.nearDistance.value=c.nearDistance,r.farDistance.value=c.farDistance;else if(c.isMeshNormalMaterial)p(r,c),c.bumpMap&&(r.bumpMap.value=c.bumpMap,r.bumpScale.value=c.bumpScale,1===c.side&&(r.bumpScale.value*=-1)),c.normalMap&&(r.normalMap.value=c.normalMap,r.normalScale.value.copy(c.normalScale),1===c.side&&r.normalScale.value.negate()),
c.displacementMap&&(r.displacementMap.value=c.displacementMap,r.displacementScale.value=c.displacementScale,r.displacementBias.value=c.displacementBias);else if(c.isLineBasicMaterial)r.diffuse.value.copy(c.color),r.opacity.value=c.opacity,c.isLineDashedMaterial&&(r.dashSize.value=c.dashSize,r.totalSize.value=c.dashSize+c.gapSize,r.scale.value=c.scale);else if(c.isPointsMaterial){r.diffuse.value.copy(c.color);r.opacity.value=c.opacity;r.size.value=c.size*fa;r.scale.value=.5*W;c.map&&(r.map.value=c.map);
c.alphaMap&&(r.alphaMap.value=c.alphaMap);if(c.map)var y=c.map;else c.alphaMap&&(y=c.alphaMap);void 0!==y&&(!0===y.matrixAutoUpdate&&y.updateMatrix(),r.uvTransform.value.copy(y.matrix))}else if(c.isSpriteMaterial){r.diffuse.value.copy(c.color);r.opacity.value=c.opacity;r.rotation.value=c.rotation;c.map&&(r.map.value=c.map);c.alphaMap&&(r.alphaMap.value=c.alphaMap);if(c.map)var w=c.map;else c.alphaMap&&(w=c.alphaMap);void 0!==w&&(!0===w.matrixAutoUpdate&&w.updateMatrix(),r.uvTransform.value.copy(w.matrix))}else c.isShadowMaterial&&
(r.color.value.copy(c.color),r.opacity.value=c.opacity);void 0!==r.ltc_1&&(r.ltc_1.value=L.LTC_1);void 0!==r.ltc_2&&(r.ltc_2.value=L.LTC_2);Cb.upload(K,e.uniformsList,r,ba);c.isShaderMaterial&&(c.uniformsNeedUpdate=!1)}c.isShaderMaterial&&!0===c.uniformsNeedUpdate&&(Cb.upload(K,e.uniformsList,r,ba),c.uniformsNeedUpdate=!1);c.isSpriteMaterial&&m.setValue(K,"center",d.center);0<f.numMultiviewViews?ua.updateObjectMatricesUniforms(d,a,m):(m.setValue(K,"modelViewMatrix",d.modelViewMatrix),m.setValue(K,
"normalMatrix",d.normalMatrix));m.setValue(K,"modelMatrix",d.matrixWorld);return f}function p(a,b){a.opacity.value=b.opacity;b.color&&a.diffuse.value.copy(b.color);b.emissive&&a.emissive.value.copy(b.emissive).multiplyScalar(b.emissiveIntensity);b.map&&(a.map.value=b.map);b.alphaMap&&(a.alphaMap.value=b.alphaMap);b.specularMap&&(a.specularMap.value=b.specularMap);b.envMap&&(a.envMap.value=b.envMap,a.flipEnvMap.value=b.envMap.isCubeTexture?-1:1,a.reflectivity.value=b.reflectivity,a.refractionRatio.value=
b.refractionRatio,a.maxMipLevel.value=Z.get(b.envMap).__maxMipLevel);b.lightMap&&(a.lightMap.value=b.lightMap,a.lightMapIntensity.value=b.lightMapIntensity);b.aoMap&&(a.aoMap.value=b.aoMap,a.aoMapIntensity.value=b.aoMapIntensity);if(b.map)var c=b.map;else b.specularMap?c=b.specularMap:b.displacementMap?c=b.displacementMap:b.normalMap?c=b.normalMap:b.bumpMap?c=b.bumpMap:b.roughnessMap?c=b.roughnessMap:b.metalnessMap?c=b.metalnessMap:b.alphaMap?c=b.alphaMap:b.emissiveMap&&(c=b.emissiveMap);void 0!==
c&&(c.isWebGLRenderTarget&&(c=c.texture),!0===c.matrixAutoUpdate&&c.updateMatrix(),a.uvTransform.value.copy(c.matrix))}function t(a,b){a.specular.value.copy(b.specular);a.shininess.value=Math.max(b.shininess,1E-4);b.emissiveMap&&(a.emissiveMap.value=b.emissiveMap);b.bumpMap&&(a.bumpMap.value=b.bumpMap,a.bumpScale.value=b.bumpScale,1===b.side&&(a.bumpScale.value*=-1));b.normalMap&&(a.normalMap.value=b.normalMap,a.normalScale.value.copy(b.normalScale),1===b.side&&a.normalScale.value.negate());b.displacementMap&&
(a.displacementMap.value=b.displacementMap,a.displacementScale.value=b.displacementScale,a.displacementBias.value=b.displacementBias)}function v(a,b){a.roughness.value=b.roughness;a.metalness.value=b.metalness;b.roughnessMap&&(a.roughnessMap.value=b.roughnessMap);b.metalnessMap&&(a.metalnessMap.value=b.metalnessMap);b.emissiveMap&&(a.emissiveMap.value=b.emissiveMap);b.bumpMap&&(a.bumpMap.value=b.bumpMap,a.bumpScale.value=b.bumpScale,1===b.side&&(a.bumpScale.value*=-1));b.normalMap&&(a.normalMap.value=
b.normalMap,a.normalScale.value.copy(b.normalScale),1===b.side&&a.normalScale.value.negate());b.displacementMap&&(a.displacementMap.value=b.displacementMap,a.displacementScale.value=b.displacementScale,a.displacementBias.value=b.displacementBias);b.envMap&&(a.envMapIntensity.value=b.envMapIntensity)}a=a||{};var y=void 0!==a.canvas?a.canvas:document.createElementNS("http://www.w3.org/1999/xhtml","canvas"),w=void 0!==a.context?a.context:null,x=void 0!==a.alpha?a.alpha:!1,F=void 0!==a.depth?a.depth:
!0,I=void 0!==a.stencil?a.stencil:!0,z=void 0!==a.antialias?a.antialias:!1,A=void 0!==a.premultipliedAlpha?a.premultipliedAlpha:!0,E=void 0!==a.preserveDrawingBuffer?a.preserveDrawingBuffer:!1,D=void 0!==a.powerPreference?a.powerPreference:"default",J=void 0!==a.failIfMajorPerformanceCaveat?a.failIfMajorPerformanceCaveat:!1,H=null,C=null;this.domElement=y;this.debug={checkShaderErrors:!0};this.sortObjects=this.autoClearStencil=this.autoClearDepth=this.autoClearColor=this.autoClear=!0;this.clippingPlanes=
[];this.localClippingEnabled=!1;this.gammaFactor=2;this.physicallyCorrectLights=this.gammaOutput=this.gammaInput=!1;this.toneMappingWhitePoint=this.toneMappingExposure=this.toneMapping=1;this.maxMorphTargets=8;this.maxMorphNormals=4;var G=this,N=!1,O=null,S=0,V=0,R=null,Ie=null,ha=-1;var Je=b=null;var Y=!1;var X=null,$b=null,T=new da,ob=new da,ka=null,M=y.width,W=y.height,fa=1,ea=new da(0,0,M,W),U=new da(0,0,M,W),na=!1,eg=new Dd,Pa=new aj,He=!1,ta=!1,Id=new Q,Fb=new n;try{x={alpha:x,depth:F,stencil:I,
antialias:z,premultipliedAlpha:A,preserveDrawingBuffer:E,powerPreference:D,failIfMajorPerformanceCaveat:J,xrCompatible:!0};y.addEventListener("webglcontextlost",d,!1);y.addEventListener("webglcontextrestored",e,!1);var K=w||y.getContext("webgl",x)||y.getContext("experimental-webgl",x);if(null===K){if(null!==y.getContext("webgl"))throw Error("Error creating WebGL context with your selected attributes.");throw Error("Error creating WebGL context.");}void 0===K.getShaderPrecisionFormat&&(K.getShaderPrecisionFormat=
function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(Ph){throw console.error("THREE.WebGLRenderer: "+Ph.message),Ph;}var qa,Fa,aa,ca,Z,ba,ra,xa,sa,oa,wa,va,ma,ya,Aa,Ba,pa;c();var ja="undefined"!==typeof navigator&&"xr"in navigator&&"isSessionSupported"in navigator.xr?new Oh(G,K):new gg(G);this.vr=ja;var ua=new lk(G,K),Ea=new Ih(G,sa,Fa.maxTextureSize);this.shadowMap=Ea;this.getContext=function(){return K};this.getContextAttributes=function(){return K.getContextAttributes()};this.forceContextLoss=
function(){var a=qa.get("WEBGL_lose_context");a&&a.loseContext()};this.forceContextRestore=function(){var a=qa.get("WEBGL_lose_context");a&&a.restoreContext()};this.getPixelRatio=function(){return fa};this.setPixelRatio=function(a){void 0!==a&&(fa=a,this.setSize(M,W,!1))};this.getSize=function(a){void 0===a&&(console.warn("WebGLRenderer: .getsize() now requires a Vector2 as an argument"),a=new B);return a.set(M,W)};this.setSize=function(a,b,c){ja.isPresenting()?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):
(M=a,W=b,y.width=Math.floor(a*fa),y.height=Math.floor(b*fa),!1!==c&&(y.style.width=a+"px",y.style.height=b+"px"),this.setViewport(0,0,a,b))};this.getDrawingBufferSize=function(a){void 0===a&&(console.warn("WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument"),a=new B);return a.set(M*fa,W*fa).floor()};this.setDrawingBufferSize=function(a,b,c){M=a;W=b;fa=c;y.width=Math.floor(a*c);y.height=Math.floor(b*c);this.setViewport(0,0,a,b)};this.getCurrentViewport=function(a){void 0===
a&&(console.warn("WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument"),a=new da);return a.copy(T)};this.getViewport=function(a){return a.copy(ea)};this.setViewport=function(a,b,c,d){a.isVector4?ea.set(a.x,a.y,a.z,a.w):ea.set(a,b,c,d);aa.viewport(T.copy(ea).multiplyScalar(fa).floor())};this.getScissor=function(a){return a.copy(U)};this.setScissor=function(a,b,c,d){a.isVector4?U.set(a.x,a.y,a.z,a.w):U.set(a,b,c,d);aa.scissor(ob.copy(U).multiplyScalar(fa).floor())};this.getScissorTest=
function(){return na};this.setScissorTest=function(a){aa.setScissorTest(na=a)};this.getClearColor=function(){return ma.getClearColor()};this.setClearColor=function(){ma.setClearColor.apply(ma,arguments)};this.getClearAlpha=function(){return ma.getClearAlpha()};this.setClearAlpha=function(){ma.setClearAlpha.apply(ma,arguments)};this.clear=function(a,b,c){var d=0;if(void 0===a||a)d|=16384;if(void 0===b||b)d|=256;if(void 0===c||c)d|=1024;K.clear(d)};this.clearColor=function(){this.clear(!0,!1,!1)};this.clearDepth=
function(){this.clear(!1,!0,!1)};this.clearStencil=function(){this.clear(!1,!1,!0)};this.dispose=function(){y.removeEventListener("webglcontextlost",d,!1);y.removeEventListener("webglcontextrestored",e,!1);wa.dispose();va.dispose();Z.dispose();sa.dispose();ja.dispose();za.stop()};this.renderBufferImmediate=function(a,b){aa.initAttributes();var c=Z.get(a);a.hasPositions&&!c.position&&(c.position=K.createBuffer());a.hasNormals&&!c.normal&&(c.normal=K.createBuffer());a.hasUvs&&!c.uv&&(c.uv=K.createBuffer());
a.hasColors&&!c.color&&(c.color=K.createBuffer());b=b.getAttributes();a.hasPositions&&(K.bindBuffer(34962,c.position),K.bufferData(34962,a.positionArray,35048),aa.enableAttribute(b.position),K.vertexAttribPointer(b.position,3,5126,!1,0,0));a.hasNormals&&(K.bindBuffer(34962,c.normal),K.bufferData(34962,a.normalArray,35048),aa.enableAttribute(b.normal),K.vertexAttribPointer(b.normal,3,5126,!1,0,0));a.hasUvs&&(K.bindBuffer(34962,c.uv),K.bufferData(34962,a.uvArray,35048),aa.enableAttribute(b.uv),K.vertexAttribPointer(b.uv,
2,5126,!1,0,0));a.hasColors&&(K.bindBuffer(34962,c.color),K.bufferData(34962,a.colorArray,35048),aa.enableAttribute(b.color),K.vertexAttribPointer(b.color,3,5126,!1,0,0));aa.disableUnusedAttributes();K.drawArrays(4,0,a.count);a.count=0};this.renderBufferDirect=function(a,c,d,e,f,g){var h=f.isMesh&&0>f.matrixWorld.determinant();aa.setMaterial(e,h);var l=k(a,c,e,f),m=!1;if(b!==d.id||Je!==l.id||Y!==(!0===e.wireframe))b=d.id,Je=l.id,Y=!0===e.wireframe,m=!0;f.morphTargetInfluences&&(ya.update(f,d,e,l),
m=!0);h=d.index;var r=d.attributes.position;c=1;!0===e.wireframe&&(h=xa.getWireframeAttribute(d),c=2);a=Aa;if(null!==h){var q=ra.get(h);a=Ba;a.setIndex(q)}if(m){if(!1!==Fa.isWebGL2||!f.isInstancedMesh&&!d.isInstancedBufferGeometry||null!==qa.get("ANGLE_instanced_arrays")){aa.initAttributes();m=d.attributes;l=l.getAttributes();var u=e.defaultAttributeValues;for(I in l){var p=l[I];if(0<=p){var t=m[I];if(void 0!==t){var n=t.normalized,v=t.itemSize,y=ra.get(t);if(void 0!==y){var w=y.buffer,x=y.type;y=
y.bytesPerElement;if(t.isInterleavedBufferAttribute){var z=t.data,F=z.stride;t=t.offset;z&&z.isInstancedInterleavedBuffer?(aa.enableAttributeAndDivisor(p,z.meshPerAttribute),void 0===d.maxInstancedCount&&(d.maxInstancedCount=z.meshPerAttribute*z.count)):aa.enableAttribute(p);K.bindBuffer(34962,w);K.vertexAttribPointer(p,v,x,n,F*y,t*y)}else t.isInstancedBufferAttribute?(aa.enableAttributeAndDivisor(p,t.meshPerAttribute),void 0===d.maxInstancedCount&&(d.maxInstancedCount=t.meshPerAttribute*t.count)):
aa.enableAttribute(p),K.bindBuffer(34962,w),K.vertexAttribPointer(p,v,x,n,0,0)}}else if("instanceMatrix"===I)y=ra.get(f.instanceMatrix),void 0!==y&&(w=y.buffer,x=y.type,aa.enableAttributeAndDivisor(p+0,1),aa.enableAttributeAndDivisor(p+1,1),aa.enableAttributeAndDivisor(p+2,1),aa.enableAttributeAndDivisor(p+3,1),K.bindBuffer(34962,w),K.vertexAttribPointer(p+0,4,x,!1,64,0),K.vertexAttribPointer(p+1,4,x,!1,64,16),K.vertexAttribPointer(p+2,4,x,!1,64,32),K.vertexAttribPointer(p+3,4,x,!1,64,48));else if(void 0!==
u&&(n=u[I],void 0!==n))switch(n.length){case 2:K.vertexAttrib2fv(p,n);break;case 3:K.vertexAttrib3fv(p,n);break;case 4:K.vertexAttrib4fv(p,n);break;default:K.vertexAttrib1fv(p,n)}}}aa.disableUnusedAttributes()}null!==h&&K.bindBuffer(34963,q.buffer)}q=Infinity;null!==h?q=h.count:void 0!==r&&(q=r.count);h=d.drawRange.start*c;r=null!==g?g.start*c:0;var I=Math.max(h,r);g=Math.max(0,Math.min(q,h+d.drawRange.count*c,r+(null!==g?g.count*c:Infinity))-1-I+1);if(0!==g){if(f.isMesh)if(!0===e.wireframe)aa.setLineWidth(e.wireframeLinewidth*
(null===R?fa:1)),a.setMode(1);else switch(f.drawMode){case 0:a.setMode(4);break;case 1:a.setMode(5);break;case 2:a.setMode(6)}else f.isLine?(e=e.linewidth,void 0===e&&(e=1),aa.setLineWidth(e*(null===R?fa:1)),f.isLineSegments?a.setMode(1):f.isLineLoop?a.setMode(2):a.setMode(3)):f.isPoints?a.setMode(0):f.isSprite&&a.setMode(4);f.isInstancedMesh?a.renderInstances(d,I,g,f.count):d.isInstancedBufferGeometry?a.renderInstances(d,I,g,d.maxInstancedCount):a.render(I,g)}};this.compile=function(a,b){C=va.get(a,
b);C.init();a.traverse(function(a){a.isLight&&(C.pushLight(a),a.castShadow&&C.pushShadow(a))});C.setupLights(b);a.traverse(function(b){if(b.material)if(Array.isArray(b.material))for(var c=0;c<b.material.length;c++)q(b.material[c],a.fog,b);else q(b.material,a.fog,b)})};var Da=null,za=new ag;za.setAnimationLoop(function(a){ja.isPresenting()||Da&&Da(a)});"undefined"!==typeof window&&za.setContext(window);this.setAnimationLoop=function(a){Da=a;ja.setAnimationLoop(a);za.start()};this.render=function(a,
c,d,e){if(void 0!==d){console.warn("THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead.");var f=d}if(void 0!==e){console.warn("THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead.");var g=e}c&&c.isCamera?N||(Je=b=null,Y=!1,ha=-1,X=null,!0===a.autoUpdate&&a.updateMatrixWorld(),null===c.parent&&c.updateMatrixWorld(),ja.enabled&&(c=ja.getCamera(c)),C=va.get(a,c),C.init(),a.onBeforeRender(G,a,c,f||R),Id.multiplyMatrices(c.projectionMatrix,
c.matrixWorldInverse),eg.setFromMatrix(Id),ta=this.localClippingEnabled,He=Pa.init(this.clippingPlanes,ta,c),H=wa.get(a,c),H.init(),l(a,c,0,G.sortObjects),!0===G.sortObjects&&H.sort(),He&&Pa.beginShadows(),Ea.render(C.state.shadowsArray,a,c),C.setupLights(c),He&&Pa.endShadows(),this.info.autoReset&&this.info.reset(),void 0!==f&&this.setRenderTarget(f),ja.enabled&&ua.isAvailable()&&ua.attachCamera(c),ma.render(H,a,c,g),d=H.opaque,e=H.transparent,a.overrideMaterial?(f=a.overrideMaterial,d.length&&m(d,
a,c,f),e.length&&m(e,a,c,f)):(d.length&&m(d,a,c),e.length&&m(e,a,c)),a.onAfterRender(G,a,c),null!==R&&(ba.updateRenderTargetMipmap(R),ba.updateMultisampleRenderTarget(R)),aa.buffers.depth.setTest(!0),aa.buffers.depth.setMask(!0),aa.buffers.color.setMask(!0),aa.setPolygonOffset(!1),ja.enabled&&(ua.isAvailable()&&ua.detachCamera(c),ja.submitFrame()),C=H=null):console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.")};this.setFramebuffer=function(a){O!==a&&null===R&&K.bindFramebuffer(36160,
a);O=a};this.getActiveCubeFace=function(){return S};this.getActiveMipmapLevel=function(){return V};this.getRenderTarget=function(){return R};this.setRenderTarget=function(a,b,c){R=a;S=b;V=c;a&&void 0===Z.get(a).__webglFramebuffer&&ba.setupRenderTarget(a);var d=O,e=!1;a?(d=Z.get(a).__webglFramebuffer,a.isWebGLRenderTargetCube?(d=d[b||0],e=!0):d=a.isWebGLMultisampleRenderTarget?Z.get(a).__webglMultisampledFramebuffer:d,T.copy(a.viewport),ob.copy(a.scissor),ka=a.scissorTest):(T.copy(ea).multiplyScalar(fa).floor(),
ob.copy(U).multiplyScalar(fa).floor(),ka=na);Ie!==d&&(K.bindFramebuffer(36160,d),Ie=d);aa.viewport(T);aa.scissor(ob);aa.setScissorTest(ka);e&&(a=Z.get(a.texture),K.framebufferTexture2D(36160,36064,34069+(b||0),a.__webglTexture,c||0))};this.readRenderTargetPixels=function(a,b,c,d,e,f,g){if(a&&a.isWebGLRenderTarget){var h=Z.get(a).__webglFramebuffer;a.isWebGLRenderTargetCube&&void 0!==g&&(h=h[g]);if(h){g=!1;h!==Ie&&(K.bindFramebuffer(36160,h),g=!0);try{var l=a.texture,m=l.format,r=l.type;1023!==m&&
pa.convert(m)!==K.getParameter(35739)?console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format."):1009===r||pa.convert(r)===K.getParameter(35738)||1015===r&&(Fa.isWebGL2||qa.get("OES_texture_float")||qa.get("WEBGL_color_buffer_float"))||1016===r&&(Fa.isWebGL2?qa.get("EXT_color_buffer_float"):qa.get("EXT_color_buffer_half_float"))?36053===K.checkFramebufferStatus(36160)?0<=b&&b<=a.width-d&&0<=c&&c<=a.height-e&&K.readPixels(b,c,d,e,pa.convert(m),
pa.convert(r),f):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete."):console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.")}finally{g&&K.bindFramebuffer(36160,Ie)}}}else console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.")};this.copyFramebufferToTexture=function(a,b,c){void 0===c&&(c=0);var d=Math.pow(2,
-c),e=Math.floor(b.image.width*d);d=Math.floor(b.image.height*d);var f=pa.convert(b.format);ba.setTexture2D(b,0);K.copyTexImage2D(3553,c,f,a.x,a.y,e,d,0);aa.unbindTexture()};this.copyTextureToTexture=function(a,b,c,d){var e=b.image.width,f=b.image.height,g=pa.convert(c.format),h=pa.convert(c.type);ba.setTexture2D(c,0);b.isDataTexture?K.texSubImage2D(3553,d||0,a.x,a.y,e,f,g,h,b.image.data):K.texSubImage2D(3553,d||0,a.x,a.y,g,h,b.image);aa.unbindTexture()};this.initTexture=function(a){ba.setTexture2D(a,
0);aa.unbindTexture()};"undefined"!==typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}function Le(a,b){this.name="";this.color=new J(a);this.density=void 0!==b?b:2.5E-4}function Me(a,b,c){this.name="";this.color=new J(a);this.near=void 0!==b?b:1;this.far=void 0!==c?c:1E3}function pb(a,b){this.array=a;this.stride=b;this.count=void 0!==a?a.length/b:0;this.usage=35044;this.updateRange={offset:0,count:-1};this.version=0}function Kd(a,b,c,d){this.data=
a;this.itemSize=b;this.offset=c;this.normalized=!0===d}function Gb(a){O.call(this);this.type="SpriteMaterial";this.color=new J(16777215);this.alphaMap=this.map=null;this.rotation=0;this.transparent=this.sizeAttenuation=!0;this.setValues(a)}function Ld(a){E.call(this);this.type="Sprite";if(void 0===Hc){Hc=new D;var b=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]);b=new pb(b,5);Hc.setIndex([0,1,2,0,2,3]);Hc.setAttribute("position",new Kd(b,3,0,!1));Hc.setAttribute("uv",new Kd(b,
2,3,!1))}this.geometry=Hc;this.material=void 0!==a?a:new Gb;this.center=new B(.5,.5)}function Ne(a,b,c,d,e,f){Ic.subVectors(a,c).addScalar(.5).multiply(d);void 0!==e?(Md.x=f*Ic.x-e*Ic.y,Md.y=e*Ic.x+f*Ic.y):Md.copy(Ic);a.copy(b);a.x+=Md.x;a.y+=Md.y;a.applyMatrix4(Qh)}function Nd(){E.call(this);this.type="LOD";Object.defineProperties(this,{levels:{enumerable:!0,value:[]}});this.autoUpdate=!0}function Od(a,b){a&&a.isGeometry&&console.error("THREE.SkinnedMesh no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");
ea.call(this,a,b);this.type="SkinnedMesh";this.bindMode="attached";this.bindMatrix=new Q;this.bindMatrixInverse=new Q}function Oe(a,b){a=a||[];this.bones=a.slice(0);this.boneMatrices=new Float32Array(16*this.bones.length);this.frame=-1;if(void 0===b)this.calculateInverses();else if(this.bones.length===b.length)this.boneInverses=b.slice(0);else for(console.warn("THREE.Skeleton boneInverses is the wrong length."),this.boneInverses=[],a=0,b=this.bones.length;a<b;a++)this.boneInverses.push(new Q)}function ig(){E.call(this);
this.type="Bone"}function Pe(a,b,c){ea.call(this,a,b);this.instanceMatrix=new N(new Float32Array(16*c),16);this.count=c}function R(a){O.call(this);this.type="LineBasicMaterial";this.color=new J(16777215);this.linewidth=1;this.linejoin=this.linecap="round";this.setValues(a)}function ra(a,b,c){1===c&&console.error("THREE.Line: parameter THREE.LinePieces no longer supported. Use THREE.LineSegments instead.");E.call(this);this.type="Line";this.geometry=void 0!==a?a:new D;this.material=void 0!==b?b:new R({color:16777215*
Math.random()})}function X(a,b){ra.call(this,a,b);this.type="LineSegments"}function Qe(a,b){ra.call(this,a,b);this.type="LineLoop"}function Qa(a){O.call(this);this.type="PointsMaterial";this.color=new J(16777215);this.alphaMap=this.map=null;this.size=1;this.sizeAttenuation=!0;this.morphTargets=!1;this.setValues(a)}function Jc(a,b){E.call(this);this.type="Points";this.geometry=void 0!==a?a:new D;this.material=void 0!==b?b:new Qa({color:16777215*Math.random()});this.updateMorphTargets()}function jg(a,
b,c,d,e,f,g){var h=kg.distanceSqToPoint(a);h<c&&(c=new n,kg.closestPointToPoint(a,c),c.applyMatrix4(d),a=e.ray.origin.distanceTo(c),a<e.near||a>e.far||f.push({distance:a,distanceToRay:Math.sqrt(h),point:c,index:b,face:null,object:g}))}function lg(a,b,c,d,e,f,g,h,l){Y.call(this,a,b,c,d,e,f,g,h,l);this.format=void 0!==g?g:1022;this.minFilter=void 0!==f?f:1006;this.magFilter=void 0!==e?e:1006;this.generateMipmaps=!1}function Kc(a,b,c,d,e,f,g,h,l,m,r,q){Y.call(this,null,f,g,h,l,m,d,e,r,q);this.image=
{width:b,height:c};this.mipmaps=a;this.generateMipmaps=this.flipY=!1}function Pd(a,b,c,d,e,f,g,h,l){Y.call(this,a,b,c,d,e,f,g,h,l);this.needsUpdate=!0}function Qd(a,b,c,d,e,f,g,h,l,m){m=void 0!==m?m:1026;if(1026!==m&&1027!==m)throw Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===c&&1026===m&&(c=1012);void 0===c&&1027===m&&(c=1020);Y.call(this,null,d,e,f,g,h,m,c,l);this.image={width:a,height:b};this.magFilter=void 0!==g?g:1003;this.minFilter=void 0!==
h?h:1003;this.generateMipmaps=this.flipY=!1}function Lc(a){D.call(this);this.type="WireframeGeometry";var b=[],c,d,e,f=[0,0],g={},h=["a","b","c"];if(a&&a.isGeometry){var l=a.faces;var m=0;for(d=l.length;m<d;m++){var r=l[m];for(c=0;3>c;c++){var q=r[h[c]];var k=r[h[(c+1)%3]];f[0]=Math.min(q,k);f[1]=Math.max(q,k);q=f[0]+","+f[1];void 0===g[q]&&(g[q]={index1:f[0],index2:f[1]})}}for(q in g)m=g[q],h=a.vertices[m.index1],b.push(h.x,h.y,h.z),h=a.vertices[m.index2],b.push(h.x,h.y,h.z)}else if(a&&a.isBufferGeometry)if(h=
new n,null!==a.index){l=a.attributes.position;r=a.index;var p=a.groups;0===p.length&&(p=[{start:0,count:r.count,materialIndex:0}]);a=0;for(e=p.length;a<e;++a)for(m=p[a],c=m.start,d=m.count,m=c,d=c+d;m<d;m+=3)for(c=0;3>c;c++)q=r.getX(m+c),k=r.getX(m+(c+1)%3),f[0]=Math.min(q,k),f[1]=Math.max(q,k),q=f[0]+","+f[1],void 0===g[q]&&(g[q]={index1:f[0],index2:f[1]});for(q in g)m=g[q],h.fromBufferAttribute(l,m.index1),b.push(h.x,h.y,h.z),h.fromBufferAttribute(l,m.index2),b.push(h.x,h.y,h.z)}else for(l=a.attributes.position,
m=0,d=l.count/3;m<d;m++)for(c=0;3>c;c++)g=3*m+c,h.fromBufferAttribute(l,g),b.push(h.x,h.y,h.z),g=3*m+(c+1)%3,h.fromBufferAttribute(l,g),b.push(h.x,h.y,h.z);this.setAttribute("position",new A(b,3))}function Rd(a,b,c){G.call(this);this.type="ParametricGeometry";this.parameters={func:a,slices:b,stacks:c};this.fromBufferGeometry(new Mc(a,b,c));this.mergeVertices()}function Mc(a,b,c){D.call(this);this.type="ParametricBufferGeometry";this.parameters={func:a,slices:b,stacks:c};var d=[],e=[],f=[],g=[],h=
new n,l=new n,m=new n,r=new n,q=new n,k,p;3>a.length&&console.error("THREE.ParametricGeometry: Function must now modify a Vector3 as third parameter.");var t=b+1;for(k=0;k<=c;k++){var v=k/c;for(p=0;p<=b;p++){var y=p/b;a(y,v,l);e.push(l.x,l.y,l.z);0<=y-1E-5?(a(y-1E-5,v,m),r.subVectors(l,m)):(a(y+1E-5,v,m),r.subVectors(m,l));0<=v-1E-5?(a(y,v-1E-5,m),q.subVectors(l,m)):(a(y,v+1E-5,m),q.subVectors(m,l));h.crossVectors(r,q).normalize();f.push(h.x,h.y,h.z);g.push(y,v)}}for(k=0;k<c;k++)for(p=0;p<b;p++)a=
k*t+p+1,h=(k+1)*t+p+1,l=(k+1)*t+p,d.push(k*t+p,a,l),d.push(a,h,l);this.setIndex(d);this.setAttribute("position",new A(e,3));this.setAttribute("normal",new A(f,3));this.setAttribute("uv",new A(g,2))}function Sd(a,b,c,d){G.call(this);this.type="PolyhedronGeometry";this.parameters={vertices:a,indices:b,radius:c,detail:d};this.fromBufferGeometry(new Ea(a,b,c,d));this.mergeVertices()}function Ea(a,b,c,d){function e(a){h.push(a.x,a.y,a.z)}function f(b,c){b*=3;c.x=a[b+0];c.y=a[b+1];c.z=a[b+2]}function g(a,
b,c,d){0>d&&1===a.x&&(l[b]=a.x-1);0===c.x&&0===c.z&&(l[b]=d/2/Math.PI+.5)}D.call(this);this.type="PolyhedronBufferGeometry";this.parameters={vertices:a,indices:b,radius:c,detail:d};c=c||1;d=d||0;var h=[],l=[];(function(a){for(var c=new n,d=new n,g=new n,h=0;h<b.length;h+=3){f(b[h+0],c);f(b[h+1],d);f(b[h+2],g);var l,m,k=c,w=d,x=g,F=Math.pow(2,a),I=[];for(m=0;m<=F;m++){I[m]=[];var z=k.clone().lerp(x,m/F),B=w.clone().lerp(x,m/F),A=F-m;for(l=0;l<=A;l++)I[m][l]=0===l&&m===F?z:z.clone().lerp(B,l/A)}for(m=
0;m<F;m++)for(l=0;l<2*(F-m)-1;l++)k=Math.floor(l/2),0===l%2?(e(I[m][k+1]),e(I[m+1][k]),e(I[m][k])):(e(I[m][k+1]),e(I[m+1][k+1]),e(I[m+1][k]))}})(d);(function(a){for(var b=new n,c=0;c<h.length;c+=3)b.x=h[c+0],b.y=h[c+1],b.z=h[c+2],b.normalize().multiplyScalar(a),h[c+0]=b.x,h[c+1]=b.y,h[c+2]=b.z})(c);(function(){for(var a=new n,b=0;b<h.length;b+=3)a.x=h[b+0],a.y=h[b+1],a.z=h[b+2],l.push(Math.atan2(a.z,-a.x)/2/Math.PI+.5,1-(Math.atan2(-a.y,Math.sqrt(a.x*a.x+a.z*a.z))/Math.PI+.5));a=new n;b=new n;for(var c=
new n,d=new n,e=new B,f=new B,k=new B,y=0,w=0;y<h.length;y+=9,w+=6){a.set(h[y+0],h[y+1],h[y+2]);b.set(h[y+3],h[y+4],h[y+5]);c.set(h[y+6],h[y+7],h[y+8]);e.set(l[w+0],l[w+1]);f.set(l[w+2],l[w+3]);k.set(l[w+4],l[w+5]);d.copy(a).add(b).add(c).divideScalar(3);var x=Math.atan2(d.z,-d.x);g(e,w+0,a,x);g(f,w+2,b,x);g(k,w+4,c,x)}for(a=0;a<l.length;a+=6)b=l[a+0],c=l[a+2],d=l[a+4],e=Math.min(b,c,d),.9<Math.max(b,c,d)&&.1>e&&(.2>b&&(l[a+0]+=1),.2>c&&(l[a+2]+=1),.2>d&&(l[a+4]+=1))})();this.setAttribute("position",
new A(h,3));this.setAttribute("normal",new A(h.slice(),3));this.setAttribute("uv",new A(l,2));0===d?this.computeVertexNormals():this.normalizeNormals()}function Td(a,b){G.call(this);this.type="TetrahedronGeometry";this.parameters={radius:a,detail:b};this.fromBufferGeometry(new Nc(a,b));this.mergeVertices()}function Nc(a,b){Ea.call(this,[1,1,1,-1,-1,1,-1,1,-1,1,-1,-1],[2,1,0,0,3,2,1,3,0,2,3,1],a,b);this.type="TetrahedronBufferGeometry";this.parameters={radius:a,detail:b}}function Ud(a,b){G.call(this);
this.type="OctahedronGeometry";this.parameters={radius:a,detail:b};this.fromBufferGeometry(new ac(a,b));this.mergeVertices()}function ac(a,b){Ea.call(this,[1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1],[0,2,4,0,4,3,0,3,5,0,5,2,1,2,5,1,5,3,1,3,4,1,4,2],a,b);this.type="OctahedronBufferGeometry";this.parameters={radius:a,detail:b}}function Vd(a,b){G.call(this);this.type="IcosahedronGeometry";this.parameters={radius:a,detail:b};this.fromBufferGeometry(new Oc(a,b));this.mergeVertices()}function Oc(a,b){var c=
(1+Math.sqrt(5))/2;Ea.call(this,[-1,c,0,1,c,0,-1,-c,0,1,-c,0,0,-1,c,0,1,c,0,-1,-c,0,1,-c,c,0,-1,c,0,1,-c,0,-1,-c,0,1],[0,11,5,0,5,1,0,1,7,0,7,10,0,10,11,1,5,9,5,11,4,11,10,2,10,7,6,7,1,8,3,9,4,3,4,2,3,2,6,3,6,8,3,8,9,4,9,5,2,4,11,6,2,10,8,6,7,9,8,1],a,b);this.type="IcosahedronBufferGeometry";this.parameters={radius:a,detail:b}}function Wd(a,b){G.call(this);this.type="DodecahedronGeometry";this.parameters={radius:a,detail:b};this.fromBufferGeometry(new Pc(a,b));this.mergeVertices()}function Pc(a,b){var c=
(1+Math.sqrt(5))/2,d=1/c;Ea.call(this,[-1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,0,-d,-c,0,-d,c,0,d,-c,0,d,c,-d,-c,0,-d,c,0,d,-c,0,d,c,0,-c,0,-d,c,0,-d,-c,0,d,c,0,d],[3,11,7,3,7,15,3,15,13,7,19,17,7,17,6,7,6,15,17,4,8,17,8,10,17,10,6,8,0,16,8,16,2,8,2,10,0,12,1,0,1,18,0,18,16,6,10,2,6,2,13,6,13,15,2,16,18,2,18,3,2,3,13,18,1,9,18,9,11,18,11,3,4,14,12,4,12,0,4,0,8,11,9,5,11,5,19,11,19,7,19,5,14,19,14,4,19,4,17,1,12,14,1,14,5,1,5,9],a,b);this.type="DodecahedronBufferGeometry";this.parameters=
{radius:a,detail:b}}function Xd(a,b,c,d,e,f){G.call(this);this.type="TubeGeometry";this.parameters={path:a,tubularSegments:b,radius:c,radialSegments:d,closed:e};void 0!==f&&console.warn("THREE.TubeGeometry: taper has been removed.");a=new bc(a,b,c,d,e);this.tangents=a.tangents;this.normals=a.normals;this.binormals=a.binormals;this.fromBufferGeometry(a);this.mergeVertices()}function bc(a,b,c,d,e){function f(e){r=a.getPointAt(e/b,r);var f=g.normals[e];e=g.binormals[e];for(u=0;u<=d;u++){var m=u/d*Math.PI*
2,k=Math.sin(m);m=-Math.cos(m);l.x=m*f.x+k*e.x;l.y=m*f.y+k*e.y;l.z=m*f.z+k*e.z;l.normalize();t.push(l.x,l.y,l.z);h.x=r.x+c*l.x;h.y=r.y+c*l.y;h.z=r.z+c*l.z;p.push(h.x,h.y,h.z)}}D.call(this);this.type="TubeBufferGeometry";this.parameters={path:a,tubularSegments:b,radius:c,radialSegments:d,closed:e};b=b||64;c=c||1;d=d||8;e=e||!1;var g=a.computeFrenetFrames(b,e);this.tangents=g.tangents;this.normals=g.normals;this.binormals=g.binormals;var h=new n,l=new n,m=new B,r=new n,k,u,p=[],t=[],v=[],y=[];for(k=
0;k<b;k++)f(k);f(!1===e?b:0);for(k=0;k<=b;k++)for(u=0;u<=d;u++)m.x=k/b,m.y=u/d,v.push(m.x,m.y);(function(){for(u=1;u<=b;u++)for(k=1;k<=d;k++){var a=(d+1)*u+(k-1),c=(d+1)*u+k,e=(d+1)*(u-1)+k;y.push((d+1)*(u-1)+(k-1),a,e);y.push(a,c,e)}})();this.setIndex(y);this.setAttribute("position",new A(p,3));this.setAttribute("normal",new A(t,3));this.setAttribute("uv",new A(v,2))}function Yd(a,b,c,d,e,f,g){G.call(this);this.type="TorusKnotGeometry";this.parameters={radius:a,tube:b,tubularSegments:c,radialSegments:d,
p:e,q:f};void 0!==g&&console.warn("THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.");this.fromBufferGeometry(new Qc(a,b,c,d,e,f));this.mergeVertices()}function Qc(a,b,c,d,e,f){function g(a,b,c,d,e){var f=Math.sin(a);b=c/b*a;c=Math.cos(b);e.x=d*(2+c)*.5*Math.cos(a);e.y=d*(2+c)*f*.5;e.z=d*Math.sin(b)*.5}D.call(this);this.type="TorusKnotBufferGeometry";this.parameters={radius:a,tube:b,tubularSegments:c,radialSegments:d,p:e,q:f};a=a||1;b=b||.4;c=Math.floor(c)||
64;d=Math.floor(d)||8;e=e||2;f=f||3;var h=[],l=[],m=[],r=[],k,u=new n,p=new n,t=new n,v=new n,y=new n,w=new n,x=new n;for(k=0;k<=c;++k){var F=k/c*e*Math.PI*2;g(F,e,f,a,t);g(F+.01,e,f,a,v);w.subVectors(v,t);x.addVectors(v,t);y.crossVectors(w,x);x.crossVectors(y,w);y.normalize();x.normalize();for(F=0;F<=d;++F){var I=F/d*Math.PI*2,z=-b*Math.cos(I);I=b*Math.sin(I);u.x=t.x+(z*x.x+I*y.x);u.y=t.y+(z*x.y+I*y.y);u.z=t.z+(z*x.z+I*y.z);l.push(u.x,u.y,u.z);p.subVectors(u,t).normalize();m.push(p.x,p.y,p.z);r.push(k/
c);r.push(F/d)}}for(F=1;F<=c;F++)for(k=1;k<=d;k++)a=(d+1)*F+(k-1),b=(d+1)*F+k,e=(d+1)*(F-1)+k,h.push((d+1)*(F-1)+(k-1),a,e),h.push(a,b,e);this.setIndex(h);this.setAttribute("position",new A(l,3));this.setAttribute("normal",new A(m,3));this.setAttribute("uv",new A(r,2))}function Zd(a,b,c,d,e){G.call(this);this.type="TorusGeometry";this.parameters={radius:a,tube:b,radialSegments:c,tubularSegments:d,arc:e};this.fromBufferGeometry(new Rc(a,b,c,d,e));this.mergeVertices()}function Rc(a,b,c,d,e){D.call(this);
this.type="TorusBufferGeometry";this.parameters={radius:a,tube:b,radialSegments:c,tubularSegments:d,arc:e};a=a||1;b=b||.4;c=Math.floor(c)||8;d=Math.floor(d)||6;e=e||2*Math.PI;var f=[],g=[],h=[],l=[],m=new n,r=new n,k=new n,u,p;for(u=0;u<=c;u++)for(p=0;p<=d;p++){var t=p/d*e,v=u/c*Math.PI*2;r.x=(a+b*Math.cos(v))*Math.cos(t);r.y=(a+b*Math.cos(v))*Math.sin(t);r.z=b*Math.sin(v);g.push(r.x,r.y,r.z);m.x=a*Math.cos(t);m.y=a*Math.sin(t);k.subVectors(r,m).normalize();h.push(k.x,k.y,k.z);l.push(p/d);l.push(u/
c)}for(u=1;u<=c;u++)for(p=1;p<=d;p++)a=(d+1)*(u-1)+p-1,b=(d+1)*(u-1)+p,e=(d+1)*u+p,f.push((d+1)*u+p-1,a,e),f.push(a,b,e);this.setIndex(f);this.setAttribute("position",new A(g,3));this.setAttribute("normal",new A(h,3));this.setAttribute("uv",new A(l,2))}function Rh(a,b,c,d,e){for(var f,g=0,h=b,l=c-d;h<c;h+=d)g+=(a[l]-a[h])*(a[h+1]+a[l+1]),l=h;if(e===0<g)for(e=b;e<c;e+=d)f=Sh(e,a[e],a[e+1],f);else for(e=c-d;e>=b;e-=d)f=Sh(e,a[e],a[e+1],f);f&&cc(f,f.next)&&($d(f),f=f.next);return f}function ae(a,b){if(!a)return a;
b||(b=a);do{var c=!1;if(a.steiner||!cc(a,a.next)&&0!==xa(a.prev,a,a.next))a=a.next;else{$d(a);a=b=a.prev;if(a===a.next)break;c=!0}}while(c||a!==b);return b}function be(a,b,c,d,e,f,g){if(a){if(!g&&f){var h=a,l=h;do null===l.z&&(l.z=mg(l.x,l.y,d,e,f)),l.prevZ=l.prev,l=l.nextZ=l.next;while(l!==h);l.prevZ.nextZ=null;l.prevZ=null;h=l;var m,r,k,u,p=1;do{l=h;var t=h=null;for(r=0;l;){r++;var n=l;for(m=k=0;m<p&&(k++,n=n.nextZ,n);m++);for(u=p;0<k||0<u&&n;)0!==k&&(0===u||!n||l.z<=n.z)?(m=l,l=l.nextZ,k--):(m=
n,n=n.nextZ,u--),t?t.nextZ=m:h=m,m.prevZ=t,t=m;l=n}t.nextZ=null;p*=2}while(1<r)}for(h=a;a.prev!==a.next;){l=a.prev;n=a.next;if(f)t=mk(a,d,e,f);else a:if(t=a,r=t.prev,k=t,p=t.next,0<=xa(r,k,p))t=!1;else{for(m=t.next.next;m!==t.prev;){if(Sc(r.x,r.y,k.x,k.y,p.x,p.y,m.x,m.y)&&0<=xa(m.prev,m,m.next)){t=!1;break a}m=m.next}t=!0}if(t)b.push(l.i/c),b.push(a.i/c),b.push(n.i/c),$d(a),h=a=n.next;else if(a=n,a===h){if(!g)be(ae(a),b,c,d,e,f,1);else if(1===g){g=b;h=c;l=a;do n=l.prev,t=l.next.next,!cc(n,t)&&Th(n,
l,l.next,t)&&ce(n,t)&&ce(t,n)&&(g.push(n.i/h),g.push(l.i/h),g.push(t.i/h),$d(l),$d(l.next),l=a=t),l=l.next;while(l!==a);a=l;be(a,b,c,d,e,f,2)}else if(2===g)a:{g=a;do{for(h=g.next.next;h!==g.prev;){if(l=g.i!==h.i){l=g;n=h;if(t=l.next.i!==n.i&&l.prev.i!==n.i){b:{t=l;do{if(t.i!==l.i&&t.next.i!==l.i&&t.i!==n.i&&t.next.i!==n.i&&Th(t,t.next,l,n)){t=!0;break b}t=t.next}while(t!==l);t=!1}t=!t}if(t=t&&ce(l,n)&&ce(n,l)){t=l;r=!1;k=(l.x+n.x)/2;n=(l.y+n.y)/2;do t.y>n!==t.next.y>n&&t.next.y!==t.y&&k<(t.next.x-
t.x)*(n-t.y)/(t.next.y-t.y)+t.x&&(r=!r),t=t.next;while(t!==l);t=r}l=t}if(l){a=Uh(g,h);g=ae(g,g.next);a=ae(a,a.next);be(g,b,c,d,e,f);be(a,b,c,d,e,f);break a}h=h.next}g=g.next}while(g!==a)}break}}}}function mk(a,b,c,d){var e=a.prev,f=a.next;if(0<=xa(e,a,f))return!1;var g=e.x>a.x?e.x>f.x?e.x:f.x:a.x>f.x?a.x:f.x,h=e.y>a.y?e.y>f.y?e.y:f.y:a.y>f.y?a.y:f.y,l=mg(e.x<a.x?e.x<f.x?e.x:f.x:a.x<f.x?a.x:f.x,e.y<a.y?e.y<f.y?e.y:f.y:a.y<f.y?a.y:f.y,b,c,d);b=mg(g,h,b,c,d);c=a.prevZ;for(d=a.nextZ;c&&c.z>=l&&d&&d.z<=
b;){if(c!==a.prev&&c!==a.next&&Sc(e.x,e.y,a.x,a.y,f.x,f.y,c.x,c.y)&&0<=xa(c.prev,c,c.next))return!1;c=c.prevZ;if(d!==a.prev&&d!==a.next&&Sc(e.x,e.y,a.x,a.y,f.x,f.y,d.x,d.y)&&0<=xa(d.prev,d,d.next))return!1;d=d.nextZ}for(;c&&c.z>=l;){if(c!==a.prev&&c!==a.next&&Sc(e.x,e.y,a.x,a.y,f.x,f.y,c.x,c.y)&&0<=xa(c.prev,c,c.next))return!1;c=c.prevZ}for(;d&&d.z<=b;){if(d!==a.prev&&d!==a.next&&Sc(e.x,e.y,a.x,a.y,f.x,f.y,d.x,d.y)&&0<=xa(d.prev,d,d.next))return!1;d=d.nextZ}return!0}function nk(a,b){return a.x-b.x}
function ok(a,b){var c=b,d=a.x,e=a.y,f=-Infinity;do{if(e<=c.y&&e>=c.next.y&&c.next.y!==c.y){var g=c.x+(e-c.y)*(c.next.x-c.x)/(c.next.y-c.y);if(g<=d&&g>f){f=g;if(g===d){if(e===c.y)return c;if(e===c.next.y)return c.next}var h=c.x<c.next.x?c:c.next}}c=c.next}while(c!==b);if(!h)return null;if(d===f)return h.prev;b=h;g=h.x;var l=h.y,m=Infinity;for(c=h.next;c!==b;){if(d>=c.x&&c.x>=g&&d!==c.x&&Sc(e<l?d:f,e,g,l,e<l?f:d,e,c.x,c.y)){var r=Math.abs(e-c.y)/(d-c.x);(r<m||r===m&&c.x>h.x)&&ce(c,a)&&(h=c,m=r)}c=
c.next}return h}function mg(a,b,c,d,e){a=32767*(a-c)*e;b=32767*(b-d)*e;a=(a|a<<8)&16711935;a=(a|a<<4)&252645135;a=(a|a<<2)&858993459;b=(b|b<<8)&16711935;b=(b|b<<4)&252645135;b=(b|b<<2)&858993459;return(a|a<<1)&1431655765|((b|b<<1)&1431655765)<<1}function pk(a){var b=a,c=a;do{if(b.x<c.x||b.x===c.x&&b.y<c.y)c=b;b=b.next}while(b!==a);return c}function Sc(a,b,c,d,e,f,g,h){return 0<=(e-g)*(b-h)-(a-g)*(f-h)&&0<=(a-g)*(d-h)-(c-g)*(b-h)&&0<=(c-g)*(f-h)-(e-g)*(d-h)}function xa(a,b,c){return(b.y-a.y)*(c.x-
b.x)-(b.x-a.x)*(c.y-b.y)}function cc(a,b){return a.x===b.x&&a.y===b.y}function Th(a,b,c,d){return cc(a,c)&&cc(b,d)||cc(a,d)&&cc(c,b)?!0:0<xa(a,b,c)!==0<xa(a,b,d)&&0<xa(c,d,a)!==0<xa(c,d,b)}function ce(a,b){return 0>xa(a.prev,a,a.next)?0<=xa(a,b,a.next)&&0<=xa(a,a.prev,b):0>xa(a,b,a.prev)||0>xa(a,a.next,b)}function Uh(a,b){var c=new ng(a.i,a.x,a.y),d=new ng(b.i,b.x,b.y),e=a.next,f=b.prev;a.next=b;b.prev=a;c.next=e;e.prev=c;d.next=c;c.prev=d;f.next=d;d.prev=f;return d}function Sh(a,b,c,d){a=new ng(a,
b,c);d?(a.next=d.next,a.prev=d,d.next.prev=a,d.next=a):(a.prev=a,a.next=a);return a}function $d(a){a.next.prev=a.prev;a.prev.next=a.next;a.prevZ&&(a.prevZ.nextZ=a.nextZ);a.nextZ&&(a.nextZ.prevZ=a.prevZ)}function ng(a,b,c){this.i=a;this.x=b;this.y=c;this.nextZ=this.prevZ=this.z=this.next=this.prev=null;this.steiner=!1}function Vh(a){var b=a.length;2<b&&a[b-1].equals(a[0])&&a.pop()}function Wh(a,b){for(var c=0;c<b.length;c++)a.push(b[c].x),a.push(b[c].y)}function dc(a,b){G.call(this);this.type="ExtrudeGeometry";
this.parameters={shapes:a,options:b};this.fromBufferGeometry(new db(a,b));this.mergeVertices()}function db(a,b){function c(a){function c(a,b,c){b||console.error("THREE.ExtrudeGeometry: vec does not exist");return b.clone().multiplyScalar(c).add(a)}function g(a,b,c){var d=a.x-b.x;var e=a.y-b.y;var f=c.x-a.x;var g=c.y-a.y,h=d*d+e*e;if(Math.abs(d*g-e*f)>Number.EPSILON){var l=Math.sqrt(h),m=Math.sqrt(f*f+g*g);h=b.x-e/l;b=b.y+d/l;g=((c.x-g/m-h)*g-(c.y+f/m-b)*f)/(d*g-e*f);f=h+d*g-a.x;d=b+e*g-a.y;e=f*f+
d*d;if(2>=e)return new B(f,d);e=Math.sqrt(e/2)}else a=!1,d>Number.EPSILON?f>Number.EPSILON&&(a=!0):d<-Number.EPSILON?f<-Number.EPSILON&&(a=!0):Math.sign(e)===Math.sign(g)&&(a=!0),a?(f=-e,e=Math.sqrt(h)):(f=d,d=e,e=Math.sqrt(h/2));return new B(f/e,d/e)}function h(a,b){for(M=a.length;0<=--M;){var c=M;var f=M-1;0>f&&(f=a.length-1);var g,h=x+2*E;for(g=0;g<h;g++){var l=Y*g,m=Y*(g+1),r=b+f+l,k=b+f+m;m=b+c+m;t(b+c+l);t(r);t(m);t(r);t(k);t(m);l=e.length/3;l=H.generateSideWallUV(d,e,l-6,l-3,l-2,l-1);v(l[0]);
v(l[1]);v(l[3]);v(l[1]);v(l[2]);v(l[3])}}}function l(a,b,c){y.push(a);y.push(b);y.push(c)}function k(a,b,c){t(a);t(b);t(c);a=e.length/3;a=H.generateTopUV(d,e,a-3,a-2,a-1);v(a[0]);v(a[1]);v(a[2])}function t(a){e.push(y[3*a]);e.push(y[3*a+1]);e.push(y[3*a+2])}function v(a){f.push(a.x);f.push(a.y)}var y=[],w=void 0!==b.curveSegments?b.curveSegments:12,x=void 0!==b.steps?b.steps:1,F=void 0!==b.depth?b.depth:100,I=void 0!==b.bevelEnabled?b.bevelEnabled:!0,z=void 0!==b.bevelThickness?b.bevelThickness:6,
A=void 0!==b.bevelSize?b.bevelSize:z-2,G=void 0!==b.bevelOffset?b.bevelOffset:0,E=void 0!==b.bevelSegments?b.bevelSegments:3,C=b.extrudePath,H=void 0!==b.UVGenerator?b.UVGenerator:qk;void 0!==b.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),F=b.amount);var D=!1;if(C){var J=C.getSpacedPoints(x);D=!0;I=!1;var L=C.computeFrenetFrames(x,!1);var N=new n;var O=new n;var P=new n}I||(G=A=z=E=0);var Q;w=a.extractPoints(w);a=w.shape;var S=w.holes;if(!qb.isClockWise(a)){a=
a.reverse();var ha=0;for(Q=S.length;ha<Q;ha++){var R=S[ha];qb.isClockWise(R)&&(S[ha]=R.reverse())}}var Z=qb.triangulateShape(a,S),X=a;ha=0;for(Q=S.length;ha<Q;ha++)R=S[ha],a=a.concat(R);var T,Y=a.length,V,ca=Z.length;w=[];var M=0;var W=X.length;var fa=W-1;for(T=M+1;M<W;M++,fa++,T++)fa===W&&(fa=0),T===W&&(T=0),w[M]=g(X[M],X[fa],X[T]);C=[];var da=w.concat();ha=0;for(Q=S.length;ha<Q;ha++){R=S[ha];var ba=[];M=0;W=R.length;fa=W-1;for(T=M+1;M<W;M++,fa++,T++)fa===W&&(fa=0),T===W&&(T=0),ba[M]=g(R[M],R[fa],
R[T]);C.push(ba);da=da.concat(ba)}for(fa=0;fa<E;fa++){W=fa/E;var ea=z*Math.cos(W*Math.PI/2);T=A*Math.sin(W*Math.PI/2)+G;M=0;for(W=X.length;M<W;M++){var U=c(X[M],w[M],T);l(U.x,U.y,-ea)}ha=0;for(Q=S.length;ha<Q;ha++)for(R=S[ha],ba=C[ha],M=0,W=R.length;M<W;M++)U=c(R[M],ba[M],T),l(U.x,U.y,-ea)}T=A+G;for(M=0;M<Y;M++)U=I?c(a[M],da[M],T):a[M],D?(O.copy(L.normals[0]).multiplyScalar(U.x),N.copy(L.binormals[0]).multiplyScalar(U.y),P.copy(J[0]).add(O).add(N),l(P.x,P.y,P.z)):l(U.x,U.y,0);for(W=1;W<=x;W++)for(M=
0;M<Y;M++)U=I?c(a[M],da[M],T):a[M],D?(O.copy(L.normals[W]).multiplyScalar(U.x),N.copy(L.binormals[W]).multiplyScalar(U.y),P.copy(J[W]).add(O).add(N),l(P.x,P.y,P.z)):l(U.x,U.y,F/x*W);for(fa=E-1;0<=fa;fa--){W=fa/E;ea=z*Math.cos(W*Math.PI/2);T=A*Math.sin(W*Math.PI/2)+G;M=0;for(W=X.length;M<W;M++)U=c(X[M],w[M],T),l(U.x,U.y,F+ea);ha=0;for(Q=S.length;ha<Q;ha++)for(R=S[ha],ba=C[ha],M=0,W=R.length;M<W;M++)U=c(R[M],ba[M],T),D?l(U.x,U.y+J[x-1].y,J[x-1].x+ea):l(U.x,U.y,F+ea)}(function(){var a=e.length/3;if(I){var b=
0*Y;for(M=0;M<ca;M++)V=Z[M],k(V[2]+b,V[1]+b,V[0]+b);b=Y*(x+2*E);for(M=0;M<ca;M++)V=Z[M],k(V[0]+b,V[1]+b,V[2]+b)}else{for(M=0;M<ca;M++)V=Z[M],k(V[2],V[1],V[0]);for(M=0;M<ca;M++)V=Z[M],k(V[0]+Y*x,V[1]+Y*x,V[2]+Y*x)}d.addGroup(a,e.length/3-a,0)})();(function(){var a=e.length/3,b=0;h(X,b);b+=X.length;ha=0;for(Q=S.length;ha<Q;ha++)R=S[ha],h(R,b),b+=R.length;d.addGroup(a,e.length/3-a,1)})()}D.call(this);this.type="ExtrudeBufferGeometry";this.parameters={shapes:a,options:b};a=Array.isArray(a)?a:[a];for(var d=
this,e=[],f=[],g=0,h=a.length;g<h;g++)c(a[g]);this.setAttribute("position",new A(e,3));this.setAttribute("uv",new A(f,2));this.computeVertexNormals()}function Xh(a,b,c){c.shapes=[];if(Array.isArray(a))for(var d=0,e=a.length;d<e;d++)c.shapes.push(a[d].uuid);else c.shapes.push(a.uuid);void 0!==b.extrudePath&&(c.options.extrudePath=b.extrudePath.toJSON());return c}function de(a,b){G.call(this);this.type="TextGeometry";this.parameters={text:a,parameters:b};this.fromBufferGeometry(new Tc(a,b));this.mergeVertices()}
function Tc(a,b){b=b||{};var c=b.font;if(!c||!c.isFont)return console.error("THREE.TextGeometry: font parameter is not an instance of THREE.Font."),new G;a=c.generateShapes(a,b.size);b.depth=void 0!==b.height?b.height:50;void 0===b.bevelThickness&&(b.bevelThickness=10);void 0===b.bevelSize&&(b.bevelSize=8);void 0===b.bevelEnabled&&(b.bevelEnabled=!1);db.call(this,a,b);this.type="TextBufferGeometry"}function ee(a,b,c,d,e,f,g){G.call(this);this.type="SphereGeometry";this.parameters={radius:a,widthSegments:b,
heightSegments:c,phiStart:d,phiLength:e,thetaStart:f,thetaLength:g};this.fromBufferGeometry(new Hb(a,b,c,d,e,f,g));this.mergeVertices()}function Hb(a,b,c,d,e,f,g){D.call(this);this.type="SphereBufferGeometry";this.parameters={radius:a,widthSegments:b,heightSegments:c,phiStart:d,phiLength:e,thetaStart:f,thetaLength:g};a=a||1;b=Math.max(3,Math.floor(b)||8);c=Math.max(2,Math.floor(c)||6);d=void 0!==d?d:0;e=void 0!==e?e:2*Math.PI;f=void 0!==f?f:0;g=void 0!==g?g:Math.PI;var h=Math.min(f+g,Math.PI),l,m,
r=0,k=[],u=new n,p=new n,t=[],v=[],y=[],w=[];for(m=0;m<=c;m++){var x=[],F=m/c,I=0;0==m&&0==f?I=.5/b:m==c&&h==Math.PI&&(I=-.5/b);for(l=0;l<=b;l++){var z=l/b;u.x=-a*Math.cos(d+z*e)*Math.sin(f+F*g);u.y=a*Math.cos(f+F*g);u.z=a*Math.sin(d+z*e)*Math.sin(f+F*g);v.push(u.x,u.y,u.z);p.copy(u).normalize();y.push(p.x,p.y,p.z);w.push(z+I,1-F);x.push(r++)}k.push(x)}for(m=0;m<c;m++)for(l=0;l<b;l++)a=k[m][l+1],d=k[m][l],e=k[m+1][l],g=k[m+1][l+1],(0!==m||0<f)&&t.push(a,d,g),(m!==c-1||h<Math.PI)&&t.push(d,e,g);this.setIndex(t);
this.setAttribute("position",new A(v,3));this.setAttribute("normal",new A(y,3));this.setAttribute("uv",new A(w,2))}function fe(a,b,c,d,e,f){G.call(this);this.type="RingGeometry";this.parameters={innerRadius:a,outerRadius:b,thetaSegments:c,phiSegments:d,thetaStart:e,thetaLength:f};this.fromBufferGeometry(new Uc(a,b,c,d,e,f));this.mergeVertices()}function Uc(a,b,c,d,e,f){D.call(this);this.type="RingBufferGeometry";this.parameters={innerRadius:a,outerRadius:b,thetaSegments:c,phiSegments:d,thetaStart:e,
thetaLength:f};a=a||.5;b=b||1;e=void 0!==e?e:0;f=void 0!==f?f:2*Math.PI;c=void 0!==c?Math.max(3,c):8;d=void 0!==d?Math.max(1,d):1;var g=[],h=[],l=[],m=[],r=a,k=(b-a)/d,u=new n,p=new B,t,v;for(t=0;t<=d;t++){for(v=0;v<=c;v++)a=e+v/c*f,u.x=r*Math.cos(a),u.y=r*Math.sin(a),h.push(u.x,u.y,u.z),l.push(0,0,1),p.x=(u.x/b+1)/2,p.y=(u.y/b+1)/2,m.push(p.x,p.y);r+=k}for(t=0;t<d;t++)for(b=t*(c+1),v=0;v<c;v++)a=v+b,e=a+c+1,f=a+c+2,r=a+1,g.push(a,e,r),g.push(e,f,r);this.setIndex(g);this.setAttribute("position",new A(h,
3));this.setAttribute("normal",new A(l,3));this.setAttribute("uv",new A(m,2))}function ge(a,b,c,d){G.call(this);this.type="LatheGeometry";this.parameters={points:a,segments:b,phiStart:c,phiLength:d};this.fromBufferGeometry(new Vc(a,b,c,d));this.mergeVertices()}function Vc(a,b,c,d){D.call(this);this.type="LatheBufferGeometry";this.parameters={points:a,segments:b,phiStart:c,phiLength:d};b=Math.floor(b)||12;c=c||0;d=d||2*Math.PI;d=P.clamp(d,0,2*Math.PI);var e=[],f=[],g=[],h=1/b,l=new n,m=new B,r;for(r=
0;r<=b;r++){var k=c+r*h*d;var u=Math.sin(k),p=Math.cos(k);for(k=0;k<=a.length-1;k++)l.x=a[k].x*u,l.y=a[k].y,l.z=a[k].x*p,f.push(l.x,l.y,l.z),m.x=r/b,m.y=k/(a.length-1),g.push(m.x,m.y)}for(r=0;r<b;r++)for(k=0;k<a.length-1;k++)c=k+r*a.length,h=c+a.length,l=c+a.length+1,m=c+1,e.push(c,h,m),e.push(h,l,m);this.setIndex(e);this.setAttribute("position",new A(f,3));this.setAttribute("uv",new A(g,2));this.computeVertexNormals();if(d===2*Math.PI)for(d=this.attributes.normal.array,e=new n,f=new n,g=new n,c=
b*a.length*3,k=r=0;r<a.length;r++,k+=3)e.x=d[k+0],e.y=d[k+1],e.z=d[k+2],f.x=d[c+k+0],f.y=d[c+k+1],f.z=d[c+k+2],g.addVectors(e,f).normalize(),d[k+0]=d[c+k+0]=g.x,d[k+1]=d[c+k+1]=g.y,d[k+2]=d[c+k+2]=g.z}function ec(a,b){G.call(this);this.type="ShapeGeometry";"object"===typeof b&&(console.warn("THREE.ShapeGeometry: Options parameter has been removed."),b=b.curveSegments);this.parameters={shapes:a,curveSegments:b};this.fromBufferGeometry(new fc(a,b));this.mergeVertices()}function fc(a,b){function c(a){var c,
h=e.length/3;a=a.extractPoints(b);var m=a.shape,k=a.holes;!1===qb.isClockWise(m)&&(m=m.reverse());a=0;for(c=k.length;a<c;a++){var r=k[a];!0===qb.isClockWise(r)&&(k[a]=r.reverse())}var n=qb.triangulateShape(m,k);a=0;for(c=k.length;a<c;a++)r=k[a],m=m.concat(r);a=0;for(c=m.length;a<c;a++)r=m[a],e.push(r.x,r.y,0),f.push(0,0,1),g.push(r.x,r.y);a=0;for(c=n.length;a<c;a++)m=n[a],d.push(m[0]+h,m[1]+h,m[2]+h),l+=3}D.call(this);this.type="ShapeBufferGeometry";this.parameters={shapes:a,curveSegments:b};b=b||
12;var d=[],e=[],f=[],g=[],h=0,l=0;if(!1===Array.isArray(a))c(a);else for(var m=0;m<a.length;m++)c(a[m]),this.addGroup(h,l,m),h+=l,l=0;this.setIndex(d);this.setAttribute("position",new A(e,3));this.setAttribute("normal",new A(f,3));this.setAttribute("uv",new A(g,2))}function Yh(a,b){b.shapes=[];if(Array.isArray(a))for(var c=0,d=a.length;c<d;c++)b.shapes.push(a[c].uuid);else b.shapes.push(a.uuid);return b}function Wc(a,b){D.call(this);this.type="EdgesGeometry";this.parameters={thresholdAngle:b};var c=
[];b=Math.cos(P.DEG2RAD*(void 0!==b?b:1));var d=[0,0],e={},f=["a","b","c"];if(a.isBufferGeometry){var g=new G;g.fromBufferGeometry(a)}else g=a.clone();g.mergeVertices();g.computeFaceNormals();a=g.vertices;g=g.faces;for(var h=0,l=g.length;h<l;h++)for(var m=g[h],k=0;3>k;k++){var q=m[f[k]];var n=m[f[(k+1)%3]];d[0]=Math.min(q,n);d[1]=Math.max(q,n);q=d[0]+","+d[1];void 0===e[q]?e[q]={index1:d[0],index2:d[1],face1:h,face2:void 0}:e[q].face2=h}for(q in e)if(d=e[q],void 0===d.face2||g[d.face1].normal.dot(g[d.face2].normal)<=
b)f=a[d.index1],c.push(f.x,f.y,f.z),f=a[d.index2],c.push(f.x,f.y,f.z);this.setAttribute("position",new A(c,3))}function gc(a,b,c,d,e,f,g,h){G.call(this);this.type="CylinderGeometry";this.parameters={radiusTop:a,radiusBottom:b,height:c,radialSegments:d,heightSegments:e,openEnded:f,thetaStart:g,thetaLength:h};this.fromBufferGeometry(new rb(a,b,c,d,e,f,g,h));this.mergeVertices()}function rb(a,b,c,d,e,f,g,h){function l(c){var e,f=new B,l=new n,r=0,v=!0===c?a:b,x=!0===c?1:-1;var A=t;for(e=1;e<=d;e++)q.push(0,
y*x,0),u.push(0,x,0),p.push(.5,.5),t++;var H=t;for(e=0;e<=d;e++){var E=e/d*h+g,C=Math.cos(E);E=Math.sin(E);l.x=v*E;l.y=y*x;l.z=v*C;q.push(l.x,l.y,l.z);u.push(0,x,0);f.x=.5*C+.5;f.y=.5*E*x+.5;p.push(f.x,f.y);t++}for(e=0;e<d;e++)f=A+e,l=H+e,!0===c?k.push(l,l+1,f):k.push(l+1,l,f),r+=3;m.addGroup(w,r,!0===c?1:2);w+=r}D.call(this);this.type="CylinderBufferGeometry";this.parameters={radiusTop:a,radiusBottom:b,height:c,radialSegments:d,heightSegments:e,openEnded:f,thetaStart:g,thetaLength:h};var m=this;
a=void 0!==a?a:1;b=void 0!==b?b:1;c=c||1;d=Math.floor(d)||8;e=Math.floor(e)||1;f=void 0!==f?f:!1;g=void 0!==g?g:0;h=void 0!==h?h:2*Math.PI;var k=[],q=[],u=[],p=[],t=0,v=[],y=c/2,w=0;(function(){var f,l,r=new n,z=new n,B=0,A=(b-a)/c;for(l=0;l<=e;l++){var E=[],C=l/e,H=C*(b-a)+a;for(f=0;f<=d;f++){var G=f/d,D=G*h+g,J=Math.sin(D);D=Math.cos(D);z.x=H*J;z.y=-C*c+y;z.z=H*D;q.push(z.x,z.y,z.z);r.set(J,A,D).normalize();u.push(r.x,r.y,r.z);p.push(G,1-C);E.push(t++)}v.push(E)}for(f=0;f<d;f++)for(l=0;l<e;l++)r=
v[l+1][f],z=v[l+1][f+1],A=v[l][f+1],k.push(v[l][f],r,A),k.push(r,z,A),B+=6;m.addGroup(w,B,0);w+=B})();!1===f&&(0<a&&l(!0),0<b&&l(!1));this.setIndex(k);this.setAttribute("position",new A(q,3));this.setAttribute("normal",new A(u,3));this.setAttribute("uv",new A(p,2))}function he(a,b,c,d,e,f,g){gc.call(this,0,a,b,c,d,e,f,g);this.type="ConeGeometry";this.parameters={radius:a,height:b,radialSegments:c,heightSegments:d,openEnded:e,thetaStart:f,thetaLength:g}}function ie(a,b,c,d,e,f,g){rb.call(this,0,a,
b,c,d,e,f,g);this.type="ConeBufferGeometry";this.parameters={radius:a,height:b,radialSegments:c,heightSegments:d,openEnded:e,thetaStart:f,thetaLength:g}}function je(a,b,c,d){G.call(this);this.type="CircleGeometry";this.parameters={radius:a,segments:b,thetaStart:c,thetaLength:d};this.fromBufferGeometry(new Xc(a,b,c,d));this.mergeVertices()}function Xc(a,b,c,d){D.call(this);this.type="CircleBufferGeometry";this.parameters={radius:a,segments:b,thetaStart:c,thetaLength:d};a=a||1;b=void 0!==b?Math.max(3,
b):8;c=void 0!==c?c:0;d=void 0!==d?d:2*Math.PI;var e=[],f=[],g=[],h=[],l,m=new n,k=new B;f.push(0,0,0);g.push(0,0,1);h.push(.5,.5);var q=0;for(l=3;q<=b;q++,l+=3){var u=c+q/b*d;m.x=a*Math.cos(u);m.y=a*Math.sin(u);f.push(m.x,m.y,m.z);g.push(0,0,1);k.x=(f[l]/a+1)/2;k.y=(f[l+1]/a+1)/2;h.push(k.x,k.y)}for(l=1;l<=b;l++)e.push(l,l+1,0);this.setIndex(e);this.setAttribute("position",new A(f,3));this.setAttribute("normal",new A(g,3));this.setAttribute("uv",new A(h,2))}function hc(a){O.call(this);this.type=
"ShadowMaterial";this.color=new J(0);this.transparent=!0;this.setValues(a)}function Yc(a){va.call(this,a);this.type="RawShaderMaterial"}function eb(a){O.call(this);this.defines={STANDARD:""};this.type="MeshStandardMaterial";this.color=new J(16777215);this.metalness=this.roughness=.5;this.lightMap=this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new J(0);this.emissiveIntensity=1;this.bumpMap=this.emissiveMap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=
0;this.normalScale=new B(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.envMap=this.alphaMap=this.metalnessMap=this.roughnessMap=null;this.envMapIntensity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap="round";this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function ic(a){eb.call(this);this.defines={STANDARD:"",PHYSICAL:""};this.type="MeshPhysicalMaterial";this.reflectivity=
.5;this.clearcoatRoughness=this.clearcoat=0;this.sheen=null;this.clearcoatNormalScale=new B(1,1);this.clearcoatNormalMap=null;this.transparency=0;this.setValues(a)}function Ra(a){O.call(this);this.type="MeshPhongMaterial";this.color=new J(16777215);this.specular=new J(1118481);this.shininess=30;this.lightMap=this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new J(0);this.emissiveIntensity=1;this.bumpMap=this.emissiveMap=null;this.bumpScale=1;this.normalMap=
null;this.normalMapType=0;this.normalScale=new B(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.envMap=this.alphaMap=this.specularMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap="round";this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function jc(a){Ra.call(this);this.defines={TOON:""};this.type="MeshToonMaterial";this.gradientMap=
null;this.setValues(a)}function kc(a){O.call(this);this.type="MeshNormalMaterial";this.bumpMap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new B(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.wireframe=!1;this.wireframeLinewidth=1;this.morphNormals=this.morphTargets=this.skinning=this.fog=!1;this.setValues(a)}function lc(a){O.call(this);this.type="MeshLambertMaterial";this.color=new J(16777215);this.lightMap=this.map=null;this.lightMapIntensity=
1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new J(0);this.emissiveIntensity=1;this.envMap=this.alphaMap=this.specularMap=this.emissiveMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap="round";this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function mc(a){O.call(this);this.defines={MATCAP:""};this.type="MeshMatcapMaterial";this.color=new J(16777215);this.bumpMap=
this.map=this.matcap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new B(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.alphaMap=null;this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function nc(a){R.call(this);this.type="LineDashedMaterial";this.scale=1;this.dashSize=3;this.gapSize=1;this.setValues(a)}function Ia(a,b,c,d){this.parameterPositions=a;this._cachedIndex=0;this.resultBuffer=void 0!==d?d:new b.constructor(c);
this.sampleValues=b;this.valueSize=c}function Re(a,b,c,d){Ia.call(this,a,b,c,d);this._offsetNext=this._weightNext=this._offsetPrev=this._weightPrev=-0}function ke(a,b,c,d){Ia.call(this,a,b,c,d)}function Se(a,b,c,d){Ia.call(this,a,b,c,d)}function sa(a,b,c,d){if(void 0===a)throw Error("THREE.KeyframeTrack: track name is undefined");if(void 0===b||0===b.length)throw Error("THREE.KeyframeTrack: no keyframes in track named "+a);this.name=a;this.times=ta.convertArray(b,this.TimeBufferType);this.values=
ta.convertArray(c,this.ValueBufferType);this.setInterpolation(d||this.DefaultInterpolation)}function Te(a,b,c){sa.call(this,a,b,c)}function Ue(a,b,c,d){sa.call(this,a,b,c,d)}function Zc(a,b,c,d){sa.call(this,a,b,c,d)}function Ve(a,b,c,d){Ia.call(this,a,b,c,d)}function le(a,b,c,d){sa.call(this,a,b,c,d)}function We(a,b,c,d){sa.call(this,a,b,c,d)}function $c(a,b,c,d){sa.call(this,a,b,c,d)}function Ma(a,b,c){this.name=a;this.tracks=c;this.duration=void 0!==b?b:-1;this.uuid=P.generateUUID();0>this.duration&&
this.resetDuration()}function rk(a){switch(a.toLowerCase()){case "scalar":case "double":case "float":case "number":case "integer":return Zc;case "vector":case "vector2":case "vector3":case "vector4":return $c;case "color":return Ue;case "quaternion":return le;case "bool":case "boolean":return Te;case "string":return We}throw Error("THREE.KeyframeTrack: Unsupported typeName: "+a);}function sk(a){if(void 0===a.type)throw Error("THREE.KeyframeTrack: track type undefined, can not parse");var b=rk(a.type);
if(void 0===a.times){var c=[],d=[];ta.flattenJSON(a.keys,c,d,"value");a.times=c;a.values=d}return void 0!==b.parse?b.parse(a):new b(a.name,a.times,a.values,a.interpolation)}function og(a,b,c){var d=this,e=!1,f=0,g=0,h=void 0,l=[];this.onStart=void 0;this.onLoad=a;this.onProgress=b;this.onError=c;this.itemStart=function(a){g++;if(!1===e&&void 0!==d.onStart)d.onStart(a,f,g);e=!0};this.itemEnd=function(a){f++;if(void 0!==d.onProgress)d.onProgress(a,f,g);if(f===g&&(e=!1,void 0!==d.onLoad))d.onLoad()};
this.itemError=function(a){if(void 0!==d.onError)d.onError(a)};this.resolveURL=function(a){return h?h(a):a};this.setURLModifier=function(a){h=a;return this};this.addHandler=function(a,b){l.push(a,b);return this};this.removeHandler=function(a){a=l.indexOf(a);-1!==a&&l.splice(a,2);return this};this.getHandler=function(a){for(var b=0,c=l.length;b<c;b+=2){var d=l[b+1];if(l[b].test(a))return d}return null}}function V(a){this.manager=void 0!==a?a:Zh;this.crossOrigin="anonymous";this.resourcePath=this.path=
""}function Na(a){V.call(this,a)}function pg(a){V.call(this,a)}function qg(a){V.call(this,a)}function Xe(a){V.call(this,a)}function ad(a){V.call(this,a)}function Ye(a){V.call(this,a)}function Ze(a){V.call(this,a)}function C(){this.type="Curve";this.arcLengthDivisions=200}function Ja(a,b,c,d,e,f,g,h){C.call(this);this.type="EllipseCurve";this.aX=a||0;this.aY=b||0;this.xRadius=c||1;this.yRadius=d||1;this.aStartAngle=e||0;this.aEndAngle=f||2*Math.PI;this.aClockwise=g||!1;this.aRotation=h||0}function bd(a,
b,c,d,e,f){Ja.call(this,a,b,c,c,d,e,f);this.type="ArcCurve"}function rg(){var a=0,b=0,c=0,d=0;return{initCatmullRom:function(e,f,g,h,l){e=l*(g-e);h=l*(h-f);a=f;b=e;c=-3*f+3*g-2*e-h;d=2*f-2*g+e+h},initNonuniformCatmullRom:function(e,f,g,h,l,m,k){e=((f-e)/l-(g-e)/(l+m)+(g-f)/m)*m;h=((g-f)/m-(h-f)/(m+k)+(h-g)/k)*m;a=f;b=e;c=-3*f+3*g-2*e-h;d=2*f-2*g+e+h},calc:function(e){var f=e*e;return a+b*e+c*f+d*f*e}}}function ma(a,b,c,d){C.call(this);this.type="CatmullRomCurve3";this.points=a||[];this.closed=b||
!1;this.curveType=c||"centripetal";this.tension=d||.5}function $h(a,b,c,d,e){b=.5*(d-b);e=.5*(e-c);var f=a*a;return(2*c-2*d+b+e)*a*f+(-3*c+3*d-2*b-e)*f+b*a+c}function me(a,b,c,d){var e=1-a;return e*e*b+2*(1-a)*a*c+a*a*d}function ne(a,b,c,d,e){var f=1-a,g=1-a;return f*f*f*b+3*g*g*a*c+3*(1-a)*a*a*d+a*a*a*e}function Sa(a,b,c,d){C.call(this);this.type="CubicBezierCurve";this.v0=a||new B;this.v1=b||new B;this.v2=c||new B;this.v3=d||new B}function fb(a,b,c,d){C.call(this);this.type="CubicBezierCurve3";
this.v0=a||new n;this.v1=b||new n;this.v2=c||new n;this.v3=d||new n}function Da(a,b){C.call(this);this.type="LineCurve";this.v1=a||new B;this.v2=b||new B}function Ta(a,b){C.call(this);this.type="LineCurve3";this.v1=a||new n;this.v2=b||new n}function Ua(a,b,c){C.call(this);this.type="QuadraticBezierCurve";this.v0=a||new B;this.v1=b||new B;this.v2=c||new B}function gb(a,b,c){C.call(this);this.type="QuadraticBezierCurve3";this.v0=a||new n;this.v1=b||new n;this.v2=c||new n}function Va(a){C.call(this);
this.type="SplineCurve";this.points=a||[]}function sb(){C.call(this);this.type="CurvePath";this.curves=[];this.autoClose=!1}function Wa(a){sb.call(this);this.type="Path";this.currentPoint=new B;a&&this.setFromPoints(a)}function Ib(a){Wa.call(this,a);this.uuid=P.generateUUID();this.type="Shape";this.holes=[]}function T(a,b){E.call(this);this.type="Light";this.color=new J(a);this.intensity=void 0!==b?b:1;this.receiveShadow=void 0}function $e(a,b,c){T.call(this,a,c);this.type="HemisphereLight";this.castShadow=
void 0;this.position.copy(E.DefaultUp);this.updateMatrix();this.groundColor=new J(b)}function hb(a){this.camera=a;this.bias=0;this.radius=1;this.mapSize=new B(512,512);this.mapPass=this.map=null;this.matrix=new Q;this._frustum=new Dd;this._frameExtents=new B(1,1);this._viewportCount=1;this._viewports=[new da(0,0,1,1)]}function af(){hb.call(this,new U(50,1,.5,500))}function bf(a,b,c,d,e,f){T.call(this,a,b);this.type="SpotLight";this.position.copy(E.DefaultUp);this.updateMatrix();this.target=new E;
Object.defineProperty(this,"power",{get:function(){return this.intensity*Math.PI},set:function(a){this.intensity=a/Math.PI}});this.distance=void 0!==c?c:0;this.angle=void 0!==d?d:Math.PI/3;this.penumbra=void 0!==e?e:0;this.decay=void 0!==f?f:1;this.shadow=new af}function sg(){hb.call(this,new U(90,1,.5,500));this._frameExtents=new B(4,2);this._viewportCount=6;this._viewports=[new da(2,1,1,1),new da(0,1,1,1),new da(3,1,1,1),new da(1,1,1,1),new da(3,0,1,1),new da(1,0,1,1)];this._cubeDirections=[new n(1,
0,0),new n(-1,0,0),new n(0,0,1),new n(0,0,-1),new n(0,1,0),new n(0,-1,0)];this._cubeUps=[new n(0,1,0),new n(0,1,0),new n(0,1,0),new n(0,1,0),new n(0,0,1),new n(0,0,-1)]}function cf(a,b,c,d){T.call(this,a,b);this.type="PointLight";Object.defineProperty(this,"power",{get:function(){return 4*this.intensity*Math.PI},set:function(a){this.intensity=a/(4*Math.PI)}});this.distance=void 0!==c?c:0;this.decay=void 0!==d?d:1;this.shadow=new sg}function oe(a,b,c,d,e,f){bb.call(this);this.type="OrthographicCamera";
this.zoom=1;this.view=null;this.left=void 0!==a?a:-1;this.right=void 0!==b?b:1;this.top=void 0!==c?c:1;this.bottom=void 0!==d?d:-1;this.near=void 0!==e?e:.1;this.far=void 0!==f?f:2E3;this.updateProjectionMatrix()}function df(){hb.call(this,new oe(-5,5,5,-5,.5,500))}function ef(a,b){T.call(this,a,b);this.type="DirectionalLight";this.position.copy(E.DefaultUp);this.updateMatrix();this.target=new E;this.shadow=new df}function ff(a,b){T.call(this,a,b);this.type="AmbientLight";this.castShadow=void 0}function gf(a,
b,c,d){T.call(this,a,b);this.type="RectAreaLight";this.width=void 0!==c?c:10;this.height=void 0!==d?d:10}function hf(a){V.call(this,a);this.textures={}}function jf(){D.call(this);this.type="InstancedBufferGeometry";this.maxInstancedCount=void 0}function kf(a,b,c,d){"number"===typeof c&&(d=c,c=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument."));N.call(this,a,b,c);this.meshPerAttribute=d||1}function lf(a){V.call(this,a)}function mf(a){V.call(this,
a)}function tg(a){"undefined"===typeof createImageBitmap&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported.");"undefined"===typeof fetch&&console.warn("THREE.ImageBitmapLoader: fetch() not supported.");V.call(this,a);this.options=void 0}function ug(){this.type="ShapePath";this.color=new J;this.subPaths=[];this.currentPath=null}function vg(a){this.type="Font";this.data=a}function wg(a){V.call(this,a)}function nf(a){V.call(this,a)}function of(){this.coefficients=[];for(var a=
0;9>a;a++)this.coefficients.push(new n)}function Xa(a,b){T.call(this,void 0,b);this.sh=void 0!==a?a:new of}function xg(a,b,c){Xa.call(this,void 0,c);a=(new J).set(a);c=(new J).set(b);b=new n(a.r,a.g,a.b);a=new n(c.r,c.g,c.b);c=Math.sqrt(Math.PI);var d=c*Math.sqrt(.75);this.sh.coefficients[0].copy(b).add(a).multiplyScalar(c);this.sh.coefficients[1].copy(b).sub(a).multiplyScalar(d)}function yg(a,b){Xa.call(this,void 0,b);a=(new J).set(a);this.sh.coefficients[0].set(a.r,a.g,a.b).multiplyScalar(2*Math.sqrt(Math.PI))}
function ai(){this.type="StereoCamera";this.aspect=1;this.eyeSep=.064;this.cameraL=new U;this.cameraL.layers.enable(1);this.cameraL.matrixAutoUpdate=!1;this.cameraR=new U;this.cameraR.layers.enable(2);this.cameraR.matrixAutoUpdate=!1;this._cache={focus:null,fov:null,aspect:null,near:null,far:null,zoom:null,eyeSep:null}}function zg(a){this.autoStart=void 0!==a?a:!0;this.elapsedTime=this.oldTime=this.startTime=0;this.running=!1}function Ag(){E.call(this);this.type="AudioListener";this.context=Bg.getContext();
this.gain=this.context.createGain();this.gain.connect(this.context.destination);this.filter=null;this.timeDelta=0;this._clock=new zg}function cd(a){E.call(this);this.type="Audio";this.listener=a;this.context=a.context;this.gain=this.context.createGain();this.gain.connect(a.getInput());this.autoplay=!1;this.buffer=null;this.detune=0;this.loop=!1;this.offset=this.loopEnd=this.loopStart=0;this.duration=void 0;this.playbackRate=1;this.isPlaying=!1;this.hasPlaybackControl=!0;this.sourceType="empty";this._pausedAt=
this._startedAt=0;this.filters=[]}function Cg(a){cd.call(this,a);this.panner=this.context.createPanner();this.panner.panningModel="HRTF";this.panner.connect(this.gain)}function Dg(a,b){this.analyser=a.context.createAnalyser();this.analyser.fftSize=void 0!==b?b:2048;this.data=new Uint8Array(this.analyser.frequencyBinCount);a.getOutput().connect(this.analyser)}function Eg(a,b,c){this.binding=a;this.valueSize=c;a=Float64Array;switch(b){case "quaternion":b=this._slerp;break;case "string":case "bool":a=
Array;b=this._select;break;default:b=this._lerp}this.buffer=new a(4*c);this._mixBufferRegion=b;this.referenceCount=this.useCount=this.cumulativeWeight=0}function bi(a,b,c){c=c||ya.parseTrackName(b);this._targetGroup=a;this._bindings=a.subscribe_(b,c)}function ya(a,b,c){this.path=b;this.parsedPath=c||ya.parseTrackName(b);this.node=ya.findNode(a,this.parsedPath.nodeName)||a;this.rootNode=a}function ci(){this.uuid=P.generateUUID();this._objects=Array.prototype.slice.call(arguments);this.nCachedObjects_=
0;var a={};this._indicesByUUID=a;for(var b=0,c=arguments.length;b!==c;++b)a[arguments[b].uuid]=b;this._paths=[];this._parsedPaths=[];this._bindings=[];this._bindingsIndicesByPath={};var d=this;this.stats={objects:{get total(){return d._objects.length},get inUse(){return this.total-d.nCachedObjects_}},get bindingsPerObject(){return d._bindings.length}}}function di(a,b,c){this._mixer=a;this._clip=b;this._localRoot=c||null;a=b.tracks;b=a.length;c=Array(b);for(var d={endingStart:2400,endingEnd:2400},
e=0;e!==b;++e){var f=a[e].createInterpolant(null);c[e]=f;f.settings=d}this._interpolantSettings=d;this._interpolants=c;this._propertyBindings=Array(b);this._weightInterpolant=this._timeScaleInterpolant=this._byClipCacheIndex=this._cacheIndex=null;this.loop=2201;this._loopCount=-1;this._startTime=null;this.time=0;this._effectiveWeight=this.weight=this._effectiveTimeScale=this.timeScale=1;this.repetitions=Infinity;this.paused=!1;this.enabled=!0;this.clampWhenFinished=!1;this.zeroSlopeAtEnd=this.zeroSlopeAtStart=
!0}function Fg(a){this._root=a;this._initMemoryManager();this.time=this._accuIndex=0;this.timeScale=1}function pf(a,b){"string"===typeof a&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),a=b);this.value=a}function Gg(a,b,c){pb.call(this,a,b);this.meshPerAttribute=c||1}function ei(a,b,c,d){this.ray=new Rb(a,b);this.near=c||0;this.far=d||Infinity;this.camera=null;this.params={Mesh:{},Line:{},LOD:{},Points:{threshold:1},Sprite:{}};Object.defineProperties(this.params,{PointCloud:{get:function(){console.warn("THREE.Raycaster: params.PointCloud has been renamed to params.Points.");
return this.Points}}})}function fi(a,b){return a.distance-b.distance}function Hg(a,b,c,d){if(!1!==a.visible&&(a.raycast(b,c),!0===d)){a=a.children;d=0;for(var e=a.length;d<e;d++)Hg(a[d],b,c,!0)}}function gi(a,b,c){this.radius=void 0!==a?a:1;this.phi=void 0!==b?b:0;this.theta=void 0!==c?c:0;return this}function hi(a,b,c){this.radius=void 0!==a?a:1;this.theta=void 0!==b?b:0;this.y=void 0!==c?c:0;return this}function Ig(a,b){this.min=void 0!==a?a:new B(Infinity,Infinity);this.max=void 0!==b?b:new B(-Infinity,
-Infinity)}function Jg(a,b){this.start=void 0!==a?a:new n;this.end=void 0!==b?b:new n}function pe(a){E.call(this);this.material=a;this.render=function(){}}function qe(a,b,c,d){this.object=a;this.size=void 0!==b?b:1;a=void 0!==c?c:16711680;d=void 0!==d?d:1;b=0;(c=this.object.geometry)&&c.isGeometry?b=3*c.faces.length:c&&c.isBufferGeometry&&(b=c.attributes.normal.count);c=new D;b=new A(6*b,3);c.setAttribute("position",b);X.call(this,c,new R({color:a,linewidth:d}));this.matrixAutoUpdate=!1;this.update()}
function dd(a,b){E.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=b;a=new D;b=[0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,1,0,0,0,0,1,1,0,0,0,0,-1,1];for(var c=0,d=1;32>c;c++,d++){var e=c/32*Math.PI*2,f=d/32*Math.PI*2;b.push(Math.cos(e),Math.sin(e),1,Math.cos(f),Math.sin(f),1)}a.setAttribute("position",new A(b,3));b=new R({fog:!1});this.cone=new X(a,b);this.add(this.cone);this.update()}function ii(a){var b=[];a&&a.isBone&&b.push(a);for(var c=
0;c<a.children.length;c++)b.push.apply(b,ii(a.children[c]));return b}function ed(a){for(var b=ii(a),c=new D,d=[],e=[],f=new J(0,0,1),g=new J(0,1,0),h=0;h<b.length;h++){var l=b[h];l.parent&&l.parent.isBone&&(d.push(0,0,0),d.push(0,0,0),e.push(f.r,f.g,f.b),e.push(g.r,g.g,g.b))}c.setAttribute("position",new A(d,3));c.setAttribute("color",new A(e,3));d=new R({vertexColors:2,depthTest:!1,depthWrite:!1,transparent:!0});X.call(this,c,d);this.root=a;this.bones=b;this.matrix=a.matrixWorld;this.matrixAutoUpdate=
!1}function fd(a,b,c){this.light=a;this.light.updateMatrixWorld();this.color=c;a=new Hb(b,4,2);b=new Ga({wireframe:!0,fog:!1});ea.call(this,a,b);this.matrix=this.light.matrixWorld;this.matrixAutoUpdate=!1;this.update()}function gd(a,b){this.type="RectAreaLightHelper";this.light=a;this.color=b;a=new D;a.setAttribute("position",new A([1,1,0,-1,1,0,-1,-1,0,1,-1,0,1,1,0],3));a.computeBoundingSphere();b=new R({fog:!1});ra.call(this,a,b);a=new D;a.setAttribute("position",new A([1,1,0,-1,1,0,-1,-1,0,1,1,
0,-1,-1,0,1,-1,0],3));a.computeBoundingSphere();this.add(new ea(a,new Ga({side:1,fog:!1})));this.update()}function hd(a,b,c){E.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=c;a=new ac(b);a.rotateY(.5*Math.PI);this.material=new Ga({wireframe:!0,fog:!1});void 0===this.color&&(this.material.vertexColors=2);b=a.getAttribute("position");b=new Float32Array(3*b.count);a.setAttribute("color",new N(b,3));this.add(new ea(a,this.material));
this.update()}function id(a,b){this.lightProbe=a;this.size=b;a=new va({defines:{GAMMA_OUTPUT:""},uniforms:{sh:{value:this.lightProbe.sh.coefficients},intensity:{value:this.lightProbe.intensity}},vertexShader:"varying vec3 vNormal;\nvoid main() {\n\tvNormal = normalize( normalMatrix * normal );\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",fragmentShader:"#define RECIPROCAL_PI 0.318309886\nvec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {\n\t// matrix is assumed to be orthogonal\n\treturn normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );\n}\nvec3 linearToOutput( in vec3 a ) {\n\t#ifdef GAMMA_OUTPUT\n\t\treturn pow( a, vec3( 1.0 / float( GAMMA_FACTOR ) ) );\n\t#else\n\t\treturn a;\n\t#endif\n}\n// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\t// normal is assumed to have unit length\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\t// band 0\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\t// band 1\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\t// band 2\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nuniform vec3 sh[ 9 ]; // sh coefficients\nuniform float intensity; // light probe intensity\nvarying vec3 vNormal;\nvoid main() {\n\tvec3 normal = normalize( vNormal );\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, sh );\n\tvec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;\n\toutgoingLight = linearToOutput( outgoingLight );\n\tgl_FragColor = vec4( outgoingLight, 1.0 );\n}"});
b=new Hb(1,32,16);ea.call(this,b,a);this.onBeforeRender()}function qf(a,b,c,d){a=a||10;b=b||10;c=new J(void 0!==c?c:4473924);d=new J(void 0!==d?d:8947848);var e=b/2,f=a/b,g=a/2;a=[];for(var h=[],l=0,m=0,k=-g;l<=b;l++,k+=f){a.push(-g,0,k,g,0,k);a.push(k,0,-g,k,0,g);var q=l===e?c:d;q.toArray(h,m);m+=3;q.toArray(h,m);m+=3;q.toArray(h,m);m+=3;q.toArray(h,m);m+=3}b=new D;b.setAttribute("position",new A(a,3));b.setAttribute("color",new A(h,3));c=new R({vertexColors:2});X.call(this,b,c)}function rf(a,b,
c,d,e,f){a=a||10;b=b||16;c=c||8;d=d||64;e=new J(void 0!==e?e:4473924);f=new J(void 0!==f?f:8947848);var g=[],h=[],l;for(l=0;l<=b;l++){var m=l/b*2*Math.PI;var k=Math.sin(m)*a;m=Math.cos(m)*a;g.push(0,0,0);g.push(k,0,m);var q=l&1?e:f;h.push(q.r,q.g,q.b);h.push(q.r,q.g,q.b)}for(l=0;l<=c;l++){q=l&1?e:f;var n=a-a/c*l;for(b=0;b<d;b++)m=b/d*2*Math.PI,k=Math.sin(m)*n,m=Math.cos(m)*n,g.push(k,0,m),h.push(q.r,q.g,q.b),m=(b+1)/d*2*Math.PI,k=Math.sin(m)*n,m=Math.cos(m)*n,g.push(k,0,m),h.push(q.r,q.g,q.b)}a=new D;
a.setAttribute("position",new A(g,3));a.setAttribute("color",new A(h,3));g=new R({vertexColors:2});X.call(this,a,g)}function jd(a,b,c,d){this.audio=a;this.range=b||1;this.divisionsInnerAngle=c||16;this.divisionsOuterAngle=d||2;a=new D;b=new Float32Array(3*(3*(this.divisionsInnerAngle+2*this.divisionsOuterAngle)+3));a.setAttribute("position",new N(b,3));b=new R({color:65280});c=new R({color:16776960});ra.call(this,a,[c,b]);this.update()}function re(a,b,c,d){this.object=a;this.size=void 0!==b?b:1;a=
void 0!==c?c:16776960;d=void 0!==d?d:1;b=0;(c=this.object.geometry)&&c.isGeometry?b=c.faces.length:console.warn("THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.");c=new D;b=new A(6*b,3);c.setAttribute("position",b);X.call(this,c,new R({color:a,linewidth:d}));this.matrixAutoUpdate=!1;this.update()}function kd(a,b,c){E.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=c;void 0===b&&
(b=1);a=new D;a.setAttribute("position",new A([-b,b,0,b,b,0,b,-b,0,-b,-b,0,-b,b,0],3));b=new R({fog:!1});this.lightPlane=new ra(a,b);this.add(this.lightPlane);a=new D;a.setAttribute("position",new A([0,0,0,0,0,1],3));this.targetLine=new ra(a,b);this.add(this.targetLine);this.update()}function se(a){function b(a,b,d){c(a,d);c(b,d)}function c(a,b){f.push(0,0,0);g.push(b.r,b.g,b.b);void 0===h[a]&&(h[a]=[]);h[a].push(f.length/3-1)}var d=new D,e=new R({color:16777215,vertexColors:1}),f=[],g=[],h={},l=
new J(16755200),m=new J(16711680),k=new J(43775),q=new J(16777215),n=new J(3355443);b("n1","n2",l);b("n2","n4",l);b("n4","n3",l);b("n3","n1",l);b("f1","f2",l);b("f2","f4",l);b("f4","f3",l);b("f3","f1",l);b("n1","f1",l);b("n2","f2",l);b("n3","f3",l);b("n4","f4",l);b("p","n1",m);b("p","n2",m);b("p","n3",m);b("p","n4",m);b("u1","u2",k);b("u2","u3",k);b("u3","u1",k);b("c","t",q);b("p","c",n);b("cn1","cn2",n);b("cn3","cn4",n);b("cf1","cf2",n);b("cf3","cf4",n);d.setAttribute("position",new A(f,3));d.setAttribute("color",
new A(g,3));X.call(this,d,e);this.camera=a;this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.pointMap=h;this.update()}function na(a,b,c,d,e,f,g){sf.set(e,f,g).unproject(d);a=b[a];if(void 0!==a)for(c=c.getAttribute("position"),b=0,d=a.length;b<d;b++)c.setXYZ(a[b],sf.x,sf.y,sf.z)}function tb(a,b){this.object=a;void 0===b&&(b=16776960);a=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]);var c=new Float32Array(24),
d=new D;d.setIndex(new N(a,1));d.setAttribute("position",new N(c,3));X.call(this,d,new R({color:b}));this.matrixAutoUpdate=!1;this.update()}function te(a,b){this.type="Box3Helper";this.box=a;b=b||16776960;a=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]);var c=new D;c.setIndex(new N(a,1));c.setAttribute("position",new A([1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],3));X.call(this,c,new R({color:b}));this.geometry.computeBoundingSphere()}function ue(a,b,c){this.type=
"PlaneHelper";this.plane=a;this.size=void 0===b?1:b;a=void 0!==c?c:16776960;b=new D;b.setAttribute("position",new A([1,-1,1,-1,1,1,-1,-1,1,1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,1,0,0,1,0,0,0],3));b.computeBoundingSphere();ra.call(this,b,new R({color:a}));b=new D;b.setAttribute("position",new A([1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,-1,1],3));b.computeBoundingSphere();this.add(new ea(b,new Ga({color:a,opacity:.2,transparent:!0,depthWrite:!1})))}function ub(a,b,c,d,e,f){E.call(this);void 0===a&&(a=new n(0,
0,1));void 0===b&&(b=new n(0,0,0));void 0===c&&(c=1);void 0===d&&(d=16776960);void 0===e&&(e=.2*c);void 0===f&&(f=.2*e);void 0===tf&&(tf=new D,tf.setAttribute("position",new A([0,0,0,0,1,0],3)),Kg=new rb(0,.5,1,5,1),Kg.translate(0,-.5,0));this.position.copy(b);this.line=new ra(tf,new R({color:d}));this.line.matrixAutoUpdate=!1;this.add(this.line);this.cone=new ea(Kg,new Ga({color:d}));this.cone.matrixAutoUpdate=!1;this.add(this.cone);this.setDirection(a);this.setLength(c,e,f)}function ve(a){a=a||
1;var b=[0,0,0,a,0,0,0,0,0,0,a,0,0,0,0,0,0,a];a=new D;a.setAttribute("position",new A(b,3));a.setAttribute("color",new A([1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],3));b=new R({vertexColors:2});X.call(this,a,b)}function ji(a){console.warn("THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.");ma.call(this,a);this.type="catmullrom";this.closed=!0}function ki(a){console.warn("THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.");ma.call(this,a);this.type=
"catmullrom"}function Lg(a){console.warn("THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.");ma.call(this,a);this.type="catmullrom"}void 0===Number.EPSILON&&(Number.EPSILON=Math.pow(2,-52));void 0===Number.isInteger&&(Number.isInteger=function(a){return"number"===typeof a&&isFinite(a)&&Math.floor(a)===a});void 0===Math.sign&&(Math.sign=function(a){return 0>a?-1:0<a?1:+a});!1==="name"in Function.prototype&&Object.defineProperty(Function.prototype,"name",{get:function(){return this.toString().match(/^\s*function\s*([^\(\s]*)/)[1]}});
void 0===Object.assign&&(Object.assign=function(a){if(void 0===a||null===a)throw new TypeError("Cannot convert undefined or null to object");for(var b=Object(a),c=1;c<arguments.length;c++){var d=arguments[c];if(void 0!==d&&null!==d)for(var e in d)Object.prototype.hasOwnProperty.call(d,e)&&(b[e]=d[e])}return b});Object.assign(Aa.prototype,{addEventListener:function(a,b){void 0===this._listeners&&(this._listeners={});var c=this._listeners;void 0===c[a]&&(c[a]=[]);-1===c[a].indexOf(b)&&c[a].push(b)},
hasEventListener:function(a,b){if(void 0===this._listeners)return!1;var c=this._listeners;return void 0!==c[a]&&-1!==c[a].indexOf(b)},removeEventListener:function(a,b){void 0!==this._listeners&&(a=this._listeners[a],void 0!==a&&(b=a.indexOf(b),-1!==b&&a.splice(b,1)))},dispatchEvent:function(a){if(void 0!==this._listeners){var b=this._listeners[a.type];if(void 0!==b){a.target=this;b=b.slice(0);for(var c=0,d=b.length;c<d;c++)b[c].call(this,a)}}}});for(var oa=[],we=0;256>we;we++)oa[we]=(16>we?"0":"")+
we.toString(16);var P={DEG2RAD:Math.PI/180,RAD2DEG:180/Math.PI,generateUUID:function(){var a=4294967295*Math.random()|0,b=4294967295*Math.random()|0,c=4294967295*Math.random()|0,d=4294967295*Math.random()|0;return(oa[a&255]+oa[a>>8&255]+oa[a>>16&255]+oa[a>>24&255]+"-"+oa[b&255]+oa[b>>8&255]+"-"+oa[b>>16&15|64]+oa[b>>24&255]+"-"+oa[c&63|128]+oa[c>>8&255]+"-"+oa[c>>16&255]+oa[c>>24&255]+oa[d&255]+oa[d>>8&255]+oa[d>>16&255]+oa[d>>24&255]).toUpperCase()},clamp:function(a,b,c){return Math.max(b,Math.min(c,
a))},euclideanModulo:function(a,b){return(a%b+b)%b},mapLinear:function(a,b,c,d,e){return d+(a-b)*(e-d)/(c-b)},lerp:function(a,b,c){return(1-c)*a+c*b},smoothstep:function(a,b,c){if(a<=b)return 0;if(a>=c)return 1;a=(a-b)/(c-b);return a*a*(3-2*a)},smootherstep:function(a,b,c){if(a<=b)return 0;if(a>=c)return 1;a=(a-b)/(c-b);return a*a*a*(a*(6*a-15)+10)},randInt:function(a,b){return a+Math.floor(Math.random()*(b-a+1))},randFloat:function(a,b){return a+Math.random()*(b-a)},randFloatSpread:function(a){return a*
(.5-Math.random())},degToRad:function(a){return a*P.DEG2RAD},radToDeg:function(a){return a*P.RAD2DEG},isPowerOfTwo:function(a){return 0===(a&a-1)&&0!==a},ceilPowerOfTwo:function(a){return Math.pow(2,Math.ceil(Math.log(a)/Math.LN2))},floorPowerOfTwo:function(a){return Math.pow(2,Math.floor(Math.log(a)/Math.LN2))}};Object.defineProperties(B.prototype,{width:{get:function(){return this.x},set:function(a){this.x=a}},height:{get:function(){return this.y},set:function(a){this.y=a}}});Object.assign(B.prototype,
{isVector2:!0,set:function(a,b){this.x=a;this.y=b;return this},setScalar:function(a){this.y=this.x=a;return this},setX:function(a){this.x=a;return this},setY:function(a){this.y=a;return this},setComponent:function(a,b){switch(a){case 0:this.x=b;break;case 1:this.y=b;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;case 1:return this.y;default:throw Error("index is out of range: "+a);}},clone:function(){return new this.constructor(this.x,
this.y)},copy:function(a){this.x=a.x;this.y=a.y;return this},add:function(a,b){if(void 0!==b)return console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(a,b);this.x+=a.x;this.y+=a.y;return this},addScalar:function(a){this.x+=a;this.y+=a;return this},addVectors:function(a,b){this.x=a.x+b.x;this.y=a.y+b.y;return this},addScaledVector:function(a,b){this.x+=a.x*b;this.y+=a.y*b;return this},sub:function(a,b){if(void 0!==b)return console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),
this.subVectors(a,b);this.x-=a.x;this.y-=a.y;return this},subScalar:function(a){this.x-=a;this.y-=a;return this},subVectors:function(a,b){this.x=a.x-b.x;this.y=a.y-b.y;return this},multiply:function(a){this.x*=a.x;this.y*=a.y;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;return this},divide:function(a){this.x/=a.x;this.y/=a.y;return this},divideScalar:function(a){return this.multiplyScalar(1/a)},applyMatrix3:function(a){var b=this.x,c=this.y;a=a.elements;this.x=a[0]*b+a[3]*c+a[6];this.y=
a[1]*b+a[4]*c+a[7];return this},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,a.y);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);return this},clamp:function(a,b){this.x=Math.max(a.x,Math.min(b.x,this.x));this.y=Math.max(a.y,Math.min(b.y,this.y));return this},clampScalar:function(a,b){this.x=Math.max(a,Math.min(b,this.x));this.y=Math.max(a,Math.min(b,this.y));return this},clampLength:function(a,b){var c=this.length();return this.divideScalar(c||
1).multiplyScalar(Math.max(a,Math.min(b,c)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);return this},ceil:function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);return this},round:function(){this.x=Math.round(this.x);this.y=Math.round(this.y);return this},roundToZero:function(){this.x=0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);return this},negate:function(){this.x=-this.x;this.y=-this.y;return this},dot:function(a){return this.x*
a.x+this.y*a.y},cross:function(a){return this.x*a.y-this.y*a.x},lengthSq:function(){return this.x*this.x+this.y*this.y},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)},normalize:function(){return this.divideScalar(this.length()||1)},angle:function(){var a=Math.atan2(this.y,this.x);0>a&&(a+=2*Math.PI);return a},distanceTo:function(a){return Math.sqrt(this.distanceToSquared(a))},distanceToSquared:function(a){var b=
this.x-a.x;a=this.y-a.y;return b*b+a*a},manhattanDistanceTo:function(a){return Math.abs(this.x-a.x)+Math.abs(this.y-a.y)},setLength:function(a){return this.normalize().multiplyScalar(a)},lerp:function(a,b){this.x+=(a.x-this.x)*b;this.y+=(a.y-this.y)*b;return this},lerpVectors:function(a,b,c){return this.subVectors(b,a).multiplyScalar(c).add(a)},equals:function(a){return a.x===this.x&&a.y===this.y},fromArray:function(a,b){void 0===b&&(b=0);this.x=a[b];this.y=a[b+1];return this},toArray:function(a,
b){void 0===a&&(a=[]);void 0===b&&(b=0);a[b]=this.x;a[b+1]=this.y;return a},fromBufferAttribute:function(a,b,c){void 0!==c&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute().");this.x=a.getX(b);this.y=a.getY(b);return this},rotateAround:function(a,b){var c=Math.cos(b);b=Math.sin(b);var d=this.x-a.x,e=this.y-a.y;this.x=d*c-e*b+a.x;this.y=d*b+e*c+a.y;return this}});Object.assign(wa,{slerp:function(a,b,c,d){return c.copy(a).slerp(b,d)},slerpFlat:function(a,b,c,d,e,f,g){var h=
c[d+0],l=c[d+1],m=c[d+2];c=c[d+3];d=e[f+0];var k=e[f+1],q=e[f+2];e=e[f+3];if(c!==e||h!==d||l!==k||m!==q){f=1-g;var n=h*d+l*k+m*q+c*e,p=0<=n?1:-1,t=1-n*n;t>Number.EPSILON&&(t=Math.sqrt(t),n=Math.atan2(t,n*p),f=Math.sin(f*n)/t,g=Math.sin(g*n)/t);p*=g;h=h*f+d*p;l=l*f+k*p;m=m*f+q*p;c=c*f+e*p;f===1-g&&(g=1/Math.sqrt(h*h+l*l+m*m+c*c),h*=g,l*=g,m*=g,c*=g)}a[b]=h;a[b+1]=l;a[b+2]=m;a[b+3]=c}});Object.defineProperties(wa.prototype,{x:{get:function(){return this._x},set:function(a){this._x=a;this._onChangeCallback()}},
y:{get:function(){return this._y},set:function(a){this._y=a;this._onChangeCallback()}},z:{get:function(){return this._z},set:function(a){this._z=a;this._onChangeCallback()}},w:{get:function(){return this._w},set:function(a){this._w=a;this._onChangeCallback()}}});Object.assign(wa.prototype,{isQuaternion:!0,set:function(a,b,c,d){this._x=a;this._y=b;this._z=c;this._w=d;this._onChangeCallback();return this},clone:function(){return new this.constructor(this._x,this._y,this._z,this._w)},copy:function(a){this._x=
a.x;this._y=a.y;this._z=a.z;this._w=a.w;this._onChangeCallback();return this},setFromEuler:function(a,b){if(!a||!a.isEuler)throw Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");var c=a._x,d=a._y,e=a._z;a=a.order;var f=Math.cos,g=Math.sin,h=f(c/2),l=f(d/2);f=f(e/2);c=g(c/2);d=g(d/2);e=g(e/2);"XYZ"===a?(this._x=c*l*f+h*d*e,this._y=h*d*f-c*l*e,this._z=h*l*e+c*d*f,this._w=h*l*f-c*d*e):"YXZ"===a?(this._x=c*l*f+h*d*e,this._y=h*d*f-c*l*e,this._z=
h*l*e-c*d*f,this._w=h*l*f+c*d*e):"ZXY"===a?(this._x=c*l*f-h*d*e,this._y=h*d*f+c*l*e,this._z=h*l*e+c*d*f,this._w=h*l*f-c*d*e):"ZYX"===a?(this._x=c*l*f-h*d*e,this._y=h*d*f+c*l*e,this._z=h*l*e-c*d*f,this._w=h*l*f+c*d*e):"YZX"===a?(this._x=c*l*f+h*d*e,this._y=h*d*f+c*l*e,this._z=h*l*e-c*d*f,this._w=h*l*f-c*d*e):"XZY"===a&&(this._x=c*l*f-h*d*e,this._y=h*d*f-c*l*e,this._z=h*l*e+c*d*f,this._w=h*l*f+c*d*e);!1!==b&&this._onChangeCallback();return this},setFromAxisAngle:function(a,b){b/=2;var c=Math.sin(b);
this._x=a.x*c;this._y=a.y*c;this._z=a.z*c;this._w=Math.cos(b);this._onChangeCallback();return this},setFromRotationMatrix:function(a){var b=a.elements,c=b[0];a=b[4];var d=b[8],e=b[1],f=b[5],g=b[9],h=b[2],l=b[6];b=b[10];var m=c+f+b;0<m?(c=.5/Math.sqrt(m+1),this._w=.25/c,this._x=(l-g)*c,this._y=(d-h)*c,this._z=(e-a)*c):c>f&&c>b?(c=2*Math.sqrt(1+c-f-b),this._w=(l-g)/c,this._x=.25*c,this._y=(a+e)/c,this._z=(d+h)/c):f>b?(c=2*Math.sqrt(1+f-c-b),this._w=(d-h)/c,this._x=(a+e)/c,this._y=.25*c,this._z=(g+l)/
c):(c=2*Math.sqrt(1+b-c-f),this._w=(e-a)/c,this._x=(d+h)/c,this._y=(g+l)/c,this._z=.25*c);this._onChangeCallback();return this},setFromUnitVectors:function(a,b){var c=a.dot(b)+1;1E-6>c?(c=0,Math.abs(a.x)>Math.abs(a.z)?(this._x=-a.y,this._y=a.x,this._z=0):(this._x=0,this._y=-a.z,this._z=a.y)):(this._x=a.y*b.z-a.z*b.y,this._y=a.z*b.x-a.x*b.z,this._z=a.x*b.y-a.y*b.x);this._w=c;return this.normalize()},angleTo:function(a){return 2*Math.acos(Math.abs(P.clamp(this.dot(a),-1,1)))},rotateTowards:function(a,
b){var c=this.angleTo(a);if(0===c)return this;this.slerp(a,Math.min(1,b/c));return this},inverse:function(){return this.conjugate()},conjugate:function(){this._x*=-1;this._y*=-1;this._z*=-1;this._onChangeCallback();return this},dot:function(a){return this._x*a._x+this._y*a._y+this._z*a._z+this._w*a._w},lengthSq:function(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w},length:function(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)},normalize:function(){var a=
this.length();0===a?(this._z=this._y=this._x=0,this._w=1):(a=1/a,this._x*=a,this._y*=a,this._z*=a,this._w*=a);this._onChangeCallback();return this},multiply:function(a,b){return void 0!==b?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(a,b)):this.multiplyQuaternions(this,a)},premultiply:function(a){return this.multiplyQuaternions(a,this)},multiplyQuaternions:function(a,b){var c=a._x,d=a._y,e=a._z;a=a._w;
var f=b._x,g=b._y,h=b._z;b=b._w;this._x=c*b+a*f+d*h-e*g;this._y=d*b+a*g+e*f-c*h;this._z=e*b+a*h+c*g-d*f;this._w=a*b-c*f-d*g-e*h;this._onChangeCallback();return this},slerp:function(a,b){if(0===b)return this;if(1===b)return this.copy(a);var c=this._x,d=this._y,e=this._z,f=this._w,g=f*a._w+c*a._x+d*a._y+e*a._z;0>g?(this._w=-a._w,this._x=-a._x,this._y=-a._y,this._z=-a._z,g=-g):this.copy(a);if(1<=g)return this._w=f,this._x=c,this._y=d,this._z=e,this;a=1-g*g;if(a<=Number.EPSILON)return g=1-b,this._w=g*
f+b*this._w,this._x=g*c+b*this._x,this._y=g*d+b*this._y,this._z=g*e+b*this._z,this.normalize(),this._onChangeCallback(),this;a=Math.sqrt(a);var h=Math.atan2(a,g);g=Math.sin((1-b)*h)/a;b=Math.sin(b*h)/a;this._w=f*g+this._w*b;this._x=c*g+this._x*b;this._y=d*g+this._y*b;this._z=e*g+this._z*b;this._onChangeCallback();return this},equals:function(a){return a._x===this._x&&a._y===this._y&&a._z===this._z&&a._w===this._w},fromArray:function(a,b){void 0===b&&(b=0);this._x=a[b];this._y=a[b+1];this._z=a[b+2];
this._w=a[b+3];this._onChangeCallback();return this},toArray:function(a,b){void 0===a&&(a=[]);void 0===b&&(b=0);a[b]=this._x;a[b+1]=this._y;a[b+2]=this._z;a[b+3]=this._w;return a},_onChange:function(a){this._onChangeCallback=a;return this},_onChangeCallback:function(){}});var Mg=new n,li=new wa;Object.assign(n.prototype,{isVector3:!0,set:function(a,b,c){this.x=a;this.y=b;this.z=c;return this},setScalar:function(a){this.z=this.y=this.x=a;return this},setX:function(a){this.x=a;return this},setY:function(a){this.y=
a;return this},setZ:function(a){this.z=a;return this},setComponent:function(a,b){switch(a){case 0:this.x=b;break;case 1:this.y=b;break;case 2:this.z=b;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw Error("index is out of range: "+a);}},clone:function(){return new this.constructor(this.x,this.y,this.z)},copy:function(a){this.x=a.x;this.y=a.y;this.z=a.z;return this},
add:function(a,b){if(void 0!==b)return console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(a,b);this.x+=a.x;this.y+=a.y;this.z+=a.z;return this},addScalar:function(a){this.x+=a;this.y+=a;this.z+=a;return this},addVectors:function(a,b){this.x=a.x+b.x;this.y=a.y+b.y;this.z=a.z+b.z;return this},addScaledVector:function(a,b){this.x+=a.x*b;this.y+=a.y*b;this.z+=a.z*b;return this},sub:function(a,b){if(void 0!==b)return console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),
this.subVectors(a,b);this.x-=a.x;this.y-=a.y;this.z-=a.z;return this},subScalar:function(a){this.x-=a;this.y-=a;this.z-=a;return this},subVectors:function(a,b){this.x=a.x-b.x;this.y=a.y-b.y;this.z=a.z-b.z;return this},multiply:function(a,b){if(void 0!==b)return console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(a,b);this.x*=a.x;this.y*=a.y;this.z*=a.z;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;this.z*=
a;return this},multiplyVectors:function(a,b){this.x=a.x*b.x;this.y=a.y*b.y;this.z=a.z*b.z;return this},applyEuler:function(a){a&&a.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.");return this.applyQuaternion(li.setFromEuler(a))},applyAxisAngle:function(a,b){return this.applyQuaternion(li.setFromAxisAngle(a,b))},applyMatrix3:function(a){var b=this.x,c=this.y,d=this.z;a=a.elements;this.x=a[0]*b+a[3]*c+a[6]*d;this.y=a[1]*b+a[4]*c+a[7]*
d;this.z=a[2]*b+a[5]*c+a[8]*d;return this},applyMatrix4:function(a){var b=this.x,c=this.y,d=this.z;a=a.elements;var e=1/(a[3]*b+a[7]*c+a[11]*d+a[15]);this.x=(a[0]*b+a[4]*c+a[8]*d+a[12])*e;this.y=(a[1]*b+a[5]*c+a[9]*d+a[13])*e;this.z=(a[2]*b+a[6]*c+a[10]*d+a[14])*e;return this},applyQuaternion:function(a){var b=this.x,c=this.y,d=this.z,e=a.x,f=a.y,g=a.z;a=a.w;var h=a*b+f*d-g*c,l=a*c+g*b-e*d,m=a*d+e*c-f*b;b=-e*b-f*c-g*d;this.x=h*a+b*-e+l*-g-m*-f;this.y=l*a+b*-f+m*-e-h*-g;this.z=m*a+b*-g+h*-f-l*-e;return this},
project:function(a){return this.applyMatrix4(a.matrixWorldInverse).applyMatrix4(a.projectionMatrix)},unproject:function(a){return this.applyMatrix4(a.projectionMatrixInverse).applyMatrix4(a.matrixWorld)},transformDirection:function(a){var b=this.x,c=this.y,d=this.z;a=a.elements;this.x=a[0]*b+a[4]*c+a[8]*d;this.y=a[1]*b+a[5]*c+a[9]*d;this.z=a[2]*b+a[6]*c+a[10]*d;return this.normalize()},divide:function(a){this.x/=a.x;this.y/=a.y;this.z/=a.z;return this},divideScalar:function(a){return this.multiplyScalar(1/
a)},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,a.y);this.z=Math.min(this.z,a.z);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);this.z=Math.max(this.z,a.z);return this},clamp:function(a,b){this.x=Math.max(a.x,Math.min(b.x,this.x));this.y=Math.max(a.y,Math.min(b.y,this.y));this.z=Math.max(a.z,Math.min(b.z,this.z));return this},clampScalar:function(a,b){this.x=Math.max(a,Math.min(b,this.x));this.y=Math.max(a,Math.min(b,this.y));this.z=Math.max(a,
Math.min(b,this.z));return this},clampLength:function(a,b){var c=this.length();return this.divideScalar(c||1).multiplyScalar(Math.max(a,Math.min(b,c)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);this.z=Math.floor(this.z);return this},ceil:function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);this.z=Math.ceil(this.z);return this},round:function(){this.x=Math.round(this.x);this.y=Math.round(this.y);this.z=Math.round(this.z);return this},roundToZero:function(){this.x=
0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);this.z=0>this.z?Math.ceil(this.z):Math.floor(this.z);return this},negate:function(){this.x=-this.x;this.y=-this.y;this.z=-this.z;return this},dot:function(a){return this.x*a.x+this.y*a.y+this.z*a.z},lengthSq:function(){return this.x*this.x+this.y*this.y+this.z*this.z},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)+
Math.abs(this.z)},normalize:function(){return this.divideScalar(this.length()||1)},setLength:function(a){return this.normalize().multiplyScalar(a)},lerp:function(a,b){this.x+=(a.x-this.x)*b;this.y+=(a.y-this.y)*b;this.z+=(a.z-this.z)*b;return this},lerpVectors:function(a,b,c){return this.subVectors(b,a).multiplyScalar(c).add(a)},cross:function(a,b){return void 0!==b?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(a,b)):this.crossVectors(this,
a)},crossVectors:function(a,b){var c=a.x,d=a.y;a=a.z;var e=b.x,f=b.y;b=b.z;this.x=d*b-a*f;this.y=a*e-c*b;this.z=c*f-d*e;return this},projectOnVector:function(a){var b=a.dot(this)/a.lengthSq();return this.copy(a).multiplyScalar(b)},projectOnPlane:function(a){Mg.copy(this).projectOnVector(a);return this.sub(Mg)},reflect:function(a){return this.sub(Mg.copy(a).multiplyScalar(2*this.dot(a)))},angleTo:function(a){var b=Math.sqrt(this.lengthSq()*a.lengthSq());0===b&&console.error("THREE.Vector3: angleTo() can't handle zero length vectors.");
a=this.dot(a)/b;return Math.acos(P.clamp(a,-1,1))},distanceTo:function(a){return Math.sqrt(this.distanceToSquared(a))},distanceToSquared:function(a){var b=this.x-a.x,c=this.y-a.y;a=this.z-a.z;return b*b+c*c+a*a},manhattanDistanceTo:function(a){return Math.abs(this.x-a.x)+Math.abs(this.y-a.y)+Math.abs(this.z-a.z)},setFromSpherical:function(a){return this.setFromSphericalCoords(a.radius,a.phi,a.theta)},setFromSphericalCoords:function(a,b,c){var d=Math.sin(b)*a;this.x=d*Math.sin(c);this.y=Math.cos(b)*
a;this.z=d*Math.cos(c);return this},setFromCylindrical:function(a){return this.setFromCylindricalCoords(a.radius,a.theta,a.y)},setFromCylindricalCoords:function(a,b,c){this.x=a*Math.sin(b);this.y=c;this.z=a*Math.cos(b);return this},setFromMatrixPosition:function(a){a=a.elements;this.x=a[12];this.y=a[13];this.z=a[14];return this},setFromMatrixScale:function(a){var b=this.setFromMatrixColumn(a,0).length(),c=this.setFromMatrixColumn(a,1).length();a=this.setFromMatrixColumn(a,2).length();this.x=b;this.y=
c;this.z=a;return this},setFromMatrixColumn:function(a,b){return this.fromArray(a.elements,4*b)},equals:function(a){return a.x===this.x&&a.y===this.y&&a.z===this.z},fromArray:function(a,b){void 0===b&&(b=0);this.x=a[b];this.y=a[b+1];this.z=a[b+2];return this},toArray:function(a,b){void 0===a&&(a=[]);void 0===b&&(b=0);a[b]=this.x;a[b+1]=this.y;a[b+2]=this.z;return a},fromBufferAttribute:function(a,b,c){void 0!==c&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute().");
this.x=a.getX(b);this.y=a.getY(b);this.z=a.getZ(b);return this}});var oc=new n;Object.assign(Z.prototype,{isMatrix3:!0,set:function(a,b,c,d,e,f,g,h,l){var m=this.elements;m[0]=a;m[1]=d;m[2]=g;m[3]=b;m[4]=e;m[5]=h;m[6]=c;m[7]=f;m[8]=l;return this},identity:function(){this.set(1,0,0,0,1,0,0,0,1);return this},clone:function(){return(new this.constructor).fromArray(this.elements)},copy:function(a){var b=this.elements;a=a.elements;b[0]=a[0];b[1]=a[1];b[2]=a[2];b[3]=a[3];b[4]=a[4];b[5]=a[5];b[6]=a[6];b[7]=
a[7];b[8]=a[8];return this},setFromMatrix4:function(a){a=a.elements;this.set(a[0],a[4],a[8],a[1],a[5],a[9],a[2],a[6],a[10]);return this},applyToBufferAttribute:function(a){for(var b=0,c=a.count;b<c;b++)oc.x=a.getX(b),oc.y=a.getY(b),oc.z=a.getZ(b),oc.applyMatrix3(this),a.setXYZ(b,oc.x,oc.y,oc.z);return a},multiply:function(a){return this.multiplyMatrices(this,a)},premultiply:function(a){return this.multiplyMatrices(a,this)},multiplyMatrices:function(a,b){var c=a.elements,d=b.elements;b=this.elements;
a=c[0];var e=c[3],f=c[6],g=c[1],h=c[4],l=c[7],m=c[2],k=c[5];c=c[8];var q=d[0],n=d[3],p=d[6],t=d[1],v=d[4],y=d[7],w=d[2],x=d[5];d=d[8];b[0]=a*q+e*t+f*w;b[3]=a*n+e*v+f*x;b[6]=a*p+e*y+f*d;b[1]=g*q+h*t+l*w;b[4]=g*n+h*v+l*x;b[7]=g*p+h*y+l*d;b[2]=m*q+k*t+c*w;b[5]=m*n+k*v+c*x;b[8]=m*p+k*y+c*d;return this},multiplyScalar:function(a){var b=this.elements;b[0]*=a;b[3]*=a;b[6]*=a;b[1]*=a;b[4]*=a;b[7]*=a;b[2]*=a;b[5]*=a;b[8]*=a;return this},determinant:function(){var a=this.elements,b=a[0],c=a[1],d=a[2],e=a[3],
f=a[4],g=a[5],h=a[6],l=a[7];a=a[8];return b*f*a-b*g*l-c*e*a+c*g*h+d*e*l-d*f*h},getInverse:function(a,b){a&&a.isMatrix4&&console.error("THREE.Matrix3: .getInverse() no longer takes a Matrix4 argument.");var c=a.elements;a=this.elements;var d=c[0],e=c[1],f=c[2],g=c[3],h=c[4],l=c[5],m=c[6],k=c[7];c=c[8];var q=c*h-l*k,n=l*m-c*g,p=k*g-h*m,t=d*q+e*n+f*p;if(0===t){if(!0===b)throw Error("THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0");console.warn("THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0");
return this.identity()}b=1/t;a[0]=q*b;a[1]=(f*k-c*e)*b;a[2]=(l*e-f*h)*b;a[3]=n*b;a[4]=(c*d-f*m)*b;a[5]=(f*g-l*d)*b;a[6]=p*b;a[7]=(e*m-k*d)*b;a[8]=(h*d-e*g)*b;return this},transpose:function(){var a=this.elements;var b=a[1];a[1]=a[3];a[3]=b;b=a[2];a[2]=a[6];a[6]=b;b=a[5];a[5]=a[7];a[7]=b;return this},getNormalMatrix:function(a){return this.setFromMatrix4(a).getInverse(this).transpose()},transposeIntoArray:function(a){var b=this.elements;a[0]=b[0];a[1]=b[3];a[2]=b[6];a[3]=b[1];a[4]=b[4];a[5]=b[7];a[6]=
b[2];a[7]=b[5];a[8]=b[8];return this},setUvTransform:function(a,b,c,d,e,f,g){var h=Math.cos(e);e=Math.sin(e);this.set(c*h,c*e,-c*(h*f+e*g)+f+a,-d*e,d*h,-d*(-e*f+h*g)+g+b,0,0,1)},scale:function(a,b){var c=this.elements;c[0]*=a;c[3]*=a;c[6]*=a;c[1]*=b;c[4]*=b;c[7]*=b;return this},rotate:function(a){var b=Math.cos(a);a=Math.sin(a);var c=this.elements,d=c[0],e=c[3],f=c[6],g=c[1],h=c[4],l=c[7];c[0]=b*d+a*g;c[3]=b*e+a*h;c[6]=b*f+a*l;c[1]=-a*d+b*g;c[4]=-a*e+b*h;c[7]=-a*f+b*l;return this},translate:function(a,
b){var c=this.elements;c[0]+=a*c[2];c[3]+=a*c[5];c[6]+=a*c[8];c[1]+=b*c[2];c[4]+=b*c[5];c[7]+=b*c[8];return this},equals:function(a){var b=this.elements;a=a.elements;for(var c=0;9>c;c++)if(b[c]!==a[c])return!1;return!0},fromArray:function(a,b){void 0===b&&(b=0);for(var c=0;9>c;c++)this.elements[c]=a[c+b];return this},toArray:function(a,b){void 0===a&&(a=[]);void 0===b&&(b=0);var c=this.elements;a[b]=c[0];a[b+1]=c[1];a[b+2]=c[2];a[b+3]=c[3];a[b+4]=c[4];a[b+5]=c[5];a[b+6]=c[6];a[b+7]=c[7];a[b+8]=c[8];
return a}});var ld,Jb={getDataURL:function(a){if("undefined"==typeof HTMLCanvasElement)return a.src;if(!(a instanceof HTMLCanvasElement)){void 0===ld&&(ld=document.createElementNS("http://www.w3.org/1999/xhtml","canvas"));ld.width=a.width;ld.height=a.height;var b=ld.getContext("2d");a instanceof ImageData?b.putImageData(a,0,0):b.drawImage(a,0,0,a.width,a.height);a=ld}return 2048<a.width||2048<a.height?a.toDataURL("image/jpeg",.6):a.toDataURL("image/png")}},Si=0;Y.DEFAULT_IMAGE=void 0;Y.DEFAULT_MAPPING=
300;Y.prototype=Object.assign(Object.create(Aa.prototype),{constructor:Y,isTexture:!0,updateMatrix:function(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.name=a.name;this.image=a.image;this.mipmaps=a.mipmaps.slice(0);this.mapping=a.mapping;this.wrapS=a.wrapS;this.wrapT=a.wrapT;this.magFilter=a.magFilter;this.minFilter=a.minFilter;this.anisotropy=
a.anisotropy;this.format=a.format;this.type=a.type;this.offset.copy(a.offset);this.repeat.copy(a.repeat);this.center.copy(a.center);this.rotation=a.rotation;this.matrixAutoUpdate=a.matrixAutoUpdate;this.matrix.copy(a.matrix);this.generateMipmaps=a.generateMipmaps;this.premultiplyAlpha=a.premultiplyAlpha;this.flipY=a.flipY;this.unpackAlignment=a.unpackAlignment;this.encoding=a.encoding;return this},toJSON:function(a){var b=void 0===a||"string"===typeof a;if(!b&&void 0!==a.textures[this.uuid])return a.textures[this.uuid];
var c={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};
if(void 0!==this.image){var d=this.image;void 0===d.uuid&&(d.uuid=P.generateUUID());if(!b&&void 0===a.images[d.uuid]){if(Array.isArray(d)){var e=[];for(var f=0,g=d.length;f<g;f++)e.push(Jb.getDataURL(d[f]))}else e=Jb.getDataURL(d);a.images[d.uuid]={uuid:d.uuid,url:e}}c.image=d.uuid}b||(a.textures[this.uuid]=c);return c},dispose:function(){this.dispatchEvent({type:"dispose"})},transformUv:function(a){if(300!==this.mapping)return a;a.applyMatrix3(this.matrix);if(0>a.x||1<a.x)switch(this.wrapS){case 1E3:a.x-=
Math.floor(a.x);break;case 1001:a.x=0>a.x?0:1;break;case 1002:a.x=1===Math.abs(Math.floor(a.x)%2)?Math.ceil(a.x)-a.x:a.x-Math.floor(a.x)}if(0>a.y||1<a.y)switch(this.wrapT){case 1E3:a.y-=Math.floor(a.y);break;case 1001:a.y=0>a.y?0:1;break;case 1002:a.y=1===Math.abs(Math.floor(a.y)%2)?Math.ceil(a.y)-a.y:a.y-Math.floor(a.y)}this.flipY&&(a.y=1-a.y);return a}});Object.defineProperty(Y.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.defineProperties(da.prototype,{width:{get:function(){return this.z},
set:function(a){this.z=a}},height:{get:function(){return this.w},set:function(a){this.w=a}}});Object.assign(da.prototype,{isVector4:!0,set:function(a,b,c,d){this.x=a;this.y=b;this.z=c;this.w=d;return this},setScalar:function(a){this.w=this.z=this.y=this.x=a;return this},setX:function(a){this.x=a;return this},setY:function(a){this.y=a;return this},setZ:function(a){this.z=a;return this},setW:function(a){this.w=a;return this},setComponent:function(a,b){switch(a){case 0:this.x=b;break;case 1:this.y=b;
break;case 2:this.z=b;break;case 3:this.w=b;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw Error("index is out of range: "+a);}},clone:function(){return new this.constructor(this.x,this.y,this.z,this.w)},copy:function(a){this.x=a.x;this.y=a.y;this.z=a.z;this.w=void 0!==a.w?a.w:1;return this},add:function(a,b){if(void 0!==b)return console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),
this.addVectors(a,b);this.x+=a.x;this.y+=a.y;this.z+=a.z;this.w+=a.w;return this},addScalar:function(a){this.x+=a;this.y+=a;this.z+=a;this.w+=a;return this},addVectors:function(a,b){this.x=a.x+b.x;this.y=a.y+b.y;this.z=a.z+b.z;this.w=a.w+b.w;return this},addScaledVector:function(a,b){this.x+=a.x*b;this.y+=a.y*b;this.z+=a.z*b;this.w+=a.w*b;return this},sub:function(a,b){if(void 0!==b)return console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(a,
b);this.x-=a.x;this.y-=a.y;this.z-=a.z;this.w-=a.w;return this},subScalar:function(a){this.x-=a;this.y-=a;this.z-=a;this.w-=a;return this},subVectors:function(a,b){this.x=a.x-b.x;this.y=a.y-b.y;this.z=a.z-b.z;this.w=a.w-b.w;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;this.z*=a;this.w*=a;return this},applyMatrix4:function(a){var b=this.x,c=this.y,d=this.z,e=this.w;a=a.elements;this.x=a[0]*b+a[4]*c+a[8]*d+a[12]*e;this.y=a[1]*b+a[5]*c+a[9]*d+a[13]*e;this.z=a[2]*b+a[6]*c+a[10]*d+a[14]*
e;this.w=a[3]*b+a[7]*c+a[11]*d+a[15]*e;return this},divideScalar:function(a){return this.multiplyScalar(1/a)},setAxisAngleFromQuaternion:function(a){this.w=2*Math.acos(a.w);var b=Math.sqrt(1-a.w*a.w);1E-4>b?(this.x=1,this.z=this.y=0):(this.x=a.x/b,this.y=a.y/b,this.z=a.z/b);return this},setAxisAngleFromRotationMatrix:function(a){a=a.elements;var b=a[0];var c=a[4];var d=a[8],e=a[1],f=a[5],g=a[9];var h=a[2];var l=a[6];var m=a[10];if(.01>Math.abs(c-e)&&.01>Math.abs(d-h)&&.01>Math.abs(g-l)){if(.1>Math.abs(c+
e)&&.1>Math.abs(d+h)&&.1>Math.abs(g+l)&&.1>Math.abs(b+f+m-3))return this.set(1,0,0,0),this;a=Math.PI;b=(b+1)/2;f=(f+1)/2;m=(m+1)/2;c=(c+e)/4;d=(d+h)/4;g=(g+l)/4;b>f&&b>m?.01>b?(l=0,c=h=.707106781):(l=Math.sqrt(b),h=c/l,c=d/l):f>m?.01>f?(l=.707106781,h=0,c=.707106781):(h=Math.sqrt(f),l=c/h,c=g/h):.01>m?(h=l=.707106781,c=0):(c=Math.sqrt(m),l=d/c,h=g/c);this.set(l,h,c,a);return this}a=Math.sqrt((l-g)*(l-g)+(d-h)*(d-h)+(e-c)*(e-c));.001>Math.abs(a)&&(a=1);this.x=(l-g)/a;this.y=(d-h)/a;this.z=(e-c)/a;
this.w=Math.acos((b+f+m-1)/2);return this},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,a.y);this.z=Math.min(this.z,a.z);this.w=Math.min(this.w,a.w);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);this.z=Math.max(this.z,a.z);this.w=Math.max(this.w,a.w);return this},clamp:function(a,b){this.x=Math.max(a.x,Math.min(b.x,this.x));this.y=Math.max(a.y,Math.min(b.y,this.y));this.z=Math.max(a.z,Math.min(b.z,this.z));this.w=Math.max(a.w,Math.min(b.w,
this.w));return this},clampScalar:function(a,b){this.x=Math.max(a,Math.min(b,this.x));this.y=Math.max(a,Math.min(b,this.y));this.z=Math.max(a,Math.min(b,this.z));this.w=Math.max(a,Math.min(b,this.w));return this},clampLength:function(a,b){var c=this.length();return this.divideScalar(c||1).multiplyScalar(Math.max(a,Math.min(b,c)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);this.z=Math.floor(this.z);this.w=Math.floor(this.w);return this},ceil:function(){this.x=Math.ceil(this.x);
this.y=Math.ceil(this.y);this.z=Math.ceil(this.z);this.w=Math.ceil(this.w);return this},round:function(){this.x=Math.round(this.x);this.y=Math.round(this.y);this.z=Math.round(this.z);this.w=Math.round(this.w);return this},roundToZero:function(){this.x=0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);this.z=0>this.z?Math.ceil(this.z):Math.floor(this.z);this.w=0>this.w?Math.ceil(this.w):Math.floor(this.w);return this},negate:function(){this.x=-this.x;
this.y=-this.y;this.z=-this.z;this.w=-this.w;return this},dot:function(a){return this.x*a.x+this.y*a.y+this.z*a.z+this.w*a.w},lengthSq:function(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)},normalize:function(){return this.divideScalar(this.length()||1)},setLength:function(a){return this.normalize().multiplyScalar(a)},
lerp:function(a,b){this.x+=(a.x-this.x)*b;this.y+=(a.y-this.y)*b;this.z+=(a.z-this.z)*b;this.w+=(a.w-this.w)*b;return this},lerpVectors:function(a,b,c){return this.subVectors(b,a).multiplyScalar(c).add(a)},equals:function(a){return a.x===this.x&&a.y===this.y&&a.z===this.z&&a.w===this.w},fromArray:function(a,b){void 0===b&&(b=0);this.x=a[b];this.y=a[b+1];this.z=a[b+2];this.w=a[b+3];return this},toArray:function(a,b){void 0===a&&(a=[]);void 0===b&&(b=0);a[b]=this.x;a[b+1]=this.y;a[b+2]=this.z;a[b+3]=
this.w;return a},fromBufferAttribute:function(a,b,c){void 0!==c&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute().");this.x=a.getX(b);this.y=a.getY(b);this.z=a.getZ(b);this.w=a.getW(b);return this}});Ba.prototype=Object.assign(Object.create(Aa.prototype),{constructor:Ba,isWebGLRenderTarget:!0,setSize:function(a,b){if(this.width!==a||this.height!==b)this.width=a,this.height=b,this.texture.image.width=a,this.texture.image.height=b,this.dispose();this.viewport.set(0,0,
a,b);this.scissor.set(0,0,a,b)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.width=a.width;this.height=a.height;this.viewport.copy(a.viewport);this.texture=a.texture.clone();this.depthBuffer=a.depthBuffer;this.stencilBuffer=a.stencilBuffer;this.depthTexture=a.depthTexture;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});Sf.prototype=Object.assign(Object.create(Ba.prototype),{constructor:Sf,isWebGLMultisampleRenderTarget:!0,copy:function(a){Ba.prototype.copy.call(this,
a);this.samples=a.samples;return this}});var Ka=new n,ca=new Q,tk=new n(0,0,0),uk=new n(1,1,1),Kb=new n,uf=new n,pa=new n;Object.assign(Q.prototype,{isMatrix4:!0,set:function(a,b,c,d,e,f,g,h,l,m,k,q,n,p,t,v){var r=this.elements;r[0]=a;r[4]=b;r[8]=c;r[12]=d;r[1]=e;r[5]=f;r[9]=g;r[13]=h;r[2]=l;r[6]=m;r[10]=k;r[14]=q;r[3]=n;r[7]=p;r[11]=t;r[15]=v;return this},identity:function(){this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1);return this},clone:function(){return(new Q).fromArray(this.elements)},copy:function(a){var b=
this.elements;a=a.elements;b[0]=a[0];b[1]=a[1];b[2]=a[2];b[3]=a[3];b[4]=a[4];b[5]=a[5];b[6]=a[6];b[7]=a[7];b[8]=a[8];b[9]=a[9];b[10]=a[10];b[11]=a[11];b[12]=a[12];b[13]=a[13];b[14]=a[14];b[15]=a[15];return this},copyPosition:function(a){var b=this.elements;a=a.elements;b[12]=a[12];b[13]=a[13];b[14]=a[14];return this},extractBasis:function(a,b,c){a.setFromMatrixColumn(this,0);b.setFromMatrixColumn(this,1);c.setFromMatrixColumn(this,2);return this},makeBasis:function(a,b,c){this.set(a.x,b.x,c.x,0,a.y,
b.y,c.y,0,a.z,b.z,c.z,0,0,0,0,1);return this},extractRotation:function(a){var b=this.elements,c=a.elements,d=1/Ka.setFromMatrixColumn(a,0).length(),e=1/Ka.setFromMatrixColumn(a,1).length();a=1/Ka.setFromMatrixColumn(a,2).length();b[0]=c[0]*d;b[1]=c[1]*d;b[2]=c[2]*d;b[3]=0;b[4]=c[4]*e;b[5]=c[5]*e;b[6]=c[6]*e;b[7]=0;b[8]=c[8]*a;b[9]=c[9]*a;b[10]=c[10]*a;b[11]=0;b[12]=0;b[13]=0;b[14]=0;b[15]=1;return this},makeRotationFromEuler:function(a){a&&a.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");
var b=this.elements,c=a.x,d=a.y,e=a.z,f=Math.cos(c);c=Math.sin(c);var g=Math.cos(d);d=Math.sin(d);var h=Math.cos(e);e=Math.sin(e);if("XYZ"===a.order){a=f*h;var l=f*e,m=c*h,k=c*e;b[0]=g*h;b[4]=-g*e;b[8]=d;b[1]=l+m*d;b[5]=a-k*d;b[9]=-c*g;b[2]=k-a*d;b[6]=m+l*d;b[10]=f*g}else"YXZ"===a.order?(a=g*h,l=g*e,m=d*h,k=d*e,b[0]=a+k*c,b[4]=m*c-l,b[8]=f*d,b[1]=f*e,b[5]=f*h,b[9]=-c,b[2]=l*c-m,b[6]=k+a*c,b[10]=f*g):"ZXY"===a.order?(a=g*h,l=g*e,m=d*h,k=d*e,b[0]=a-k*c,b[4]=-f*e,b[8]=m+l*c,b[1]=l+m*c,b[5]=f*h,b[9]=
k-a*c,b[2]=-f*d,b[6]=c,b[10]=f*g):"ZYX"===a.order?(a=f*h,l=f*e,m=c*h,k=c*e,b[0]=g*h,b[4]=m*d-l,b[8]=a*d+k,b[1]=g*e,b[5]=k*d+a,b[9]=l*d-m,b[2]=-d,b[6]=c*g,b[10]=f*g):"YZX"===a.order?(a=f*g,l=f*d,m=c*g,k=c*d,b[0]=g*h,b[4]=k-a*e,b[8]=m*e+l,b[1]=e,b[5]=f*h,b[9]=-c*h,b[2]=-d*h,b[6]=l*e+m,b[10]=a-k*e):"XZY"===a.order&&(a=f*g,l=f*d,m=c*g,k=c*d,b[0]=g*h,b[4]=-e,b[8]=d*h,b[1]=a*e+k,b[5]=f*h,b[9]=l*e-m,b[2]=m*e-l,b[6]=c*h,b[10]=k*e+a);b[3]=0;b[7]=0;b[11]=0;b[12]=0;b[13]=0;b[14]=0;b[15]=1;return this},makeRotationFromQuaternion:function(a){return this.compose(tk,
a,uk)},lookAt:function(a,b,c){var d=this.elements;pa.subVectors(a,b);0===pa.lengthSq()&&(pa.z=1);pa.normalize();Kb.crossVectors(c,pa);0===Kb.lengthSq()&&(1===Math.abs(c.z)?pa.x+=1E-4:pa.z+=1E-4,pa.normalize(),Kb.crossVectors(c,pa));Kb.normalize();uf.crossVectors(pa,Kb);d[0]=Kb.x;d[4]=uf.x;d[8]=pa.x;d[1]=Kb.y;d[5]=uf.y;d[9]=pa.y;d[2]=Kb.z;d[6]=uf.z;d[10]=pa.z;return this},multiply:function(a,b){return void 0!==b?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),
this.multiplyMatrices(a,b)):this.multiplyMatrices(this,a)},premultiply:function(a){return this.multiplyMatrices(a,this)},multiplyMatrices:function(a,b){var c=a.elements,d=b.elements;b=this.elements;a=c[0];var e=c[4],f=c[8],g=c[12],h=c[1],l=c[5],m=c[9],k=c[13],q=c[2],n=c[6],p=c[10],t=c[14],v=c[3],y=c[7],w=c[11];c=c[15];var x=d[0],B=d[4],I=d[8],z=d[12],A=d[1],E=d[5],C=d[9],D=d[13],H=d[2],G=d[6],J=d[10],L=d[14],N=d[3],O=d[7],P=d[11];d=d[15];b[0]=a*x+e*A+f*H+g*N;b[4]=a*B+e*E+f*G+g*O;b[8]=a*I+e*C+f*J+
g*P;b[12]=a*z+e*D+f*L+g*d;b[1]=h*x+l*A+m*H+k*N;b[5]=h*B+l*E+m*G+k*O;b[9]=h*I+l*C+m*J+k*P;b[13]=h*z+l*D+m*L+k*d;b[2]=q*x+n*A+p*H+t*N;b[6]=q*B+n*E+p*G+t*O;b[10]=q*I+n*C+p*J+t*P;b[14]=q*z+n*D+p*L+t*d;b[3]=v*x+y*A+w*H+c*N;b[7]=v*B+y*E+w*G+c*O;b[11]=v*I+y*C+w*J+c*P;b[15]=v*z+y*D+w*L+c*d;return this},multiplyScalar:function(a){var b=this.elements;b[0]*=a;b[4]*=a;b[8]*=a;b[12]*=a;b[1]*=a;b[5]*=a;b[9]*=a;b[13]*=a;b[2]*=a;b[6]*=a;b[10]*=a;b[14]*=a;b[3]*=a;b[7]*=a;b[11]*=a;b[15]*=a;return this},applyToBufferAttribute:function(a){for(var b=
0,c=a.count;b<c;b++)Ka.x=a.getX(b),Ka.y=a.getY(b),Ka.z=a.getZ(b),Ka.applyMatrix4(this),a.setXYZ(b,Ka.x,Ka.y,Ka.z);return a},determinant:function(){var a=this.elements,b=a[0],c=a[4],d=a[8],e=a[12],f=a[1],g=a[5],h=a[9],l=a[13],m=a[2],k=a[6],q=a[10],n=a[14];return a[3]*(+e*h*k-d*l*k-e*g*q+c*l*q+d*g*n-c*h*n)+a[7]*(+b*h*n-b*l*q+e*f*q-d*f*n+d*l*m-e*h*m)+a[11]*(+b*l*k-b*g*n-e*f*k+c*f*n+e*g*m-c*l*m)+a[15]*(-d*g*m-b*h*k+b*g*q+d*f*k-c*f*q+c*h*m)},transpose:function(){var a=this.elements;var b=a[1];a[1]=a[4];
a[4]=b;b=a[2];a[2]=a[8];a[8]=b;b=a[6];a[6]=a[9];a[9]=b;b=a[3];a[3]=a[12];a[12]=b;b=a[7];a[7]=a[13];a[13]=b;b=a[11];a[11]=a[14];a[14]=b;return this},setPosition:function(a,b,c){var d=this.elements;a.isVector3?(d[12]=a.x,d[13]=a.y,d[14]=a.z):(d[12]=a,d[13]=b,d[14]=c);return this},getInverse:function(a,b){var c=this.elements,d=a.elements;a=d[0];var e=d[1],f=d[2],g=d[3],h=d[4],l=d[5],m=d[6],k=d[7],q=d[8],n=d[9],p=d[10],t=d[11],v=d[12],y=d[13],w=d[14];d=d[15];var x=n*w*k-y*p*k+y*m*t-l*w*t-n*m*d+l*p*d,
B=v*p*k-q*w*k-v*m*t+h*w*t+q*m*d-h*p*d,I=q*y*k-v*n*k+v*l*t-h*y*t-q*l*d+h*n*d,z=v*n*m-q*y*m-v*l*p+h*y*p+q*l*w-h*n*w,A=a*x+e*B+f*I+g*z;if(0===A){if(!0===b)throw Error("THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0");console.warn("THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0");return this.identity()}b=1/A;c[0]=x*b;c[1]=(y*p*g-n*w*g-y*f*t+e*w*t+n*f*d-e*p*d)*b;c[2]=(l*w*g-y*m*g+y*f*k-e*w*k-l*f*d+e*m*d)*b;c[3]=(n*m*g-l*p*g-n*f*k+e*p*k+l*f*t-e*m*t)*b;c[4]=B*b;c[5]=
(q*w*g-v*p*g+v*f*t-a*w*t-q*f*d+a*p*d)*b;c[6]=(v*m*g-h*w*g-v*f*k+a*w*k+h*f*d-a*m*d)*b;c[7]=(h*p*g-q*m*g+q*f*k-a*p*k-h*f*t+a*m*t)*b;c[8]=I*b;c[9]=(v*n*g-q*y*g-v*e*t+a*y*t+q*e*d-a*n*d)*b;c[10]=(h*y*g-v*l*g+v*e*k-a*y*k-h*e*d+a*l*d)*b;c[11]=(q*l*g-h*n*g-q*e*k+a*n*k+h*e*t-a*l*t)*b;c[12]=z*b;c[13]=(q*y*f-v*n*f+v*e*p-a*y*p-q*e*w+a*n*w)*b;c[14]=(v*l*f-h*y*f-v*e*m+a*y*m+h*e*w-a*l*w)*b;c[15]=(h*n*f-q*l*f+q*e*m-a*n*m-h*e*p+a*l*p)*b;return this},scale:function(a){var b=this.elements,c=a.x,d=a.y;a=a.z;b[0]*=c;
b[4]*=d;b[8]*=a;b[1]*=c;b[5]*=d;b[9]*=a;b[2]*=c;b[6]*=d;b[10]*=a;b[3]*=c;b[7]*=d;b[11]*=a;return this},getMaxScaleOnAxis:function(){var a=this.elements;return Math.sqrt(Math.max(a[0]*a[0]+a[1]*a[1]+a[2]*a[2],a[4]*a[4]+a[5]*a[5]+a[6]*a[6],a[8]*a[8]+a[9]*a[9]+a[10]*a[10]))},makeTranslation:function(a,b,c){this.set(1,0,0,a,0,1,0,b,0,0,1,c,0,0,0,1);return this},makeRotationX:function(a){var b=Math.cos(a);a=Math.sin(a);this.set(1,0,0,0,0,b,-a,0,0,a,b,0,0,0,0,1);return this},makeRotationY:function(a){var b=
Math.cos(a);a=Math.sin(a);this.set(b,0,a,0,0,1,0,0,-a,0,b,0,0,0,0,1);return this},makeRotationZ:function(a){var b=Math.cos(a);a=Math.sin(a);this.set(b,-a,0,0,a,b,0,0,0,0,1,0,0,0,0,1);return this},makeRotationAxis:function(a,b){var c=Math.cos(b);b=Math.sin(b);var d=1-c,e=a.x,f=a.y;a=a.z;var g=d*e,h=d*f;this.set(g*e+c,g*f-b*a,g*a+b*f,0,g*f+b*a,h*f+c,h*a-b*e,0,g*a-b*f,h*a+b*e,d*a*a+c,0,0,0,0,1);return this},makeScale:function(a,b,c){this.set(a,0,0,0,0,b,0,0,0,0,c,0,0,0,0,1);return this},makeShear:function(a,
b,c){this.set(1,b,c,0,a,1,c,0,a,b,1,0,0,0,0,1);return this},compose:function(a,b,c){var d=this.elements,e=b._x,f=b._y,g=b._z,h=b._w,l=e+e,m=f+f,k=g+g;b=e*l;var n=e*m;e*=k;var u=f*m;f*=k;g*=k;l*=h;m*=h;h*=k;k=c.x;var p=c.y;c=c.z;d[0]=(1-(u+g))*k;d[1]=(n+h)*k;d[2]=(e-m)*k;d[3]=0;d[4]=(n-h)*p;d[5]=(1-(b+g))*p;d[6]=(f+l)*p;d[7]=0;d[8]=(e+m)*c;d[9]=(f-l)*c;d[10]=(1-(b+u))*c;d[11]=0;d[12]=a.x;d[13]=a.y;d[14]=a.z;d[15]=1;return this},decompose:function(a,b,c){var d=this.elements,e=Ka.set(d[0],d[1],d[2]).length(),
f=Ka.set(d[4],d[5],d[6]).length(),g=Ka.set(d[8],d[9],d[10]).length();0>this.determinant()&&(e=-e);a.x=d[12];a.y=d[13];a.z=d[14];ca.copy(this);a=1/e;d=1/f;var h=1/g;ca.elements[0]*=a;ca.elements[1]*=a;ca.elements[2]*=a;ca.elements[4]*=d;ca.elements[5]*=d;ca.elements[6]*=d;ca.elements[8]*=h;ca.elements[9]*=h;ca.elements[10]*=h;b.setFromRotationMatrix(ca);c.x=e;c.y=f;c.z=g;return this},makePerspective:function(a,b,c,d,e,f){void 0===f&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");
var g=this.elements;g[0]=2*e/(b-a);g[4]=0;g[8]=(b+a)/(b-a);g[12]=0;g[1]=0;g[5]=2*e/(c-d);g[9]=(c+d)/(c-d);g[13]=0;g[2]=0;g[6]=0;g[10]=-(f+e)/(f-e);g[14]=-2*f*e/(f-e);g[3]=0;g[7]=0;g[11]=-1;g[15]=0;return this},makeOrthographic:function(a,b,c,d,e,f){var g=this.elements,h=1/(b-a),l=1/(c-d),m=1/(f-e);g[0]=2*h;g[4]=0;g[8]=0;g[12]=-((b+a)*h);g[1]=0;g[5]=2*l;g[9]=0;g[13]=-((c+d)*l);g[2]=0;g[6]=0;g[10]=-2*m;g[14]=-((f+e)*m);g[3]=0;g[7]=0;g[11]=0;g[15]=1;return this},equals:function(a){var b=this.elements;
a=a.elements;for(var c=0;16>c;c++)if(b[c]!==a[c])return!1;return!0},fromArray:function(a,b){void 0===b&&(b=0);for(var c=0;16>c;c++)this.elements[c]=a[c+b];return this},toArray:function(a,b){void 0===a&&(a=[]);void 0===b&&(b=0);var c=this.elements;a[b]=c[0];a[b+1]=c[1];a[b+2]=c[2];a[b+3]=c[3];a[b+4]=c[4];a[b+5]=c[5];a[b+6]=c[6];a[b+7]=c[7];a[b+8]=c[8];a[b+9]=c[9];a[b+10]=c[10];a[b+11]=c[11];a[b+12]=c[12];a[b+13]=c[13];a[b+14]=c[14];a[b+15]=c[15];return a}});var mi=new Q,ni=new wa;Pb.RotationOrders=
"XYZ YZX ZXY XZY YXZ ZYX".split(" ");Pb.DefaultOrder="XYZ";Object.defineProperties(Pb.prototype,{x:{get:function(){return this._x},set:function(a){this._x=a;this._onChangeCallback()}},y:{get:function(){return this._y},set:function(a){this._y=a;this._onChangeCallback()}},z:{get:function(){return this._z},set:function(a){this._z=a;this._onChangeCallback()}},order:{get:function(){return this._order},set:function(a){this._order=a;this._onChangeCallback()}}});Object.assign(Pb.prototype,{isEuler:!0,set:function(a,
b,c,d){this._x=a;this._y=b;this._z=c;this._order=d||this._order;this._onChangeCallback();return this},clone:function(){return new this.constructor(this._x,this._y,this._z,this._order)},copy:function(a){this._x=a._x;this._y=a._y;this._z=a._z;this._order=a._order;this._onChangeCallback();return this},setFromRotationMatrix:function(a,b,c){var d=P.clamp,e=a.elements;a=e[0];var f=e[4],g=e[8],h=e[1],l=e[5],m=e[9],k=e[2],n=e[6];e=e[10];b=b||this._order;"XYZ"===b?(this._y=Math.asin(d(g,-1,1)),.9999999>Math.abs(g)?
(this._x=Math.atan2(-m,e),this._z=Math.atan2(-f,a)):(this._x=Math.atan2(n,l),this._z=0)):"YXZ"===b?(this._x=Math.asin(-d(m,-1,1)),.9999999>Math.abs(m)?(this._y=Math.atan2(g,e),this._z=Math.atan2(h,l)):(this._y=Math.atan2(-k,a),this._z=0)):"ZXY"===b?(this._x=Math.asin(d(n,-1,1)),.9999999>Math.abs(n)?(this._y=Math.atan2(-k,e),this._z=Math.atan2(-f,l)):(this._y=0,this._z=Math.atan2(h,a))):"ZYX"===b?(this._y=Math.asin(-d(k,-1,1)),.9999999>Math.abs(k)?(this._x=Math.atan2(n,e),this._z=Math.atan2(h,a)):
(this._x=0,this._z=Math.atan2(-f,l))):"YZX"===b?(this._z=Math.asin(d(h,-1,1)),.9999999>Math.abs(h)?(this._x=Math.atan2(-m,l),this._y=Math.atan2(-k,a)):(this._x=0,this._y=Math.atan2(g,e))):"XZY"===b?(this._z=Math.asin(-d(f,-1,1)),.9999999>Math.abs(f)?(this._x=Math.atan2(n,l),this._y=Math.atan2(g,a)):(this._x=Math.atan2(-m,e),this._y=0)):console.warn("THREE.Euler: .setFromRotationMatrix() given unsupported order: "+b);this._order=b;!1!==c&&this._onChangeCallback();return this},setFromQuaternion:function(a,
b,c){mi.makeRotationFromQuaternion(a);return this.setFromRotationMatrix(mi,b,c)},setFromVector3:function(a,b){return this.set(a.x,a.y,a.z,b||this._order)},reorder:function(a){ni.setFromEuler(this);return this.setFromQuaternion(ni,a)},equals:function(a){return a._x===this._x&&a._y===this._y&&a._z===this._z&&a._order===this._order},fromArray:function(a){this._x=a[0];this._y=a[1];this._z=a[2];void 0!==a[3]&&(this._order=a[3]);this._onChangeCallback();return this},toArray:function(a,b){void 0===a&&(a=
[]);void 0===b&&(b=0);a[b]=this._x;a[b+1]=this._y;a[b+2]=this._z;a[b+3]=this._order;return a},toVector3:function(a){return a?a.set(this._x,this._y,this._z):new n(this._x,this._y,this._z)},_onChange:function(a){this._onChangeCallback=a;return this},_onChangeCallback:function(){}});Object.assign(Tf.prototype,{set:function(a){this.mask=1<<a|0},enable:function(a){this.mask=this.mask|1<<a|0},enableAll:function(){this.mask=-1},toggle:function(a){this.mask^=1<<a|0},disable:function(a){this.mask&=~(1<<a|
0)},disableAll:function(){this.mask=0},test:function(a){return 0!==(this.mask&a.mask)}});var Ti=0,oi=new n,md=new wa,vb=new Q,vf=new n,xe=new n,vk=new n,wk=new wa,pi=new n(1,0,0),qi=new n(0,1,0),ri=new n(0,0,1),xk={type:"added"},yk={type:"removed"};E.DefaultUp=new n(0,1,0);E.DefaultMatrixAutoUpdate=!0;E.prototype=Object.assign(Object.create(Aa.prototype),{constructor:E,isObject3D:!0,onBeforeRender:function(){},onAfterRender:function(){},applyMatrix:function(a){this.matrixAutoUpdate&&this.updateMatrix();
this.matrix.premultiply(a);this.matrix.decompose(this.position,this.quaternion,this.scale)},applyQuaternion:function(a){this.quaternion.premultiply(a);return this},setRotationFromAxisAngle:function(a,b){this.quaternion.setFromAxisAngle(a,b)},setRotationFromEuler:function(a){this.quaternion.setFromEuler(a,!0)},setRotationFromMatrix:function(a){this.quaternion.setFromRotationMatrix(a)},setRotationFromQuaternion:function(a){this.quaternion.copy(a)},rotateOnAxis:function(a,b){md.setFromAxisAngle(a,b);
this.quaternion.multiply(md);return this},rotateOnWorldAxis:function(a,b){md.setFromAxisAngle(a,b);this.quaternion.premultiply(md);return this},rotateX:function(a){return this.rotateOnAxis(pi,a)},rotateY:function(a){return this.rotateOnAxis(qi,a)},rotateZ:function(a){return this.rotateOnAxis(ri,a)},translateOnAxis:function(a,b){oi.copy(a).applyQuaternion(this.quaternion);this.position.add(oi.multiplyScalar(b));return this},translateX:function(a){return this.translateOnAxis(pi,a)},translateY:function(a){return this.translateOnAxis(qi,
a)},translateZ:function(a){return this.translateOnAxis(ri,a)},localToWorld:function(a){return a.applyMatrix4(this.matrixWorld)},worldToLocal:function(a){return a.applyMatrix4(vb.getInverse(this.matrixWorld))},lookAt:function(a,b,c){a.isVector3?vf.copy(a):vf.set(a,b,c);a=this.parent;this.updateWorldMatrix(!0,!1);xe.setFromMatrixPosition(this.matrixWorld);this.isCamera||this.isLight?vb.lookAt(xe,vf,this.up):vb.lookAt(vf,xe,this.up);this.quaternion.setFromRotationMatrix(vb);a&&(vb.extractRotation(a.matrixWorld),
md.setFromRotationMatrix(vb),this.quaternion.premultiply(md.inverse()))},add:function(a){if(1<arguments.length){for(var b=0;b<arguments.length;b++)this.add(arguments[b]);return this}if(a===this)return console.error("THREE.Object3D.add: object can't be added as a child of itself.",a),this;a&&a.isObject3D?(null!==a.parent&&a.parent.remove(a),a.parent=this,this.children.push(a),a.dispatchEvent(xk)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",a);return this},remove:function(a){if(1<
arguments.length){for(var b=0;b<arguments.length;b++)this.remove(arguments[b]);return this}b=this.children.indexOf(a);-1!==b&&(a.parent=null,this.children.splice(b,1),a.dispatchEvent(yk));return this},attach:function(a){this.updateWorldMatrix(!0,!1);vb.getInverse(this.matrixWorld);null!==a.parent&&(a.parent.updateWorldMatrix(!0,!1),vb.multiply(a.parent.matrixWorld));a.applyMatrix(vb);a.updateWorldMatrix(!1,!1);this.add(a);return this},getObjectById:function(a){return this.getObjectByProperty("id",
a)},getObjectByName:function(a){return this.getObjectByProperty("name",a)},getObjectByProperty:function(a,b){if(this[a]===b)return this;for(var c=0,d=this.children.length;c<d;c++){var e=this.children[c].getObjectByProperty(a,b);if(void 0!==e)return e}},getWorldPosition:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldPosition() target is now required"),a=new n);this.updateMatrixWorld(!0);return a.setFromMatrixPosition(this.matrixWorld)},getWorldQuaternion:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldQuaternion() target is now required"),
a=new wa);this.updateMatrixWorld(!0);this.matrixWorld.decompose(xe,a,vk);return a},getWorldScale:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldScale() target is now required"),a=new n);this.updateMatrixWorld(!0);this.matrixWorld.decompose(xe,wk,a);return a},getWorldDirection:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldDirection() target is now required"),a=new n);this.updateMatrixWorld(!0);var b=this.matrixWorld.elements;return a.set(b[8],b[9],b[10]).normalize()},
raycast:function(){},traverse:function(a){a(this);for(var b=this.children,c=0,d=b.length;c<d;c++)b[c].traverse(a)},traverseVisible:function(a){if(!1!==this.visible){a(this);for(var b=this.children,c=0,d=b.length;c<d;c++)b[c].traverseVisible(a)}},traverseAncestors:function(a){var b=this.parent;null!==b&&(a(b),b.traverseAncestors(a))},updateMatrix:function(){this.matrix.compose(this.position,this.quaternion,this.scale);this.matrixWorldNeedsUpdate=!0},updateMatrixWorld:function(a){this.matrixAutoUpdate&&
this.updateMatrix();if(this.matrixWorldNeedsUpdate||a)null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,a=!0;for(var b=this.children,c=0,d=b.length;c<d;c++)b[c].updateMatrixWorld(a)},updateWorldMatrix:function(a,b){var c=this.parent;!0===a&&null!==c&&c.updateWorldMatrix(!0,!1);this.matrixAutoUpdate&&this.updateMatrix();null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,
this.matrix);if(!0===b)for(a=this.children,b=0,c=a.length;b<c;b++)a[b].updateWorldMatrix(!1,!0)},toJSON:function(a){function b(b,c){void 0===b[c.uuid]&&(b[c.uuid]=c.toJSON(a));return c.uuid}function c(a){var b=[],c;for(c in a){var d=a[c];delete d.metadata;b.push(d)}return b}var d=void 0===a||"string"===typeof a,e={};d&&(a={geometries:{},materials:{},textures:{},images:{},shapes:{}},e.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});var f={};f.uuid=this.uuid;f.type=this.type;""!==
this.name&&(f.name=this.name);!0===this.castShadow&&(f.castShadow=!0);!0===this.receiveShadow&&(f.receiveShadow=!0);!1===this.visible&&(f.visible=!1);!1===this.frustumCulled&&(f.frustumCulled=!1);0!==this.renderOrder&&(f.renderOrder=this.renderOrder);"{}"!==JSON.stringify(this.userData)&&(f.userData=this.userData);f.layers=this.layers.mask;f.matrix=this.matrix.toArray();!1===this.matrixAutoUpdate&&(f.matrixAutoUpdate=!1);this.isMesh&&0!==this.drawMode&&(f.drawMode=this.drawMode);this.isInstancedMesh&&
(f.type="InstancedMesh",f.count=this.count,f.instanceMatrix=this.instanceMatrix.toJSON());if(this.isMesh||this.isLine||this.isPoints){f.geometry=b(a.geometries,this.geometry);var g=this.geometry.parameters;if(void 0!==g&&void 0!==g.shapes)if(g=g.shapes,Array.isArray(g))for(var h=0,l=g.length;h<l;h++)b(a.shapes,g[h]);else b(a.shapes,g)}if(void 0!==this.material)if(Array.isArray(this.material)){g=[];h=0;for(l=this.material.length;h<l;h++)g.push(b(a.materials,this.material[h]));f.material=g}else f.material=
b(a.materials,this.material);if(0<this.children.length)for(f.children=[],h=0;h<this.children.length;h++)f.children.push(this.children[h].toJSON(a).object);if(d){d=c(a.geometries);h=c(a.materials);l=c(a.textures);var m=c(a.images);g=c(a.shapes);0<d.length&&(e.geometries=d);0<h.length&&(e.materials=h);0<l.length&&(e.textures=l);0<m.length&&(e.images=m);0<g.length&&(e.shapes=g)}e.object=f;return e},clone:function(a){return(new this.constructor).copy(this,a)},copy:function(a,b){void 0===b&&(b=!0);this.name=
a.name;this.up.copy(a.up);this.position.copy(a.position);this.quaternion.copy(a.quaternion);this.scale.copy(a.scale);this.matrix.copy(a.matrix);this.matrixWorld.copy(a.matrixWorld);this.matrixAutoUpdate=a.matrixAutoUpdate;this.matrixWorldNeedsUpdate=a.matrixWorldNeedsUpdate;this.layers.mask=a.layers.mask;this.visible=a.visible;this.castShadow=a.castShadow;this.receiveShadow=a.receiveShadow;this.frustumCulled=a.frustumCulled;this.renderOrder=a.renderOrder;this.userData=JSON.parse(JSON.stringify(a.userData));
if(!0===b)for(b=0;b<a.children.length;b++)this.add(a.children[b].clone());return this}});vd.prototype=Object.assign(Object.create(E.prototype),{constructor:vd,isScene:!0,copy:function(a,b){E.prototype.copy.call(this,a,b);null!==a.background&&(this.background=a.background.clone());null!==a.fog&&(this.fog=a.fog.clone());null!==a.overrideMaterial&&(this.overrideMaterial=a.overrideMaterial.clone());this.autoUpdate=a.autoUpdate;this.matrixAutoUpdate=a.matrixAutoUpdate;return this},toJSON:function(a){var b=
E.prototype.toJSON.call(this,a);null!==this.background&&(b.object.background=this.background.toJSON(a));null!==this.fog&&(b.object.fog=this.fog.toJSON());return b},dispose:function(){this.dispatchEvent({type:"dispose"})}});var wb=[new n,new n,new n,new n,new n,new n,new n,new n],ib=new n,nd=new n,od=new n,pd=new n,Lb=new n,Mb=new n,pc=new n,ye=new n,wf=new n,xf=new n,Qb=new n;Object.assign(ab.prototype,{isBox3:!0,set:function(a,b){this.min.copy(a);this.max.copy(b);return this},setFromArray:function(a){for(var b=
Infinity,c=Infinity,d=Infinity,e=-Infinity,f=-Infinity,g=-Infinity,h=0,l=a.length;h<l;h+=3){var m=a[h],k=a[h+1],n=a[h+2];m<b&&(b=m);k<c&&(c=k);n<d&&(d=n);m>e&&(e=m);k>f&&(f=k);n>g&&(g=n)}this.min.set(b,c,d);this.max.set(e,f,g);return this},setFromBufferAttribute:function(a){for(var b=Infinity,c=Infinity,d=Infinity,e=-Infinity,f=-Infinity,g=-Infinity,h=0,l=a.count;h<l;h++){var m=a.getX(h),k=a.getY(h),n=a.getZ(h);m<b&&(b=m);k<c&&(c=k);n<d&&(d=n);m>e&&(e=m);k>f&&(f=k);n>g&&(g=n)}this.min.set(b,c,d);
this.max.set(e,f,g);return this},setFromPoints:function(a){this.makeEmpty();for(var b=0,c=a.length;b<c;b++)this.expandByPoint(a[b]);return this},setFromCenterAndSize:function(a,b){b=ib.copy(b).multiplyScalar(.5);this.min.copy(a).sub(b);this.max.copy(a).add(b);return this},setFromObject:function(a){this.makeEmpty();return this.expandByObject(a)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.min.copy(a.min);this.max.copy(a.max);return this},makeEmpty:function(){this.min.x=
this.min.y=this.min.z=Infinity;this.max.x=this.max.y=this.max.z=-Infinity;return this},isEmpty:function(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z},getCenter:function(a){void 0===a&&(console.warn("THREE.Box3: .getCenter() target is now required"),a=new n);return this.isEmpty()?a.set(0,0,0):a.addVectors(this.min,this.max).multiplyScalar(.5)},getSize:function(a){void 0===a&&(console.warn("THREE.Box3: .getSize() target is now required"),a=new n);return this.isEmpty()?
a.set(0,0,0):a.subVectors(this.max,this.min)},expandByPoint:function(a){this.min.min(a);this.max.max(a);return this},expandByVector:function(a){this.min.sub(a);this.max.add(a);return this},expandByScalar:function(a){this.min.addScalar(-a);this.max.addScalar(a);return this},expandByObject:function(a){var b;a.updateWorldMatrix(!1,!1);var c=a.geometry;if(void 0!==c)if(c.isGeometry){var d=c.vertices;c=0;for(b=d.length;c<b;c++)ib.copy(d[c]),ib.applyMatrix4(a.matrixWorld),this.expandByPoint(ib)}else if(c.isBufferGeometry&&
(d=c.attributes.position,void 0!==d))for(c=0,b=d.count;c<b;c++)ib.fromBufferAttribute(d,c).applyMatrix4(a.matrixWorld),this.expandByPoint(ib);a=a.children;c=0;for(b=a.length;c<b;c++)this.expandByObject(a[c]);return this},containsPoint:function(a){return a.x<this.min.x||a.x>this.max.x||a.y<this.min.y||a.y>this.max.y||a.z<this.min.z||a.z>this.max.z?!1:!0},containsBox:function(a){return this.min.x<=a.min.x&&a.max.x<=this.max.x&&this.min.y<=a.min.y&&a.max.y<=this.max.y&&this.min.z<=a.min.z&&a.max.z<=
this.max.z},getParameter:function(a,b){void 0===b&&(console.warn("THREE.Box3: .getParameter() target is now required"),b=new n);return b.set((a.x-this.min.x)/(this.max.x-this.min.x),(a.y-this.min.y)/(this.max.y-this.min.y),(a.z-this.min.z)/(this.max.z-this.min.z))},intersectsBox:function(a){return a.max.x<this.min.x||a.min.x>this.max.x||a.max.y<this.min.y||a.min.y>this.max.y||a.max.z<this.min.z||a.min.z>this.max.z?!1:!0},intersectsSphere:function(a){this.clampPoint(a.center,ib);return ib.distanceToSquared(a.center)<=
a.radius*a.radius},intersectsPlane:function(a){if(0<a.normal.x){var b=a.normal.x*this.min.x;var c=a.normal.x*this.max.x}else b=a.normal.x*this.max.x,c=a.normal.x*this.min.x;0<a.normal.y?(b+=a.normal.y*this.min.y,c+=a.normal.y*this.max.y):(b+=a.normal.y*this.max.y,c+=a.normal.y*this.min.y);0<a.normal.z?(b+=a.normal.z*this.min.z,c+=a.normal.z*this.max.z):(b+=a.normal.z*this.max.z,c+=a.normal.z*this.min.z);return b<=-a.constant&&c>=-a.constant},intersectsTriangle:function(a){if(this.isEmpty())return!1;
this.getCenter(ye);wf.subVectors(this.max,ye);nd.subVectors(a.a,ye);od.subVectors(a.b,ye);pd.subVectors(a.c,ye);Lb.subVectors(od,nd);Mb.subVectors(pd,od);pc.subVectors(nd,pd);a=[0,-Lb.z,Lb.y,0,-Mb.z,Mb.y,0,-pc.z,pc.y,Lb.z,0,-Lb.x,Mb.z,0,-Mb.x,pc.z,0,-pc.x,-Lb.y,Lb.x,0,-Mb.y,Mb.x,0,-pc.y,pc.x,0];if(!Uf(a,nd,od,pd,wf))return!1;a=[1,0,0,0,1,0,0,0,1];if(!Uf(a,nd,od,pd,wf))return!1;xf.crossVectors(Lb,Mb);a=[xf.x,xf.y,xf.z];return Uf(a,nd,od,pd,wf)},clampPoint:function(a,b){void 0===b&&(console.warn("THREE.Box3: .clampPoint() target is now required"),
b=new n);return b.copy(a).clamp(this.min,this.max)},distanceToPoint:function(a){return ib.copy(a).clamp(this.min,this.max).sub(a).length()},getBoundingSphere:function(a){void 0===a&&console.error("THREE.Box3: .getBoundingSphere() target is now required");this.getCenter(a.center);a.radius=.5*this.getSize(ib).length();return a},intersect:function(a){this.min.max(a.min);this.max.min(a.max);this.isEmpty()&&this.makeEmpty();return this},union:function(a){this.min.min(a.min);this.max.max(a.max);return this},
applyMatrix4:function(a){if(this.isEmpty())return this;wb[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(a);wb[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(a);wb[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(a);wb[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(a);wb[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(a);wb[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(a);wb[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(a);wb[7].set(this.max.x,this.max.y,
this.max.z).applyMatrix4(a);this.setFromPoints(wb);return this},translate:function(a){this.min.add(a);this.max.add(a);return this},equals:function(a){return a.min.equals(this.min)&&a.max.equals(this.max)}});var zk=new ab;Object.assign(mb.prototype,{set:function(a,b){this.center.copy(a);this.radius=b;return this},setFromPoints:function(a,b){var c=this.center;void 0!==b?c.copy(b):zk.setFromPoints(a).getCenter(c);for(var d=b=0,e=a.length;d<e;d++)b=Math.max(b,c.distanceToSquared(a[d]));this.radius=Math.sqrt(b);
return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.center.copy(a.center);this.radius=a.radius;return this},empty:function(){return 0>=this.radius},containsPoint:function(a){return a.distanceToSquared(this.center)<=this.radius*this.radius},distanceToPoint:function(a){return a.distanceTo(this.center)-this.radius},intersectsSphere:function(a){var b=this.radius+a.radius;return a.center.distanceToSquared(this.center)<=b*b},intersectsBox:function(a){return a.intersectsSphere(this)},
intersectsPlane:function(a){return Math.abs(a.distanceToPoint(this.center))<=this.radius},clampPoint:function(a,b){var c=this.center.distanceToSquared(a);void 0===b&&(console.warn("THREE.Sphere: .clampPoint() target is now required"),b=new n);b.copy(a);c>this.radius*this.radius&&(b.sub(this.center).normalize(),b.multiplyScalar(this.radius).add(this.center));return b},getBoundingBox:function(a){void 0===a&&(console.warn("THREE.Sphere: .getBoundingBox() target is now required"),a=new ab);a.set(this.center,
this.center);a.expandByScalar(this.radius);return a},applyMatrix4:function(a){this.center.applyMatrix4(a);this.radius*=a.getMaxScaleOnAxis();return this},translate:function(a){this.center.add(a);return this},equals:function(a){return a.center.equals(this.center)&&a.radius===this.radius}});var xb=new n,Ng=new n,yf=new n,Nb=new n,Og=new n,zf=new n,Pg=new n;Object.assign(Rb.prototype,{set:function(a,b){this.origin.copy(a);this.direction.copy(b);return this},clone:function(){return(new this.constructor).copy(this)},
copy:function(a){this.origin.copy(a.origin);this.direction.copy(a.direction);return this},at:function(a,b){void 0===b&&(console.warn("THREE.Ray: .at() target is now required"),b=new n);return b.copy(this.direction).multiplyScalar(a).add(this.origin)},lookAt:function(a){this.direction.copy(a).sub(this.origin).normalize();return this},recast:function(a){this.origin.copy(this.at(a,xb));return this},closestPointToPoint:function(a,b){void 0===b&&(console.warn("THREE.Ray: .closestPointToPoint() target is now required"),
b=new n);b.subVectors(a,this.origin);a=b.dot(this.direction);return 0>a?b.copy(this.origin):b.copy(this.direction).multiplyScalar(a).add(this.origin)},distanceToPoint:function(a){return Math.sqrt(this.distanceSqToPoint(a))},distanceSqToPoint:function(a){var b=xb.subVectors(a,this.origin).dot(this.direction);if(0>b)return this.origin.distanceToSquared(a);xb.copy(this.direction).multiplyScalar(b).add(this.origin);return xb.distanceToSquared(a)},distanceSqToSegment:function(a,b,c,d){Ng.copy(a).add(b).multiplyScalar(.5);
yf.copy(b).sub(a).normalize();Nb.copy(this.origin).sub(Ng);var e=.5*a.distanceTo(b),f=-this.direction.dot(yf),g=Nb.dot(this.direction),h=-Nb.dot(yf),l=Nb.lengthSq(),m=Math.abs(1-f*f);if(0<m){a=f*h-g;b=f*g-h;var k=e*m;0<=a?b>=-k?b<=k?(e=1/m,a*=e,b*=e,f=a*(a+f*b+2*g)+b*(f*a+b+2*h)+l):(b=e,a=Math.max(0,-(f*b+g)),f=-a*a+b*(b+2*h)+l):(b=-e,a=Math.max(0,-(f*b+g)),f=-a*a+b*(b+2*h)+l):b<=-k?(a=Math.max(0,-(-f*e+g)),b=0<a?-e:Math.min(Math.max(-e,-h),e),f=-a*a+b*(b+2*h)+l):b<=k?(a=0,b=Math.min(Math.max(-e,
-h),e),f=b*(b+2*h)+l):(a=Math.max(0,-(f*e+g)),b=0<a?e:Math.min(Math.max(-e,-h),e),f=-a*a+b*(b+2*h)+l)}else b=0<f?-e:e,a=Math.max(0,-(f*b+g)),f=-a*a+b*(b+2*h)+l;c&&c.copy(this.direction).multiplyScalar(a).add(this.origin);d&&d.copy(yf).multiplyScalar(b).add(Ng);return f},intersectSphere:function(a,b){xb.subVectors(a.center,this.origin);var c=xb.dot(this.direction),d=xb.dot(xb)-c*c;a=a.radius*a.radius;if(d>a)return null;a=Math.sqrt(a-d);d=c-a;c+=a;return 0>d&&0>c?null:0>d?this.at(c,b):this.at(d,b)},
intersectsSphere:function(a){return this.distanceSqToPoint(a.center)<=a.radius*a.radius},distanceToPlane:function(a){var b=a.normal.dot(this.direction);if(0===b)return 0===a.distanceToPoint(this.origin)?0:null;a=-(this.origin.dot(a.normal)+a.constant)/b;return 0<=a?a:null},intersectPlane:function(a,b){a=this.distanceToPlane(a);return null===a?null:this.at(a,b)},intersectsPlane:function(a){var b=a.distanceToPoint(this.origin);return 0===b||0>a.normal.dot(this.direction)*b?!0:!1},intersectBox:function(a,
b){var c=1/this.direction.x;var d=1/this.direction.y;var e=1/this.direction.z,f=this.origin;if(0<=c){var g=(a.min.x-f.x)*c;c*=a.max.x-f.x}else g=(a.max.x-f.x)*c,c*=a.min.x-f.x;if(0<=d){var h=(a.min.y-f.y)*d;d*=a.max.y-f.y}else h=(a.max.y-f.y)*d,d*=a.min.y-f.y;if(g>d||h>c)return null;if(h>g||g!==g)g=h;if(d<c||c!==c)c=d;0<=e?(h=(a.min.z-f.z)*e,a=(a.max.z-f.z)*e):(h=(a.max.z-f.z)*e,a=(a.min.z-f.z)*e);if(g>a||h>c)return null;if(h>g||g!==g)g=h;if(a<c||c!==c)c=a;return 0>c?null:this.at(0<=g?g:c,b)},intersectsBox:function(a){return null!==
this.intersectBox(a,xb)},intersectTriangle:function(a,b,c,d,e){Og.subVectors(b,a);zf.subVectors(c,a);Pg.crossVectors(Og,zf);b=this.direction.dot(Pg);if(0<b){if(d)return null;d=1}else if(0>b)d=-1,b=-b;else return null;Nb.subVectors(this.origin,a);a=d*this.direction.dot(zf.crossVectors(Nb,zf));if(0>a)return null;c=d*this.direction.dot(Og.cross(Nb));if(0>c||a+c>b)return null;a=-d*Nb.dot(Pg);return 0>a?null:this.at(a/b,e)},applyMatrix4:function(a){this.origin.applyMatrix4(a);this.direction.transformDirection(a);
return this},equals:function(a){return a.origin.equals(this.origin)&&a.direction.equals(this.direction)}});var Qg=new n,Ak=new n,Bk=new Z;Object.assign(Oa.prototype,{isPlane:!0,set:function(a,b){this.normal.copy(a);this.constant=b;return this},setComponents:function(a,b,c,d){this.normal.set(a,b,c);this.constant=d;return this},setFromNormalAndCoplanarPoint:function(a,b){this.normal.copy(a);this.constant=-b.dot(this.normal);return this},setFromCoplanarPoints:function(a,b,c){b=Qg.subVectors(c,b).cross(Ak.subVectors(a,
b)).normalize();this.setFromNormalAndCoplanarPoint(b,a);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.normal.copy(a.normal);this.constant=a.constant;return this},normalize:function(){var a=1/this.normal.length();this.normal.multiplyScalar(a);this.constant*=a;return this},negate:function(){this.constant*=-1;this.normal.negate();return this},distanceToPoint:function(a){return this.normal.dot(a)+this.constant},distanceToSphere:function(a){return this.distanceToPoint(a.center)-
a.radius},projectPoint:function(a,b){void 0===b&&(console.warn("THREE.Plane: .projectPoint() target is now required"),b=new n);return b.copy(this.normal).multiplyScalar(-this.distanceToPoint(a)).add(a)},intersectLine:function(a,b){void 0===b&&(console.warn("THREE.Plane: .intersectLine() target is now required"),b=new n);var c=a.delta(Qg),d=this.normal.dot(c);if(0===d){if(0===this.distanceToPoint(a.start))return b.copy(a.start)}else if(d=-(a.start.dot(this.normal)+this.constant)/d,!(0>d||1<d))return b.copy(c).multiplyScalar(d).add(a.start)},
intersectsLine:function(a){var b=this.distanceToPoint(a.start);a=this.distanceToPoint(a.end);return 0>b&&0<a||0>a&&0<b},intersectsBox:function(a){return a.intersectsPlane(this)},intersectsSphere:function(a){return a.intersectsPlane(this)},coplanarPoint:function(a){void 0===a&&(console.warn("THREE.Plane: .coplanarPoint() target is now required"),a=new n);return a.copy(this.normal).multiplyScalar(-this.constant)},applyMatrix4:function(a,b){b=b||Bk.getNormalMatrix(a);a=this.coplanarPoint(Qg).applyMatrix4(a);
b=this.normal.applyMatrix3(b).normalize();this.constant=-a.dot(b);return this},translate:function(a){this.constant-=a.dot(this.normal);return this},equals:function(a){return a.normal.equals(this.normal)&&a.constant===this.constant}});var Ya=new n,yb=new n,Rg=new n,zb=new n,qd=new n,rd=new n,si=new n,Sg=new n,Tg=new n,Ug=new n;Object.assign(ba,{getNormal:function(a,b,c,d){void 0===d&&(console.warn("THREE.Triangle: .getNormal() target is now required"),d=new n);d.subVectors(c,b);Ya.subVectors(a,b);
d.cross(Ya);a=d.lengthSq();return 0<a?d.multiplyScalar(1/Math.sqrt(a)):d.set(0,0,0)},getBarycoord:function(a,b,c,d,e){Ya.subVectors(d,b);yb.subVectors(c,b);Rg.subVectors(a,b);a=Ya.dot(Ya);b=Ya.dot(yb);c=Ya.dot(Rg);var f=yb.dot(yb);d=yb.dot(Rg);var g=a*f-b*b;void 0===e&&(console.warn("THREE.Triangle: .getBarycoord() target is now required"),e=new n);if(0===g)return e.set(-2,-1,-1);g=1/g;f=(f*c-b*d)*g;a=(a*d-b*c)*g;return e.set(1-f-a,a,f)},containsPoint:function(a,b,c,d){ba.getBarycoord(a,b,c,d,zb);
return 0<=zb.x&&0<=zb.y&&1>=zb.x+zb.y},getUV:function(a,b,c,d,e,f,g,h){this.getBarycoord(a,b,c,d,zb);h.set(0,0);h.addScaledVector(e,zb.x);h.addScaledVector(f,zb.y);h.addScaledVector(g,zb.z);return h},isFrontFacing:function(a,b,c,d){Ya.subVectors(c,b);yb.subVectors(a,b);return 0>Ya.cross(yb).dot(d)?!0:!1}});Object.assign(ba.prototype,{set:function(a,b,c){this.a.copy(a);this.b.copy(b);this.c.copy(c);return this},setFromPointsAndIndices:function(a,b,c,d){this.a.copy(a[b]);this.b.copy(a[c]);this.c.copy(a[d]);
return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.a.copy(a.a);this.b.copy(a.b);this.c.copy(a.c);return this},getArea:function(){Ya.subVectors(this.c,this.b);yb.subVectors(this.a,this.b);return.5*Ya.cross(yb).length()},getMidpoint:function(a){void 0===a&&(console.warn("THREE.Triangle: .getMidpoint() target is now required"),a=new n);return a.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)},getNormal:function(a){return ba.getNormal(this.a,this.b,
this.c,a)},getPlane:function(a){void 0===a&&(console.warn("THREE.Triangle: .getPlane() target is now required"),a=new Oa);return a.setFromCoplanarPoints(this.a,this.b,this.c)},getBarycoord:function(a,b){return ba.getBarycoord(a,this.a,this.b,this.c,b)},getUV:function(a,b,c,d,e){return ba.getUV(a,this.a,this.b,this.c,b,c,d,e)},containsPoint:function(a){return ba.containsPoint(a,this.a,this.b,this.c)},isFrontFacing:function(a){return ba.isFrontFacing(this.a,this.b,this.c,a)},intersectsBox:function(a){return a.intersectsTriangle(this)},
closestPointToPoint:function(a,b){void 0===b&&(console.warn("THREE.Triangle: .closestPointToPoint() target is now required"),b=new n);var c=this.a,d=this.b,e=this.c;qd.subVectors(d,c);rd.subVectors(e,c);Sg.subVectors(a,c);var f=qd.dot(Sg),g=rd.dot(Sg);if(0>=f&&0>=g)return b.copy(c);Tg.subVectors(a,d);var h=qd.dot(Tg),l=rd.dot(Tg);if(0<=h&&l<=h)return b.copy(d);var m=f*l-h*g;if(0>=m&&0<=f&&0>=h)return d=f/(f-h),b.copy(c).addScaledVector(qd,d);Ug.subVectors(a,e);a=qd.dot(Ug);var k=rd.dot(Ug);if(0<=
k&&a<=k)return b.copy(e);f=a*g-f*k;if(0>=f&&0<=g&&0>=k)return m=g/(g-k),b.copy(c).addScaledVector(rd,m);g=h*k-a*l;if(0>=g&&0<=l-h&&0<=a-k)return si.subVectors(e,d),m=(l-h)/(l-h+(a-k)),b.copy(d).addScaledVector(si,m);e=1/(g+f+m);d=f*e;m*=e;return b.copy(c).addScaledVector(qd,d).addScaledVector(rd,m)},equals:function(a){return a.a.equals(this.a)&&a.b.equals(this.b)&&a.c.equals(this.c)}});var ti={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,
black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,
darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,
lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,
mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,
purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},
za={h:0,s:0,l:0},Af={h:0,s:0,l:0};Object.assign(J.prototype,{isColor:!0,r:1,g:1,b:1,set:function(a){a&&a.isColor?this.copy(a):"number"===typeof a?this.setHex(a):"string"===typeof a&&this.setStyle(a);return this},setScalar:function(a){this.b=this.g=this.r=a;return this},setHex:function(a){a=Math.floor(a);this.r=(a>>16&255)/255;this.g=(a>>8&255)/255;this.b=(a&255)/255;return this},setRGB:function(a,b,c){this.r=a;this.g=b;this.b=c;return this},setHSL:function(a,b,c){a=P.euclideanModulo(a,1);b=P.clamp(b,
0,1);c=P.clamp(c,0,1);0===b?this.r=this.g=this.b=c:(b=.5>=c?c*(1+b):c+b-c*b,c=2*c-b,this.r=Vf(c,b,a+1/3),this.g=Vf(c,b,a),this.b=Vf(c,b,a-1/3));return this},setStyle:function(a){function b(b){void 0!==b&&1>parseFloat(b)&&console.warn("THREE.Color: Alpha component of "+a+" will be ignored.")}var c;if(c=/^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec(a)){var d=c[2];switch(c[1]){case "rgb":case "rgba":if(c=/^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(d))return this.r=Math.min(255,parseInt(c[1],
10))/255,this.g=Math.min(255,parseInt(c[2],10))/255,this.b=Math.min(255,parseInt(c[3],10))/255,b(c[5]),this;if(c=/^(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(d))return this.r=Math.min(100,parseInt(c[1],10))/100,this.g=Math.min(100,parseInt(c[2],10))/100,this.b=Math.min(100,parseInt(c[3],10))/100,b(c[5]),this;break;case "hsl":case "hsla":if(c=/^([0-9]*\.?[0-9]+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(d)){d=parseFloat(c[1])/360;var e=parseInt(c[2],
10)/100,f=parseInt(c[3],10)/100;b(c[5]);return this.setHSL(d,e,f)}}}else if(c=/^#([A-Fa-f0-9]+)$/.exec(a)){c=c[1];d=c.length;if(3===d)return this.r=parseInt(c.charAt(0)+c.charAt(0),16)/255,this.g=parseInt(c.charAt(1)+c.charAt(1),16)/255,this.b=parseInt(c.charAt(2)+c.charAt(2),16)/255,this;if(6===d)return this.r=parseInt(c.charAt(0)+c.charAt(1),16)/255,this.g=parseInt(c.charAt(2)+c.charAt(3),16)/255,this.b=parseInt(c.charAt(4)+c.charAt(5),16)/255,this}return a&&0<a.length?this.setColorName(a):this},
setColorName:function(a){var b=ti[a];void 0!==b?this.setHex(b):console.warn("THREE.Color: Unknown color "+a);return this},clone:function(){return new this.constructor(this.r,this.g,this.b)},copy:function(a){this.r=a.r;this.g=a.g;this.b=a.b;return this},copyGammaToLinear:function(a,b){void 0===b&&(b=2);this.r=Math.pow(a.r,b);this.g=Math.pow(a.g,b);this.b=Math.pow(a.b,b);return this},copyLinearToGamma:function(a,b){void 0===b&&(b=2);b=0<b?1/b:1;this.r=Math.pow(a.r,b);this.g=Math.pow(a.g,b);this.b=Math.pow(a.b,
b);return this},convertGammaToLinear:function(a){this.copyGammaToLinear(this,a);return this},convertLinearToGamma:function(a){this.copyLinearToGamma(this,a);return this},copySRGBToLinear:function(a){this.r=Wf(a.r);this.g=Wf(a.g);this.b=Wf(a.b);return this},copyLinearToSRGB:function(a){this.r=Xf(a.r);this.g=Xf(a.g);this.b=Xf(a.b);return this},convertSRGBToLinear:function(){this.copySRGBToLinear(this);return this},convertLinearToSRGB:function(){this.copyLinearToSRGB(this);return this},getHex:function(){return 255*
this.r<<16^255*this.g<<8^255*this.b<<0},getHexString:function(){return("000000"+this.getHex().toString(16)).slice(-6)},getHSL:function(a){void 0===a&&(console.warn("THREE.Color: .getHSL() target is now required"),a={h:0,s:0,l:0});var b=this.r,c=this.g,d=this.b,e=Math.max(b,c,d),f=Math.min(b,c,d),g,h=(f+e)/2;if(f===e)f=g=0;else{var l=e-f;f=.5>=h?l/(e+f):l/(2-e-f);switch(e){case b:g=(c-d)/l+(c<d?6:0);break;case c:g=(d-b)/l+2;break;case d:g=(b-c)/l+4}g/=6}a.h=g;a.s=f;a.l=h;return a},getStyle:function(){return"rgb("+
(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"},offsetHSL:function(a,b,c){this.getHSL(za);za.h+=a;za.s+=b;za.l+=c;this.setHSL(za.h,za.s,za.l);return this},add:function(a){this.r+=a.r;this.g+=a.g;this.b+=a.b;return this},addColors:function(a,b){this.r=a.r+b.r;this.g=a.g+b.g;this.b=a.b+b.b;return this},addScalar:function(a){this.r+=a;this.g+=a;this.b+=a;return this},sub:function(a){this.r=Math.max(0,this.r-a.r);this.g=Math.max(0,this.g-a.g);this.b=Math.max(0,this.b-a.b);return this},multiply:function(a){this.r*=
a.r;this.g*=a.g;this.b*=a.b;return this},multiplyScalar:function(a){this.r*=a;this.g*=a;this.b*=a;return this},lerp:function(a,b){this.r+=(a.r-this.r)*b;this.g+=(a.g-this.g)*b;this.b+=(a.b-this.b)*b;return this},lerpHSL:function(a,b){this.getHSL(za);a.getHSL(Af);a=P.lerp(za.h,Af.h,b);var c=P.lerp(za.s,Af.s,b);b=P.lerp(za.l,Af.l,b);this.setHSL(a,c,b);return this},equals:function(a){return a.r===this.r&&a.g===this.g&&a.b===this.b},fromArray:function(a,b){void 0===b&&(b=0);this.r=a[b];this.g=a[b+1];
this.b=a[b+2];return this},toArray:function(a,b){void 0===a&&(a=[]);void 0===b&&(b=0);a[b]=this.r;a[b+1]=this.g;a[b+2]=this.b;return a},toJSON:function(){return this.getHex()}});J.NAMES=ti;Object.assign(xc.prototype,{clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.a=a.a;this.b=a.b;this.c=a.c;this.normal.copy(a.normal);this.color.copy(a.color);this.materialIndex=a.materialIndex;for(var b=0,c=a.vertexNormals.length;b<c;b++)this.vertexNormals[b]=a.vertexNormals[b].clone();
b=0;for(c=a.vertexColors.length;b<c;b++)this.vertexColors[b]=a.vertexColors[b].clone();return this}});var Ui=0;O.prototype=Object.assign(Object.create(Aa.prototype),{constructor:O,isMaterial:!0,onBeforeCompile:function(){},setValues:function(a){if(void 0!==a)for(var b in a){var c=a[b];if(void 0===c)console.warn("THREE.Material: '"+b+"' parameter is undefined.");else if("shading"===b)console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=
1===c?!0:!1;else{var d=this[b];void 0===d?console.warn("THREE."+this.type+": '"+b+"' is not a property of this material."):d&&d.isColor?d.set(c):d&&d.isVector3&&c&&c.isVector3?d.copy(c):this[b]=c}}},toJSON:function(a){function b(a){var b=[],c;for(c in a){var d=a[c];delete d.metadata;b.push(d)}return b}var c=void 0===a||"string"===typeof a;c&&(a={textures:{},images:{}});var d={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};d.uuid=this.uuid;d.type=this.type;""!==this.name&&(d.name=
this.name);this.color&&this.color.isColor&&(d.color=this.color.getHex());void 0!==this.roughness&&(d.roughness=this.roughness);void 0!==this.metalness&&(d.metalness=this.metalness);this.sheen&&this.sheen.isColor&&(d.sheen=this.sheen.getHex());this.emissive&&this.emissive.isColor&&(d.emissive=this.emissive.getHex());this.emissiveIntensity&&1!==this.emissiveIntensity&&(d.emissiveIntensity=this.emissiveIntensity);this.specular&&this.specular.isColor&&(d.specular=this.specular.getHex());void 0!==this.shininess&&
(d.shininess=this.shininess);void 0!==this.clearcoat&&(d.clearcoat=this.clearcoat);void 0!==this.clearcoatRoughness&&(d.clearcoatRoughness=this.clearcoatRoughness);this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(d.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(a).uuid,d.clearcoatNormalScale=this.clearcoatNormalScale.toArray());this.map&&this.map.isTexture&&(d.map=this.map.toJSON(a).uuid);this.matcap&&this.matcap.isTexture&&(d.matcap=this.matcap.toJSON(a).uuid);this.alphaMap&&this.alphaMap.isTexture&&
(d.alphaMap=this.alphaMap.toJSON(a).uuid);this.lightMap&&this.lightMap.isTexture&&(d.lightMap=this.lightMap.toJSON(a).uuid);this.aoMap&&this.aoMap.isTexture&&(d.aoMap=this.aoMap.toJSON(a).uuid,d.aoMapIntensity=this.aoMapIntensity);this.bumpMap&&this.bumpMap.isTexture&&(d.bumpMap=this.bumpMap.toJSON(a).uuid,d.bumpScale=this.bumpScale);this.normalMap&&this.normalMap.isTexture&&(d.normalMap=this.normalMap.toJSON(a).uuid,d.normalMapType=this.normalMapType,d.normalScale=this.normalScale.toArray());this.displacementMap&&
this.displacementMap.isTexture&&(d.displacementMap=this.displacementMap.toJSON(a).uuid,d.displacementScale=this.displacementScale,d.displacementBias=this.displacementBias);this.roughnessMap&&this.roughnessMap.isTexture&&(d.roughnessMap=this.roughnessMap.toJSON(a).uuid);this.metalnessMap&&this.metalnessMap.isTexture&&(d.metalnessMap=this.metalnessMap.toJSON(a).uuid);this.emissiveMap&&this.emissiveMap.isTexture&&(d.emissiveMap=this.emissiveMap.toJSON(a).uuid);this.specularMap&&this.specularMap.isTexture&&
(d.specularMap=this.specularMap.toJSON(a).uuid);this.envMap&&this.envMap.isTexture&&(d.envMap=this.envMap.toJSON(a).uuid,d.reflectivity=this.reflectivity,d.refractionRatio=this.refractionRatio,void 0!==this.combine&&(d.combine=this.combine),void 0!==this.envMapIntensity&&(d.envMapIntensity=this.envMapIntensity));this.gradientMap&&this.gradientMap.isTexture&&(d.gradientMap=this.gradientMap.toJSON(a).uuid);void 0!==this.size&&(d.size=this.size);void 0!==this.sizeAttenuation&&(d.sizeAttenuation=this.sizeAttenuation);
1!==this.blending&&(d.blending=this.blending);!0===this.flatShading&&(d.flatShading=this.flatShading);0!==this.side&&(d.side=this.side);0!==this.vertexColors&&(d.vertexColors=this.vertexColors);1>this.opacity&&(d.opacity=this.opacity);!0===this.transparent&&(d.transparent=this.transparent);d.depthFunc=this.depthFunc;d.depthTest=this.depthTest;d.depthWrite=this.depthWrite;d.stencilWrite=this.stencilWrite;d.stencilWriteMask=this.stencilWriteMask;d.stencilFunc=this.stencilFunc;d.stencilRef=this.stencilRef;
d.stencilFuncMask=this.stencilFuncMask;d.stencilFail=this.stencilFail;d.stencilZFail=this.stencilZFail;d.stencilZPass=this.stencilZPass;this.rotation&&0!==this.rotation&&(d.rotation=this.rotation);!0===this.polygonOffset&&(d.polygonOffset=!0);0!==this.polygonOffsetFactor&&(d.polygonOffsetFactor=this.polygonOffsetFactor);0!==this.polygonOffsetUnits&&(d.polygonOffsetUnits=this.polygonOffsetUnits);this.linewidth&&1!==this.linewidth&&(d.linewidth=this.linewidth);void 0!==this.dashSize&&(d.dashSize=this.dashSize);
void 0!==this.gapSize&&(d.gapSize=this.gapSize);void 0!==this.scale&&(d.scale=this.scale);!0===this.dithering&&(d.dithering=!0);0<this.alphaTest&&(d.alphaTest=this.alphaTest);!0===this.premultipliedAlpha&&(d.premultipliedAlpha=this.premultipliedAlpha);!0===this.wireframe&&(d.wireframe=this.wireframe);1<this.wireframeLinewidth&&(d.wireframeLinewidth=this.wireframeLinewidth);"round"!==this.wireframeLinecap&&(d.wireframeLinecap=this.wireframeLinecap);"round"!==this.wireframeLinejoin&&(d.wireframeLinejoin=
this.wireframeLinejoin);!0===this.morphTargets&&(d.morphTargets=!0);!0===this.morphNormals&&(d.morphNormals=!0);!0===this.skinning&&(d.skinning=!0);!1===this.visible&&(d.visible=!1);!1===this.toneMapped&&(d.toneMapped=!1);"{}"!==JSON.stringify(this.userData)&&(d.userData=this.userData);c&&(c=b(a.textures),a=b(a.images),0<c.length&&(d.textures=c),0<a.length&&(d.images=a));return d},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.name=a.name;this.fog=a.fog;this.blending=
a.blending;this.side=a.side;this.flatShading=a.flatShading;this.vertexTangents=a.vertexTangents;this.vertexColors=a.vertexColors;this.opacity=a.opacity;this.transparent=a.transparent;this.blendSrc=a.blendSrc;this.blendDst=a.blendDst;this.blendEquation=a.blendEquation;this.blendSrcAlpha=a.blendSrcAlpha;this.blendDstAlpha=a.blendDstAlpha;this.blendEquationAlpha=a.blendEquationAlpha;this.depthFunc=a.depthFunc;this.depthTest=a.depthTest;this.depthWrite=a.depthWrite;this.stencilWriteMask=a.stencilWriteMask;
this.stencilFunc=a.stencilFunc;this.stencilRef=a.stencilRef;this.stencilFuncMask=a.stencilFuncMask;this.stencilFail=a.stencilFail;this.stencilZFail=a.stencilZFail;this.stencilZPass=a.stencilZPass;this.stencilWrite=a.stencilWrite;var b=a.clippingPlanes,c=null;if(null!==b){var d=b.length;c=Array(d);for(var e=0;e!==d;++e)c[e]=b[e].clone()}this.clippingPlanes=c;this.clipIntersection=a.clipIntersection;this.clipShadows=a.clipShadows;this.shadowSide=a.shadowSide;this.colorWrite=a.colorWrite;this.precision=
a.precision;this.polygonOffset=a.polygonOffset;this.polygonOffsetFactor=a.polygonOffsetFactor;this.polygonOffsetUnits=a.polygonOffsetUnits;this.dithering=a.dithering;this.alphaTest=a.alphaTest;this.premultipliedAlpha=a.premultipliedAlpha;this.visible=a.visible;this.toneMapped=a.toneMapped;this.userData=JSON.parse(JSON.stringify(a.userData));return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});Ga.prototype=Object.create(O.prototype);Ga.prototype.constructor=Ga;Ga.prototype.isMeshBasicMaterial=
!0;Ga.prototype.copy=function(a){O.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.specularMap=a.specularMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;
this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;return this};Object.defineProperty(N.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.assign(N.prototype,{isBufferAttribute:!0,onUploadCallback:function(){},setUsage:function(a){this.usage=a;return this},copy:function(a){this.name=a.name;this.array=new a.array.constructor(a.array);this.itemSize=a.itemSize;this.count=a.count;this.normalized=a.normalized;this.usage=a.usage;return this},
copyAt:function(a,b,c){a*=this.itemSize;c*=b.itemSize;for(var d=0,e=this.itemSize;d<e;d++)this.array[a+d]=b.array[c+d];return this},copyArray:function(a){this.array.set(a);return this},copyColorsArray:function(a){for(var b=this.array,c=0,d=0,e=a.length;d<e;d++){var f=a[d];void 0===f&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",d),f=new J);b[c++]=f.r;b[c++]=f.g;b[c++]=f.b}return this},copyVector2sArray:function(a){for(var b=this.array,c=0,d=0,e=a.length;d<e;d++){var f=
a[d];void 0===f&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",d),f=new B);b[c++]=f.x;b[c++]=f.y}return this},copyVector3sArray:function(a){for(var b=this.array,c=0,d=0,e=a.length;d<e;d++){var f=a[d];void 0===f&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",d),f=new n);b[c++]=f.x;b[c++]=f.y;b[c++]=f.z}return this},copyVector4sArray:function(a){for(var b=this.array,c=0,d=0,e=a.length;d<e;d++){var f=a[d];void 0===f&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",
d),f=new da);b[c++]=f.x;b[c++]=f.y;b[c++]=f.z;b[c++]=f.w}return this},set:function(a,b){void 0===b&&(b=0);this.array.set(a,b);return this},getX:function(a){return this.array[a*this.itemSize]},setX:function(a,b){this.array[a*this.itemSize]=b;return this},getY:function(a){return this.array[a*this.itemSize+1]},setY:function(a,b){this.array[a*this.itemSize+1]=b;return this},getZ:function(a){return this.array[a*this.itemSize+2]},setZ:function(a,b){this.array[a*this.itemSize+2]=b;return this},getW:function(a){return this.array[a*
this.itemSize+3]},setW:function(a,b){this.array[a*this.itemSize+3]=b;return this},setXY:function(a,b,c){a*=this.itemSize;this.array[a+0]=b;this.array[a+1]=c;return this},setXYZ:function(a,b,c,d){a*=this.itemSize;this.array[a+0]=b;this.array[a+1]=c;this.array[a+2]=d;return this},setXYZW:function(a,b,c,d,e){a*=this.itemSize;this.array[a+0]=b;this.array[a+1]=c;this.array[a+2]=d;this.array[a+3]=e;return this},onUpload:function(a){this.onUploadCallback=a;return this},clone:function(){return(new this.constructor(this.array,
this.itemSize)).copy(this)},toJSON:function(){return{itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized}}});wd.prototype=Object.create(N.prototype);wd.prototype.constructor=wd;xd.prototype=Object.create(N.prototype);xd.prototype.constructor=xd;yd.prototype=Object.create(N.prototype);yd.prototype.constructor=yd;zd.prototype=Object.create(N.prototype);zd.prototype.constructor=zd;Sb.prototype=Object.create(N.prototype);Sb.prototype.constructor=
Sb;Ad.prototype=Object.create(N.prototype);Ad.prototype.constructor=Ad;Tb.prototype=Object.create(N.prototype);Tb.prototype.constructor=Tb;A.prototype=Object.create(N.prototype);A.prototype.constructor=A;Bd.prototype=Object.create(N.prototype);Bd.prototype.constructor=Bd;Object.assign(ih.prototype,{computeGroups:function(a){var b=[],c=void 0;a=a.faces;for(var d=0;d<a.length;d++){var e=a[d];if(e.materialIndex!==c){c=e.materialIndex;void 0!==f&&(f.count=3*d-f.start,b.push(f));var f={start:3*d,materialIndex:c}}}void 0!==
f&&(f.count=3*d-f.start,b.push(f));this.groups=b},fromGeometry:function(a){var b=a.faces,c=a.vertices,d=a.faceVertexUvs,e=d[0]&&0<d[0].length,f=d[1]&&0<d[1].length,g=a.morphTargets,h=g.length;if(0<h){var l=[];for(var m=0;m<h;m++)l[m]={name:g[m].name,data:[]};this.morphTargets.position=l}var k=a.morphNormals,n=k.length;if(0<n){var u=[];for(m=0;m<n;m++)u[m]={name:k[m].name,data:[]};this.morphTargets.normal=u}var p=a.skinIndices,t=a.skinWeights,v=p.length===c.length,y=t.length===c.length;0<c.length&&
0===b.length&&console.error("THREE.DirectGeometry: Faceless geometries are not supported.");for(m=0;m<b.length;m++){var w=b[m];this.vertices.push(c[w.a],c[w.b],c[w.c]);var x=w.vertexNormals;3===x.length?this.normals.push(x[0],x[1],x[2]):(x=w.normal,this.normals.push(x,x,x));x=w.vertexColors;3===x.length?this.colors.push(x[0],x[1],x[2]):(x=w.color,this.colors.push(x,x,x));!0===e&&(x=d[0][m],void 0!==x?this.uvs.push(x[0],x[1],x[2]):(console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ",
m),this.uvs.push(new B,new B,new B)));!0===f&&(x=d[1][m],void 0!==x?this.uvs2.push(x[0],x[1],x[2]):(console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ",m),this.uvs2.push(new B,new B,new B)));for(x=0;x<h;x++){var A=g[x].vertices;l[x].data.push(A[w.a],A[w.b],A[w.c])}for(x=0;x<n;x++)A=k[x].vertexNormals[m],u[x].data.push(A.a,A.b,A.c);v&&this.skinIndices.push(p[w.a],p[w.b],p[w.c]);y&&this.skinWeights.push(t[w.a],t[w.b],t[w.c])}this.computeGroups(a);this.verticesNeedUpdate=a.verticesNeedUpdate;
this.normalsNeedUpdate=a.normalsNeedUpdate;this.colorsNeedUpdate=a.colorsNeedUpdate;this.uvsNeedUpdate=a.uvsNeedUpdate;this.groupsNeedUpdate=a.groupsNeedUpdate;null!==a.boundingSphere&&(this.boundingSphere=a.boundingSphere.clone());null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());return this}});var Vi=1,jb=new Q,Vg=new E,Bf=new n,qc=new ab,Wg=new ab,Za=new n;D.prototype=Object.assign(Object.create(Aa.prototype),{constructor:D,isBufferGeometry:!0,getIndex:function(){return this.index},
setIndex:function(a){Array.isArray(a)?this.index=new (65535<jh(a)?Tb:Sb)(a,1):this.index=a},getAttribute:function(a){return this.attributes[a]},setAttribute:function(a,b){this.attributes[a]=b;return this},deleteAttribute:function(a){delete this.attributes[a];return this},addGroup:function(a,b,c){this.groups.push({start:a,count:b,materialIndex:void 0!==c?c:0})},clearGroups:function(){this.groups=[]},setDrawRange:function(a,b){this.drawRange.start=a;this.drawRange.count=b},applyMatrix:function(a){var b=
this.attributes.position;void 0!==b&&(a.applyToBufferAttribute(b),b.needsUpdate=!0);var c=this.attributes.normal;void 0!==c&&(b=(new Z).getNormalMatrix(a),b.applyToBufferAttribute(c),c.needsUpdate=!0);c=this.attributes.tangent;void 0!==c&&(b=(new Z).getNormalMatrix(a),b.applyToBufferAttribute(c),c.needsUpdate=!0);null!==this.boundingBox&&this.computeBoundingBox();null!==this.boundingSphere&&this.computeBoundingSphere();return this},rotateX:function(a){jb.makeRotationX(a);this.applyMatrix(jb);return this},
rotateY:function(a){jb.makeRotationY(a);this.applyMatrix(jb);return this},rotateZ:function(a){jb.makeRotationZ(a);this.applyMatrix(jb);return this},translate:function(a,b,c){jb.makeTranslation(a,b,c);this.applyMatrix(jb);return this},scale:function(a,b,c){jb.makeScale(a,b,c);this.applyMatrix(jb);return this},lookAt:function(a){Vg.lookAt(a);Vg.updateMatrix();this.applyMatrix(Vg.matrix);return this},center:function(){this.computeBoundingBox();this.boundingBox.getCenter(Bf).negate();this.translate(Bf.x,
Bf.y,Bf.z);return this},setFromObject:function(a){var b=a.geometry;if(a.isPoints||a.isLine){a=new A(3*b.vertices.length,3);var c=new A(3*b.colors.length,3);this.setAttribute("position",a.copyVector3sArray(b.vertices));this.setAttribute("color",c.copyColorsArray(b.colors));b.lineDistances&&b.lineDistances.length===b.vertices.length&&(a=new A(b.lineDistances.length,1),this.setAttribute("lineDistance",a.copyArray(b.lineDistances)));null!==b.boundingSphere&&(this.boundingSphere=b.boundingSphere.clone());
null!==b.boundingBox&&(this.boundingBox=b.boundingBox.clone())}else a.isMesh&&b&&b.isGeometry&&this.fromGeometry(b);return this},setFromPoints:function(a){for(var b=[],c=0,d=a.length;c<d;c++){var e=a[c];b.push(e.x,e.y,e.z||0)}this.setAttribute("position",new A(b,3));return this},updateFromObject:function(a){var b=a.geometry;if(a.isMesh){var c=b.__directGeometry;!0===b.elementsNeedUpdate&&(c=void 0,b.elementsNeedUpdate=!1);if(void 0===c)return this.fromGeometry(b);c.verticesNeedUpdate=b.verticesNeedUpdate;
c.normalsNeedUpdate=b.normalsNeedUpdate;c.colorsNeedUpdate=b.colorsNeedUpdate;c.uvsNeedUpdate=b.uvsNeedUpdate;c.groupsNeedUpdate=b.groupsNeedUpdate;b.verticesNeedUpdate=!1;b.normalsNeedUpdate=!1;b.colorsNeedUpdate=!1;b.uvsNeedUpdate=!1;b.groupsNeedUpdate=!1;b=c}!0===b.verticesNeedUpdate&&(c=this.attributes.position,void 0!==c&&(c.copyVector3sArray(b.vertices),c.needsUpdate=!0),b.verticesNeedUpdate=!1);!0===b.normalsNeedUpdate&&(c=this.attributes.normal,void 0!==c&&(c.copyVector3sArray(b.normals),
c.needsUpdate=!0),b.normalsNeedUpdate=!1);!0===b.colorsNeedUpdate&&(c=this.attributes.color,void 0!==c&&(c.copyColorsArray(b.colors),c.needsUpdate=!0),b.colorsNeedUpdate=!1);b.uvsNeedUpdate&&(c=this.attributes.uv,void 0!==c&&(c.copyVector2sArray(b.uvs),c.needsUpdate=!0),b.uvsNeedUpdate=!1);b.lineDistancesNeedUpdate&&(c=this.attributes.lineDistance,void 0!==c&&(c.copyArray(b.lineDistances),c.needsUpdate=!0),b.lineDistancesNeedUpdate=!1);b.groupsNeedUpdate&&(b.computeGroups(a.geometry),this.groups=
b.groups,b.groupsNeedUpdate=!1);return this},fromGeometry:function(a){a.__directGeometry=(new ih).fromGeometry(a);return this.fromDirectGeometry(a.__directGeometry)},fromDirectGeometry:function(a){var b=new Float32Array(3*a.vertices.length);this.setAttribute("position",(new N(b,3)).copyVector3sArray(a.vertices));0<a.normals.length&&(b=new Float32Array(3*a.normals.length),this.setAttribute("normal",(new N(b,3)).copyVector3sArray(a.normals)));0<a.colors.length&&(b=new Float32Array(3*a.colors.length),
this.setAttribute("color",(new N(b,3)).copyColorsArray(a.colors)));0<a.uvs.length&&(b=new Float32Array(2*a.uvs.length),this.setAttribute("uv",(new N(b,2)).copyVector2sArray(a.uvs)));0<a.uvs2.length&&(b=new Float32Array(2*a.uvs2.length),this.setAttribute("uv2",(new N(b,2)).copyVector2sArray(a.uvs2)));this.groups=a.groups;for(var c in a.morphTargets){b=[];for(var d=a.morphTargets[c],e=0,f=d.length;e<f;e++){var g=d[e],h=new A(3*g.data.length,3);h.name=g.name;b.push(h.copyVector3sArray(g.data))}this.morphAttributes[c]=
b}0<a.skinIndices.length&&(c=new A(4*a.skinIndices.length,4),this.setAttribute("skinIndex",c.copyVector4sArray(a.skinIndices)));0<a.skinWeights.length&&(c=new A(4*a.skinWeights.length,4),this.setAttribute("skinWeight",c.copyVector4sArray(a.skinWeights)));null!==a.boundingSphere&&(this.boundingSphere=a.boundingSphere.clone());null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());return this},computeBoundingBox:function(){null===this.boundingBox&&(this.boundingBox=new ab);var a=this.attributes.position,
b=this.morphAttributes.position;if(void 0!==a){if(this.boundingBox.setFromBufferAttribute(a),b){a=0;for(var c=b.length;a<c;a++)qc.setFromBufferAttribute(b[a]),this.boundingBox.expandByPoint(qc.min),this.boundingBox.expandByPoint(qc.max)}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',
this)},computeBoundingSphere:function(){null===this.boundingSphere&&(this.boundingSphere=new mb);var a=this.attributes.position,b=this.morphAttributes.position;if(a){var c=this.boundingSphere.center;qc.setFromBufferAttribute(a);if(b)for(var d=0,e=b.length;d<e;d++){var f=b[d];Wg.setFromBufferAttribute(f);qc.expandByPoint(Wg.min);qc.expandByPoint(Wg.max)}qc.getCenter(c);var g=0;d=0;for(e=a.count;d<e;d++)Za.fromBufferAttribute(a,d),g=Math.max(g,c.distanceToSquared(Za));if(b)for(d=0,e=b.length;d<e;d++){f=
b[d];a=0;for(var h=f.count;a<h;a++)Za.fromBufferAttribute(f,a),g=Math.max(g,c.distanceToSquared(Za))}this.boundingSphere.radius=Math.sqrt(g);isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}},computeFaceNormals:function(){},computeVertexNormals:function(){var a=this.index,b=this.attributes;if(b.position){var c=b.position.array;if(void 0===b.normal)this.setAttribute("normal",
new N(new Float32Array(c.length),3));else for(var d=b.normal.array,e=0,f=d.length;e<f;e++)d[e]=0;d=b.normal.array;var g=new n,h=new n,l=new n,m=new n,k=new n;if(a){var q=a.array;e=0;for(f=a.count;e<f;e+=3){a=3*q[e+0];var u=3*q[e+1];var p=3*q[e+2];g.fromArray(c,a);h.fromArray(c,u);l.fromArray(c,p);m.subVectors(l,h);k.subVectors(g,h);m.cross(k);d[a]+=m.x;d[a+1]+=m.y;d[a+2]+=m.z;d[u]+=m.x;d[u+1]+=m.y;d[u+2]+=m.z;d[p]+=m.x;d[p+1]+=m.y;d[p+2]+=m.z}}else for(e=0,f=c.length;e<f;e+=9)g.fromArray(c,e),h.fromArray(c,
e+3),l.fromArray(c,e+6),m.subVectors(l,h),k.subVectors(g,h),m.cross(k),d[e]=m.x,d[e+1]=m.y,d[e+2]=m.z,d[e+3]=m.x,d[e+4]=m.y,d[e+5]=m.z,d[e+6]=m.x,d[e+7]=m.y,d[e+8]=m.z;this.normalizeNormals();b.normal.needsUpdate=!0}},merge:function(a,b){if(a&&a.isBufferGeometry){void 0===b&&(b=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));var c=this.attributes,d;for(d in c)if(void 0!==a.attributes[d]){var e=
c[d].array,f=a.attributes[d],g=f.array,h=f.itemSize*b;f=Math.min(g.length,e.length-h);for(var l=0;l<f;l++,h++)e[h]=g[l]}return this}console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",a)},normalizeNormals:function(){for(var a=this.attributes.normal,b=0,c=a.count;b<c;b++)Za.x=a.getX(b),Za.y=a.getY(b),Za.z=a.getZ(b),Za.normalize(),a.setXYZ(b,Za.x,Za.y,Za.z)},toNonIndexed:function(){function a(a,b){var c=a.array;a=a.itemSize;for(var d=new c.constructor(b.length*
a),e,f=0,g=0,h=b.length;g<h;g++){e=b[g]*a;for(var l=0;l<a;l++)d[f++]=c[e++]}return new N(d,a)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed."),this;var b=new D,c=this.index.array,d=this.attributes,e;for(e in d){var f=d[e];f=a(f,c);b.setAttribute(e,f)}var g=this.morphAttributes;for(e in g){var h=[],l=g[e];d=0;for(var m=l.length;d<m;d++)f=l[d],f=a(f,c),h.push(f);b.morphAttributes[e]=h}c=this.groups;d=0;for(e=c.length;d<e;d++)f=c[d],b.addGroup(f.start,
f.count,f.materialIndex);return b},toJSON:function(){var a={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};a.uuid=this.uuid;a.type=this.type;""!==this.name&&(a.name=this.name);0<Object.keys(this.userData).length&&(a.userData=this.userData);if(void 0!==this.parameters){var b=this.parameters;for(m in b)void 0!==b[m]&&(a[m]=b[m]);return a}a.data={attributes:{}};b=this.index;null!==b&&(a.data.index={type:b.array.constructor.name,array:Array.prototype.slice.call(b.array)});
var c=this.attributes;for(m in c){b=c[m];var d=b.toJSON();""!==b.name&&(d.name=b.name);a.data.attributes[m]=d}c={};var e=!1;for(m in this.morphAttributes){for(var f=this.morphAttributes[m],g=[],h=0,l=f.length;h<l;h++)b=f[h],d=b.toJSON(),""!==b.name&&(d.name=b.name),g.push(d);0<g.length&&(c[m]=g,e=!0)}e&&(a.data.morphAttributes=c);var m=this.groups;0<m.length&&(a.data.groups=JSON.parse(JSON.stringify(m)));m=this.boundingSphere;null!==m&&(a.data.boundingSphere={center:m.center.toArray(),radius:m.radius});
return a},clone:function(){return(new D).copy(this)},copy:function(a){var b;this.index=null;this.attributes={};this.morphAttributes={};this.groups=[];this.boundingSphere=this.boundingBox=null;this.name=a.name;var c=a.index;null!==c&&this.setIndex(c.clone());c=a.attributes;for(g in c)this.setAttribute(g,c[g].clone());var d=a.morphAttributes;for(g in d){var e=[],f=d[g];c=0;for(b=f.length;c<b;c++)e.push(f[c].clone());this.morphAttributes[g]=e}var g=a.groups;c=0;for(b=g.length;c<b;c++)d=g[c],this.addGroup(d.start,
d.count,d.materialIndex);g=a.boundingBox;null!==g&&(this.boundingBox=g.clone());g=a.boundingSphere;null!==g&&(this.boundingSphere=g.clone());this.drawRange.start=a.drawRange.start;this.drawRange.count=a.drawRange.count;this.userData=a.userData;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});var ui=new Q,rc=new Rb,Xg=new mb,Ub=new n,Vb=new n,Wb=new n,lh=new n,mh=new n,nh=new n,Yf=new n,Zf=new n,$f=new n,yc=new B,zc=new B,Ac=new B,Cd=new n,Ee=new n;ea.prototype=Object.assign(Object.create(E.prototype),
{constructor:ea,isMesh:!0,setDrawMode:function(a){this.drawMode=a},copy:function(a){E.prototype.copy.call(this,a);this.drawMode=a.drawMode;void 0!==a.morphTargetInfluences&&(this.morphTargetInfluences=a.morphTargetInfluences.slice());void 0!==a.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},a.morphTargetDictionary));return this},updateMorphTargets:function(){var a=this.geometry;if(a.isBufferGeometry){a=a.morphAttributes;var b=Object.keys(a);if(0<b.length){var c=a[b[0]];if(void 0!==
c)for(this.morphTargetInfluences=[],this.morphTargetDictionary={},a=0,b=c.length;a<b;a++){var d=c[a].name||String(a);this.morphTargetInfluences.push(0);this.morphTargetDictionary[d]=a}}}else a=a.morphTargets,void 0!==a&&0<a.length&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")},raycast:function(a,b){var c=this.geometry,d=this.material,e=this.matrixWorld;if(void 0!==d&&(null===c.boundingSphere&&c.computeBoundingSphere(),Xg.copy(c.boundingSphere),
Xg.applyMatrix4(e),!1!==a.ray.intersectsSphere(Xg)&&(ui.getInverse(e),rc.copy(a.ray).applyMatrix4(ui),null===c.boundingBox||!1!==rc.intersectsBox(c.boundingBox))))if(0!==this.drawMode)console.warn("THREE.Mesh: TriangleStripDrawMode and TriangleFanDrawMode are not supported by .raycast().");else if(c.isBufferGeometry){var f=c.index;e=c.attributes.position;var g=c.morphAttributes.position,h=c.attributes.uv,l=c.attributes.uv2,m=c.groups,k=c.drawRange,n,u;if(null!==f)if(Array.isArray(d)){var p=0;for(n=
m.length;p<n;p++){var t=m[p];var v=d[t.materialIndex];var y=Math.max(t.start,k.start);for(u=c=Math.min(t.start+t.count,k.start+k.count);y<u;y+=3){c=f.getX(y);var w=f.getX(y+1);var x=f.getX(y+2);if(c=Fe(this,v,a,rc,e,g,h,l,c,w,x))c.faceIndex=Math.floor(y/3),c.face.materialIndex=t.materialIndex,b.push(c)}}}else for(y=Math.max(0,k.start),c=Math.min(f.count,k.start+k.count),p=y,n=c;p<n;p+=3){if(c=f.getX(p),w=f.getX(p+1),x=f.getX(p+2),c=Fe(this,d,a,rc,e,g,h,l,c,w,x))c.faceIndex=Math.floor(p/3),b.push(c)}else if(void 0!==
e)if(Array.isArray(d))for(p=0,n=m.length;p<n;p++)for(t=m[p],v=d[t.materialIndex],y=Math.max(t.start,k.start),u=c=Math.min(t.start+t.count,k.start+k.count);y<u;y+=3){if(c=y,w=y+1,x=y+2,c=Fe(this,v,a,rc,e,g,h,l,c,w,x))c.faceIndex=Math.floor(y/3),c.face.materialIndex=t.materialIndex,b.push(c)}else for(y=Math.max(0,k.start),c=Math.min(e.count,k.start+k.count),p=y,n=c;p<n;p+=3)if(c=p,w=p+1,x=p+2,c=Fe(this,d,a,rc,e,g,h,l,c,w,x))c.faceIndex=Math.floor(p/3),b.push(c)}else if(c.isGeometry)for(e=Array.isArray(d),
g=c.vertices,h=c.faces,c=c.faceVertexUvs[0],0<c.length&&(f=c),p=0,n=h.length;p<n;p++)if(t=h[p],c=e?d[t.materialIndex]:d,void 0!==c&&(l=g[t.a],m=g[t.b],k=g[t.c],c=kh(this,c,a,rc,l,m,k,Cd)))f&&f[p]&&(v=f[p],yc.copy(v[0]),zc.copy(v[1]),Ac.copy(v[2]),c.uv=ba.getUV(Cd,l,m,k,yc,zc,Ac,new B)),c.face=t,c.faceIndex=p,b.push(c)},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});var Wi=0,kb=new Q,Yg=new E,Cf=new n;G.prototype=Object.assign(Object.create(Aa.prototype),{constructor:G,
isGeometry:!0,applyMatrix:function(a){for(var b=(new Z).getNormalMatrix(a),c=0,d=this.vertices.length;c<d;c++)this.vertices[c].applyMatrix4(a);c=0;for(d=this.faces.length;c<d;c++){a=this.faces[c];a.normal.applyMatrix3(b).normalize();for(var e=0,f=a.vertexNormals.length;e<f;e++)a.vertexNormals[e].applyMatrix3(b).normalize()}null!==this.boundingBox&&this.computeBoundingBox();null!==this.boundingSphere&&this.computeBoundingSphere();this.normalsNeedUpdate=this.verticesNeedUpdate=!0;return this},rotateX:function(a){kb.makeRotationX(a);
this.applyMatrix(kb);return this},rotateY:function(a){kb.makeRotationY(a);this.applyMatrix(kb);return this},rotateZ:function(a){kb.makeRotationZ(a);this.applyMatrix(kb);return this},translate:function(a,b,c){kb.makeTranslation(a,b,c);this.applyMatrix(kb);return this},scale:function(a,b,c){kb.makeScale(a,b,c);this.applyMatrix(kb);return this},lookAt:function(a){Yg.lookAt(a);Yg.updateMatrix();this.applyMatrix(Yg.matrix);return this},fromBufferGeometry:function(a){function b(a,b,d,e){var f=void 0===
h?[]:[c.colors[a].clone(),c.colors[b].clone(),c.colors[d].clone()],k=void 0===g?[]:[(new n).fromArray(g,3*a),(new n).fromArray(g,3*b),(new n).fromArray(g,3*d)];e=new xc(a,b,d,k,f,e);c.faces.push(e);void 0!==l&&c.faceVertexUvs[0].push([(new B).fromArray(l,2*a),(new B).fromArray(l,2*b),(new B).fromArray(l,2*d)]);void 0!==m&&c.faceVertexUvs[1].push([(new B).fromArray(m,2*a),(new B).fromArray(m,2*b),(new B).fromArray(m,2*d)])}var c=this,d=null!==a.index?a.index.array:void 0,e=a.attributes;if(void 0===
e.position)return console.error("THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion."),this;var f=e.position.array,g=void 0!==e.normal?e.normal.array:void 0,h=void 0!==e.color?e.color.array:void 0,l=void 0!==e.uv?e.uv.array:void 0,m=void 0!==e.uv2?e.uv2.array:void 0;void 0!==m&&(this.faceVertexUvs[1]=[]);for(e=0;e<f.length;e+=3)c.vertices.push((new n).fromArray(f,e)),void 0!==h&&c.colors.push((new J).fromArray(h,e));var k=a.groups;if(0<k.length)for(e=0;e<k.length;e++){f=
k[e];var q=f.start,u=q;for(q+=f.count;u<q;u+=3)void 0!==d?b(d[u],d[u+1],d[u+2],f.materialIndex):b(u,u+1,u+2,f.materialIndex)}else if(void 0!==d)for(e=0;e<d.length;e+=3)b(d[e],d[e+1],d[e+2]);else for(e=0;e<f.length/3;e+=3)b(e,e+1,e+2);this.computeFaceNormals();null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());null!==a.boundingSphere&&(this.boundingSphere=a.boundingSphere.clone());return this},center:function(){this.computeBoundingBox();this.boundingBox.getCenter(Cf).negate();this.translate(Cf.x,
Cf.y,Cf.z);return this},normalize:function(){this.computeBoundingSphere();var a=this.boundingSphere.center,b=this.boundingSphere.radius;b=0===b?1:1/b;var c=new Q;c.set(b,0,0,-b*a.x,0,b,0,-b*a.y,0,0,b,-b*a.z,0,0,0,1);this.applyMatrix(c);return this},computeFaceNormals:function(){for(var a=new n,b=new n,c=0,d=this.faces.length;c<d;c++){var e=this.faces[c],f=this.vertices[e.a],g=this.vertices[e.b];a.subVectors(this.vertices[e.c],g);b.subVectors(f,g);a.cross(b);a.normalize();e.normal.copy(a)}},computeVertexNormals:function(a){void 0===
a&&(a=!0);var b;var c=Array(this.vertices.length);var d=0;for(b=this.vertices.length;d<b;d++)c[d]=new n;if(a){var e=new n,f=new n;a=0;for(d=this.faces.length;a<d;a++){b=this.faces[a];var g=this.vertices[b.a];var h=this.vertices[b.b];var l=this.vertices[b.c];e.subVectors(l,h);f.subVectors(g,h);e.cross(f);c[b.a].add(e);c[b.b].add(e);c[b.c].add(e)}}else for(this.computeFaceNormals(),a=0,d=this.faces.length;a<d;a++)b=this.faces[a],c[b.a].add(b.normal),c[b.b].add(b.normal),c[b.c].add(b.normal);d=0;for(b=
this.vertices.length;d<b;d++)c[d].normalize();a=0;for(d=this.faces.length;a<d;a++)b=this.faces[a],g=b.vertexNormals,3===g.length?(g[0].copy(c[b.a]),g[1].copy(c[b.b]),g[2].copy(c[b.c])):(g[0]=c[b.a].clone(),g[1]=c[b.b].clone(),g[2]=c[b.c].clone());0<this.faces.length&&(this.normalsNeedUpdate=!0)},computeFlatVertexNormals:function(){var a;this.computeFaceNormals();var b=0;for(a=this.faces.length;b<a;b++){var c=this.faces[b];var d=c.vertexNormals;3===d.length?(d[0].copy(c.normal),d[1].copy(c.normal),
d[2].copy(c.normal)):(d[0]=c.normal.clone(),d[1]=c.normal.clone(),d[2]=c.normal.clone())}0<this.faces.length&&(this.normalsNeedUpdate=!0)},computeMorphNormals:function(){var a,b;var c=0;for(b=this.faces.length;c<b;c++){var d=this.faces[c];d.__originalFaceNormal?d.__originalFaceNormal.copy(d.normal):d.__originalFaceNormal=d.normal.clone();d.__originalVertexNormals||(d.__originalVertexNormals=[]);var e=0;for(a=d.vertexNormals.length;e<a;e++)d.__originalVertexNormals[e]?d.__originalVertexNormals[e].copy(d.vertexNormals[e]):
d.__originalVertexNormals[e]=d.vertexNormals[e].clone()}var f=new G;f.faces=this.faces;e=0;for(a=this.morphTargets.length;e<a;e++){if(!this.morphNormals[e]){this.morphNormals[e]={};this.morphNormals[e].faceNormals=[];this.morphNormals[e].vertexNormals=[];d=this.morphNormals[e].faceNormals;var g=this.morphNormals[e].vertexNormals;c=0;for(b=this.faces.length;c<b;c++){var h=new n;var l={a:new n,b:new n,c:new n};d.push(h);g.push(l)}}g=this.morphNormals[e];f.vertices=this.morphTargets[e].vertices;f.computeFaceNormals();
f.computeVertexNormals();c=0;for(b=this.faces.length;c<b;c++)d=this.faces[c],h=g.faceNormals[c],l=g.vertexNormals[c],h.copy(d.normal),l.a.copy(d.vertexNormals[0]),l.b.copy(d.vertexNormals[1]),l.c.copy(d.vertexNormals[2])}c=0;for(b=this.faces.length;c<b;c++)d=this.faces[c],d.normal=d.__originalFaceNormal,d.vertexNormals=d.__originalVertexNormals},computeBoundingBox:function(){null===this.boundingBox&&(this.boundingBox=new ab);this.boundingBox.setFromPoints(this.vertices)},computeBoundingSphere:function(){null===
this.boundingSphere&&(this.boundingSphere=new mb);this.boundingSphere.setFromPoints(this.vertices)},merge:function(a,b,c){if(a&&a.isGeometry){var d,e=this.vertices.length,f=this.vertices,g=a.vertices,h=this.faces,l=a.faces,m=this.colors,k=a.colors;void 0===c&&(c=0);void 0!==b&&(d=(new Z).getNormalMatrix(b));for(var n=0,u=g.length;n<u;n++){var p=g[n].clone();void 0!==b&&p.applyMatrix4(b);f.push(p)}n=0;for(u=k.length;n<u;n++)m.push(k[n].clone());n=0;for(u=l.length;n<u;n++){g=l[n];var t=g.vertexNormals;
k=g.vertexColors;m=new xc(g.a+e,g.b+e,g.c+e);m.normal.copy(g.normal);void 0!==d&&m.normal.applyMatrix3(d).normalize();b=0;for(f=t.length;b<f;b++)p=t[b].clone(),void 0!==d&&p.applyMatrix3(d).normalize(),m.vertexNormals.push(p);m.color.copy(g.color);b=0;for(f=k.length;b<f;b++)p=k[b],m.vertexColors.push(p.clone());m.materialIndex=g.materialIndex+c;h.push(m)}n=0;for(u=a.faceVertexUvs.length;n<u;n++)for(c=a.faceVertexUvs[n],void 0===this.faceVertexUvs[n]&&(this.faceVertexUvs[n]=[]),b=0,f=c.length;b<f;b++){d=
c[b];e=[];h=0;for(l=d.length;h<l;h++)e.push(d[h].clone());this.faceVertexUvs[n].push(e)}}else console.error("THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.",a)},mergeMesh:function(a){a&&a.isMesh?(a.matrixAutoUpdate&&a.updateMatrix(),this.merge(a.geometry,a.matrix)):console.error("THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.",a)},mergeVertices:function(){var a={},b=[],c=[],d=Math.pow(10,4),e;var f=0;for(e=this.vertices.length;f<e;f++){var g=this.vertices[f];
g=Math.round(g.x*d)+"_"+Math.round(g.y*d)+"_"+Math.round(g.z*d);void 0===a[g]?(a[g]=f,b.push(this.vertices[f]),c[f]=b.length-1):c[f]=c[a[g]]}a=[];f=0;for(e=this.faces.length;f<e;f++)for(d=this.faces[f],d.a=c[d.a],d.b=c[d.b],d.c=c[d.c],d=[d.a,d.b,d.c],g=0;3>g;g++)if(d[g]===d[(g+1)%3]){a.push(f);break}for(f=a.length-1;0<=f;f--)for(d=a[f],this.faces.splice(d,1),c=0,e=this.faceVertexUvs.length;c<e;c++)this.faceVertexUvs[c].splice(d,1);f=this.vertices.length-b.length;this.vertices=b;return f},setFromPoints:function(a){this.vertices=
[];for(var b=0,c=a.length;b<c;b++){var d=a[b];this.vertices.push(new n(d.x,d.y,d.z||0))}return this},sortFacesByMaterialIndex:function(){for(var a=this.faces,b=a.length,c=0;c<b;c++)a[c]._id=c;a.sort(function(a,b){return a.materialIndex-b.materialIndex});var d=this.faceVertexUvs[0],e=this.faceVertexUvs[1],f,g;d&&d.length===b&&(f=[]);e&&e.length===b&&(g=[]);for(c=0;c<b;c++){var h=a[c]._id;f&&f.push(d[h]);g&&g.push(e[h])}f&&(this.faceVertexUvs[0]=f);g&&(this.faceVertexUvs[1]=g)},toJSON:function(){function a(a,
b,c){return c?a|1<<b:a&~(1<<b)}function b(a){var b=a.x.toString()+a.y.toString()+a.z.toString();if(void 0!==m[b])return m[b];m[b]=l.length/3;l.push(a.x,a.y,a.z);return m[b]}function c(a){var b=a.r.toString()+a.g.toString()+a.b.toString();if(void 0!==n[b])return n[b];n[b]=k.length;k.push(a.getHex());return n[b]}function d(a){var b=a.x.toString()+a.y.toString();if(void 0!==p[b])return p[b];p[b]=u.length/2;u.push(a.x,a.y);return p[b]}var e={metadata:{version:4.5,type:"Geometry",generator:"Geometry.toJSON"}};
e.uuid=this.uuid;e.type=this.type;""!==this.name&&(e.name=this.name);if(void 0!==this.parameters){var f=this.parameters,g;for(g in f)void 0!==f[g]&&(e[g]=f[g]);return e}f=[];for(g=0;g<this.vertices.length;g++){var h=this.vertices[g];f.push(h.x,h.y,h.z)}h=[];var l=[],m={},k=[],n={},u=[],p={};for(g=0;g<this.faces.length;g++){var t=this.faces[g],v=void 0!==this.faceVertexUvs[0][g],y=0<t.normal.length(),w=0<t.vertexNormals.length,x=1!==t.color.r||1!==t.color.g||1!==t.color.b,B=0<t.vertexColors.length,
A=0;A=a(A,0,0);A=a(A,1,!0);A=a(A,2,!1);A=a(A,3,v);A=a(A,4,y);A=a(A,5,w);A=a(A,6,x);A=a(A,7,B);h.push(A);h.push(t.a,t.b,t.c);h.push(t.materialIndex);v&&(v=this.faceVertexUvs[0][g],h.push(d(v[0]),d(v[1]),d(v[2])));y&&h.push(b(t.normal));w&&(y=t.vertexNormals,h.push(b(y[0]),b(y[1]),b(y[2])));x&&h.push(c(t.color));B&&(t=t.vertexColors,h.push(c(t[0]),c(t[1]),c(t[2])))}e.data={};e.data.vertices=f;e.data.normals=l;0<k.length&&(e.data.colors=k);0<u.length&&(e.data.uvs=[u]);e.data.faces=h;return e},clone:function(){return(new G).copy(this)},
copy:function(a){var b,c,d;this.vertices=[];this.colors=[];this.faces=[];this.faceVertexUvs=[[]];this.morphTargets=[];this.morphNormals=[];this.skinWeights=[];this.skinIndices=[];this.lineDistances=[];this.boundingSphere=this.boundingBox=null;this.name=a.name;var e=a.vertices;var f=0;for(b=e.length;f<b;f++)this.vertices.push(e[f].clone());e=a.colors;f=0;for(b=e.length;f<b;f++)this.colors.push(e[f].clone());e=a.faces;f=0;for(b=e.length;f<b;f++)this.faces.push(e[f].clone());f=0;for(b=a.faceVertexUvs.length;f<
b;f++){var g=a.faceVertexUvs[f];void 0===this.faceVertexUvs[f]&&(this.faceVertexUvs[f]=[]);e=0;for(c=g.length;e<c;e++){var h=g[e],l=[];var m=0;for(d=h.length;m<d;m++)l.push(h[m].clone());this.faceVertexUvs[f].push(l)}}m=a.morphTargets;f=0;for(b=m.length;f<b;f++){d={};d.name=m[f].name;if(void 0!==m[f].vertices)for(d.vertices=[],e=0,c=m[f].vertices.length;e<c;e++)d.vertices.push(m[f].vertices[e].clone());if(void 0!==m[f].normals)for(d.normals=[],e=0,c=m[f].normals.length;e<c;e++)d.normals.push(m[f].normals[e].clone());
this.morphTargets.push(d)}m=a.morphNormals;f=0;for(b=m.length;f<b;f++){d={};if(void 0!==m[f].vertexNormals)for(d.vertexNormals=[],e=0,c=m[f].vertexNormals.length;e<c;e++)g=m[f].vertexNormals[e],h={},h.a=g.a.clone(),h.b=g.b.clone(),h.c=g.c.clone(),d.vertexNormals.push(h);if(void 0!==m[f].faceNormals)for(d.faceNormals=[],e=0,c=m[f].faceNormals.length;e<c;e++)d.faceNormals.push(m[f].faceNormals[e].clone());this.morphNormals.push(d)}e=a.skinWeights;f=0;for(b=e.length;f<b;f++)this.skinWeights.push(e[f].clone());
e=a.skinIndices;f=0;for(b=e.length;f<b;f++)this.skinIndices.push(e[f].clone());e=a.lineDistances;f=0;for(b=e.length;f<b;f++)this.lineDistances.push(e[f]);f=a.boundingBox;null!==f&&(this.boundingBox=f.clone());f=a.boundingSphere;null!==f&&(this.boundingSphere=f.clone());this.elementsNeedUpdate=a.elementsNeedUpdate;this.verticesNeedUpdate=a.verticesNeedUpdate;this.uvsNeedUpdate=a.uvsNeedUpdate;this.normalsNeedUpdate=a.normalsNeedUpdate;this.colorsNeedUpdate=a.colorsNeedUpdate;this.lineDistancesNeedUpdate=
a.lineDistancesNeedUpdate;this.groupsNeedUpdate=a.groupsNeedUpdate;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});var Zg=function(a){function b(b,d,e,f,g,h){a.call(this);this.type="BoxGeometry";this.parameters={width:b,height:d,depth:e,widthSegments:f,heightSegments:g,depthSegments:h};this.fromBufferGeometry(new Fd(b,d,e,f,g,h));this.mergeVertices()}a&&(b.__proto__=a);b.prototype=Object.create(a&&a.prototype);return b.prototype.constructor=b}(G),Fd=function(a){function b(b,
d,e,f,g,h){function c(a,b,c,d,e,f,g,h,l,r,A){var w=f/l,y=g/r,x=f/2,z=g/2,B=h/2;g=l+1;var E=r+1,I=f=0,C,F,D=new n;for(F=0;F<E;F++){var G=F*y-z;for(C=0;C<g;C++)D[a]=(C*w-x)*d,D[b]=G*e,D[c]=B,q.push(D.x,D.y,D.z),D[a]=0,D[b]=0,D[c]=0<h?1:-1,u.push(D.x,D.y,D.z),p.push(C/l),p.push(1-F/r),f+=1}for(F=0;F<r;F++)for(C=0;C<l;C++)a=t+C+g*(F+1),b=t+(C+1)+g*(F+1),c=t+(C+1)+g*F,k.push(t+C+g*F,a,c),k.push(a,b,c),I+=6;m.addGroup(v,I,A);v+=I;t+=f}a.call(this);this.type="BoxBufferGeometry";this.parameters={width:b,
height:d,depth:e,widthSegments:f,heightSegments:g,depthSegments:h};var m=this;b=b||1;d=d||1;e=e||1;f=Math.floor(f)||1;g=Math.floor(g)||1;h=Math.floor(h)||1;var k=[],q=[],u=[],p=[],t=0,v=0;c("z","y","x",-1,-1,e,d,b,h,g,0);c("z","y","x",1,-1,e,d,-b,h,g,1);c("x","z","y",1,1,b,e,d,f,h,2);c("x","z","y",1,-1,b,e,-d,f,h,3);c("x","y","z",1,-1,b,d,e,f,g,4);c("x","y","z",-1,-1,b,d,-e,f,g,5);this.setIndex(k);this.setAttribute("position",new A(q,3));this.setAttribute("normal",new A(u,3));this.setAttribute("uv",
new A(p,2))}a&&(b.__proto__=a);b.prototype=Object.create(a&&a.prototype);return b.prototype.constructor=b}(D),Ck={clone:Xb,merge:ua};va.prototype=Object.create(O.prototype);va.prototype.constructor=va;va.prototype.isShaderMaterial=!0;va.prototype.copy=function(a){O.prototype.copy.call(this,a);this.fragmentShader=a.fragmentShader;this.vertexShader=a.vertexShader;this.uniforms=Xb(a.uniforms);this.defines=Object.assign({},a.defines);this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;
this.lights=a.lights;this.clipping=a.clipping;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;this.extensions=a.extensions;return this};va.prototype.toJSON=function(a){var b=O.prototype.toJSON.call(this,a);b.uniforms={};for(var c in this.uniforms){var d=this.uniforms[c].value;b.uniforms[c]=d&&d.isTexture?{type:"t",value:d.toJSON(a).uuid}:d&&d.isColor?{type:"c",value:d.getHex()}:d&&d.isVector2?{type:"v2",value:d.toArray()}:d&&d.isVector3?{type:"v3",value:d.toArray()}:
d&&d.isVector4?{type:"v4",value:d.toArray()}:d&&d.isMatrix3?{type:"m3",value:d.toArray()}:d&&d.isMatrix4?{type:"m4",value:d.toArray()}:{value:d}}0<Object.keys(this.defines).length&&(b.defines=this.defines);b.vertexShader=this.vertexShader;b.fragmentShader=this.fragmentShader;a={};for(var e in this.extensions)!0===this.extensions[e]&&(a[e]=!0);0<Object.keys(a).length&&(b.extensions=a);return b};bb.prototype=Object.assign(Object.create(E.prototype),{constructor:bb,isCamera:!0,copy:function(a,b){E.prototype.copy.call(this,
a,b);this.matrixWorldInverse.copy(a.matrixWorldInverse);this.projectionMatrix.copy(a.projectionMatrix);this.projectionMatrixInverse.copy(a.projectionMatrixInverse);return this},getWorldDirection:function(a){void 0===a&&(console.warn("THREE.Camera: .getWorldDirection() target is now required"),a=new n);this.updateMatrixWorld(!0);var b=this.matrixWorld.elements;return a.set(-b[8],-b[9],-b[10]).normalize()},updateMatrixWorld:function(a){E.prototype.updateMatrixWorld.call(this,a);this.matrixWorldInverse.getInverse(this.matrixWorld)},
clone:function(){return(new this.constructor).copy(this)}});U.prototype=Object.assign(Object.create(bb.prototype),{constructor:U,isPerspectiveCamera:!0,copy:function(a,b){bb.prototype.copy.call(this,a,b);this.fov=a.fov;this.zoom=a.zoom;this.near=a.near;this.far=a.far;this.focus=a.focus;this.aspect=a.aspect;this.view=null===a.view?null:Object.assign({},a.view);this.filmGauge=a.filmGauge;this.filmOffset=a.filmOffset;return this},setFocalLength:function(a){a=.5*this.getFilmHeight()/a;this.fov=2*P.RAD2DEG*
Math.atan(a);this.updateProjectionMatrix()},getFocalLength:function(){var a=Math.tan(.5*P.DEG2RAD*this.fov);return.5*this.getFilmHeight()/a},getEffectiveFOV:function(){return 2*P.RAD2DEG*Math.atan(Math.tan(.5*P.DEG2RAD*this.fov)/this.zoom)},getFilmWidth:function(){return this.filmGauge*Math.min(this.aspect,1)},getFilmHeight:function(){return this.filmGauge/Math.max(this.aspect,1)},setViewOffset:function(a,b,c,d,e,f){this.aspect=a/b;null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,
offsetX:0,offsetY:0,width:1,height:1});this.view.enabled=!0;this.view.fullWidth=a;this.view.fullHeight=b;this.view.offsetX=c;this.view.offsetY=d;this.view.width=e;this.view.height=f;this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1);this.updateProjectionMatrix()},updateProjectionMatrix:function(){var a=this.near,b=a*Math.tan(.5*P.DEG2RAD*this.fov)/this.zoom,c=2*b,d=this.aspect*c,e=-.5*d,f=this.view;if(null!==this.view&&this.view.enabled){var g=f.fullWidth,
h=f.fullHeight;e+=f.offsetX*d/g;b-=f.offsetY*c/h;d*=f.width/g;c*=f.height/h}f=this.filmOffset;0!==f&&(e+=a*f/this.getFilmWidth());this.projectionMatrix.makePerspective(e,e+d,b,b-c,a,this.far);this.projectionMatrixInverse.getInverse(this.projectionMatrix)},toJSON:function(a){a=E.prototype.toJSON.call(this,a);a.object.fov=this.fov;a.object.zoom=this.zoom;a.object.near=this.near;a.object.far=this.far;a.object.focus=this.focus;a.object.aspect=this.aspect;null!==this.view&&(a.object.view=Object.assign({},
this.view));a.object.filmGauge=this.filmGauge;a.object.filmOffset=this.filmOffset;return a}});Bc.prototype=Object.create(E.prototype);Bc.prototype.constructor=Bc;Bb.prototype=Object.create(Ba.prototype);Bb.prototype.constructor=Bb;Bb.prototype.isWebGLRenderTargetCube=!0;Bb.prototype.fromEquirectangularTexture=function(a,b){this.texture.type=b.type;this.texture.format=b.format;this.texture.encoding=b.encoding;var c=new vd,d=new va({type:"CubemapFromEquirect",uniforms:Xb({tEquirect:{value:null}}),vertexShader:"varying vec3 vWorldDirection;\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}",
fragmentShader:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV;\n\tsampleUV.y = asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\tsampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n}",side:1,blending:0});d.uniforms.tEquirect.value=b;b=new ea(new Fd(5,
5,5),d);c.add(b);d=new Bc(1,10,1);d.renderTarget=this;d.renderTarget.texture.name="CubeCameraTexture";d.update(a,c);b.geometry.dispose();b.material.dispose();return this};Yb.prototype=Object.create(Y.prototype);Yb.prototype.constructor=Yb;Yb.prototype.isDataTexture=!0;var sd=new mb,Df=new n;Object.assign(Dd.prototype,{set:function(a,b,c,d,e,f){var g=this.planes;g[0].copy(a);g[1].copy(b);g[2].copy(c);g[3].copy(d);g[4].copy(e);g[5].copy(f);return this},clone:function(){return(new this.constructor).copy(this)},
copy:function(a){for(var b=this.planes,c=0;6>c;c++)b[c].copy(a.planes[c]);return this},setFromMatrix:function(a){var b=this.planes,c=a.elements;a=c[0];var d=c[1],e=c[2],f=c[3],g=c[4],h=c[5],l=c[6],m=c[7],k=c[8],n=c[9],u=c[10],p=c[11],t=c[12],v=c[13],y=c[14];c=c[15];b[0].setComponents(f-a,m-g,p-k,c-t).normalize();b[1].setComponents(f+a,m+g,p+k,c+t).normalize();b[2].setComponents(f+d,m+h,p+n,c+v).normalize();b[3].setComponents(f-d,m-h,p-n,c-v).normalize();b[4].setComponents(f-e,m-l,p-u,c-y).normalize();
b[5].setComponents(f+e,m+l,p+u,c+y).normalize();return this},intersectsObject:function(a){var b=a.geometry;null===b.boundingSphere&&b.computeBoundingSphere();sd.copy(b.boundingSphere).applyMatrix4(a.matrixWorld);return this.intersectsSphere(sd)},intersectsSprite:function(a){sd.center.set(0,0,0);sd.radius=.7071067811865476;sd.applyMatrix4(a.matrixWorld);return this.intersectsSphere(sd)},intersectsSphere:function(a){var b=this.planes,c=a.center;a=-a.radius;for(var d=0;6>d;d++)if(b[d].distanceToPoint(c)<
a)return!1;return!0},intersectsBox:function(a){for(var b=this.planes,c=0;6>c;c++){var d=b[c];Df.x=0<d.normal.x?a.max.x:a.min.x;Df.y=0<d.normal.y?a.max.y:a.min.y;Df.z=0<d.normal.z?a.max.z:a.min.z;if(0>d.distanceToPoint(Df))return!1}return!0},containsPoint:function(a){for(var b=this.planes,c=0;6>c;c++)if(0>b[c].distanceToPoint(a))return!1;return!0}});var S={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",
alphatest_fragment:"#ifdef ALPHATEST\n\tif ( diffuseColor.a < ALPHATEST ) discard;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n\t#endif\n#endif",
aomap_pars_fragment:"#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif",begin_vertex:"vec3 transformed = vec3( position );",beginnormal_vertex:"vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif",bsdfs:"vec2 integrateSpecularBRDF( const in float dotNV, const in float roughness ) {\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\treturn vec2( -1.04, 1.04 ) * a004 + r.zw;\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif( cutoffDistance > 0.0 ) {\n\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n#else\n\tif( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t}\n\treturn 1.0;\n#endif\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nvec3 F_Schlick_RoughnessDependent( const in vec3 F0, const in float dotNV, const in float roughness ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotNV - 6.98316 ) * dotNV );\n\tvec3 Fr = max( vec3( 1.0 - roughness ), F0 ) - F0;\n\treturn Fr * fresnel + F0;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( incidentLight.direction + viewDir );\n\tfloat dotNL = saturate( dot( normal, incidentLight.direction ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( G * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE  = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS  = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nvec3 BRDF_Specular_GGX_Environment( const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\treturn specularColor * brdf.x + brdf.y;\n}\nvoid BRDF_Specular_Multiscattering_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\tvec3 F = F_Schlick_RoughnessDependent( specularColor, dotNV, roughness );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\tvec3 FssEss = F * brdf.x + brdf.y;\n\tfloat Ess = brdf.x + brdf.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie(float roughness, float NoH) {\n\tfloat invAlpha  = 1.0 / roughness;\n\tfloat cos2h = NoH * NoH;\n\tfloat sin2h = max(1.0 - cos2h, 0.0078125);\treturn (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);\n}\nfloat V_Neubelt(float NoV, float NoL) {\n\treturn saturate(1.0 / (4.0 * (NoL + NoV - NoL * NoV)));\n}\nvec3 BRDF_Specular_Sheen( const in float roughness, const in vec3 L, const in GeometricContext geometry, vec3 specularColor ) {\n\tvec3 N = geometry.normal;\n\tvec3 V = geometry.viewDir;\n\tvec3 H = normalize( V + L );\n\tfloat dotNH = saturate( dot( N, H ) );\n\treturn specularColor * D_Charlie( roughness, dotNH ) * V_Neubelt( dot(N, V), dot(N, L) );\n}\n#endif",
bumpmap_pars_fragment:"#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 );\n\t\tfDet *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif",
clipping_planes_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vViewPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vViewPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",
clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\t#if ! defined( STANDARD ) && ! defined( PHONG ) && ! defined( MATCAP )\n\t\tvarying vec3 vViewPosition;\n\t#endif\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0 && ! defined( STANDARD ) && ! defined( PHONG ) && ! defined( MATCAP )\n\tvarying vec3 vViewPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0 && ! defined( STANDARD ) && ! defined( PHONG ) && ! defined( MATCAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif",
color_fragment:"#ifdef USE_COLOR\n\tdiffuseColor.rgb *= vColor;\n#endif",color_pars_fragment:"#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif",color_vertex:"#ifdef USE_COLOR\n\tvColor.xyz = color.xyz;\n#endif",common:"#define PI 3.14159265359\n#define PI2 6.28318530718\n#define PI_HALF 1.5707963267949\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\n#define LOG2 1.442695\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement(a) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract(sin(sn) * c);\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance = dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n  return m[ 2 ][ 3 ] == - 1.0;\n}",
cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n#define cubeUV_textureSize (1024.0)\nint getFaceFromDirection(vec3 direction) {\n\tvec3 absDirection = abs(direction);\n\tint face = -1;\n\tif( absDirection.x > absDirection.z ) {\n\t\tif(absDirection.x > absDirection.y )\n\t\t\tface = direction.x > 0.0 ? 0 : 3;\n\t\telse\n\t\t\tface = direction.y > 0.0 ? 1 : 4;\n\t}\n\telse {\n\t\tif(absDirection.z > absDirection.y )\n\t\t\tface = direction.z > 0.0 ? 2 : 5;\n\t\telse\n\t\t\tface = direction.y > 0.0 ? 1 : 4;\n\t}\n\treturn face;\n}\n#define cubeUV_maxLods1  (log2(cubeUV_textureSize*0.25) - 1.0)\n#define cubeUV_rangeClamp (exp2((6.0 - 1.0) * 2.0))\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\n\tfloat scale = exp2(cubeUV_maxLods1 - roughnessLevel);\n\tfloat dxRoughness = dFdx(roughness);\n\tfloat dyRoughness = dFdy(roughness);\n\tvec3 dx = dFdx( vec * scale * dxRoughness );\n\tvec3 dy = dFdy( vec * scale * dyRoughness );\n\tfloat d = max( dot( dx, dx ), dot( dy, dy ) );\n\td = clamp(d, 1.0, cubeUV_rangeClamp);\n\tfloat mipLevel = 0.5 * log2(d);\n\treturn vec2(floor(mipLevel), fract(mipLevel));\n}\n#define cubeUV_maxLods2 (log2(cubeUV_textureSize*0.25) - 2.0)\n#define cubeUV_rcpTextureSize (1.0 / cubeUV_textureSize)\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\n\tmipLevel = roughnessLevel > cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\n\tfloat a = 16.0 * cubeUV_rcpTextureSize;\n\tvec2 exp2_packed = exp2( vec2( roughnessLevel, mipLevel ) );\n\tvec2 rcp_exp2_packed = vec2( 1.0 ) / exp2_packed;\n\tfloat powScale = exp2_packed.x * exp2_packed.y;\n\tfloat scale = rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\n\tfloat mipOffset = 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\n\tbool bRes = mipLevel == 0.0;\n\tscale =  bRes && (scale < a) ? a : scale;\n\tvec3 r;\n\tvec2 offset;\n\tint face = getFaceFromDirection(direction);\n\tfloat rcpPowScale = 1.0 / powScale;\n\tif( face == 0) {\n\t\tr = vec3(direction.x, -direction.z, direction.y);\n\t\toffset = vec2(0.0+mipOffset,0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 1) {\n\t\tr = vec3(direction.y, direction.x, direction.z);\n\t\toffset = vec2(scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 2) {\n\t\tr = vec3(direction.z, direction.x, direction.y);\n\t\toffset = vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 3) {\n\t\tr = vec3(direction.x, direction.z, direction.y);\n\t\toffset = vec2(0.0+mipOffset,0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse if( face == 4) {\n\t\tr = vec3(direction.y, direction.x, -direction.z);\n\t\toffset = vec2(scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse {\n\t\tr = vec3(direction.z, -direction.x, direction.y);\n\t\toffset = vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\tr = normalize(r);\n\tfloat texelOffset = 0.5 * cubeUV_rcpTextureSize;\n\tvec2 s = ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\n\tvec2 base = offset + vec2( texelOffset );\n\treturn base + s * ( scale - 2.0 * texelOffset );\n}\n#define cubeUV_maxLods3 (log2(cubeUV_textureSize*0.25) - 3.0)\nvec4 textureCubeUV( sampler2D envMap, vec3 reflectedDirection, float roughness ) {\n\tfloat roughnessVal = roughness* cubeUV_maxLods3;\n\tfloat r1 = floor(roughnessVal);\n\tfloat r2 = r1 + 1.0;\n\tfloat t = fract(roughnessVal);\n\tvec2 mipInfo = MipLevelInfo(reflectedDirection, r1, roughness);\n\tfloat s = mipInfo.y;\n\tfloat level0 = mipInfo.x;\n\tfloat level1 = level0 + 1.0;\n\tlevel1 = level1 > 5.0 ? 5.0 : level1;\n\tlevel0 += min( floor( s + 0.5 ), 5.0 );\n\tvec2 uv_10 = getCubeUV(reflectedDirection, r1, level0);\n\tvec4 color10 = envMapTexelToLinear(texture2D(envMap, uv_10));\n\tvec2 uv_20 = getCubeUV(reflectedDirection, r2, level0);\n\tvec4 color20 = envMapTexelToLinear(texture2D(envMap, uv_20));\n\tvec4 result = mix(color10, color20, t);\n\treturn vec4(result.rgb, 1.0);\n}\n#endif",
defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\ttransformedNormal = mat3( instanceMatrix ) * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = normalMatrix * objectTangent;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",
displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",
encodings_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( gammaFactor ) ), value.a );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( 1.0 / gammaFactor ) ), value.a );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent = max( max( value.r, value.g ), value.b );\n\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * value.a * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat M = clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM = ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat D = max( maxRange / maxRGB, 1.0 );\n\tD = min( floor( D ) / 255.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value )  {\n\tvec3 Xp_Y_XYZp = cLogLuvM * value.rgb;\n\tXp_Y_XYZp = max( Xp_Y_XYZp, vec3( 1e-6, 1e-6, 1e-6 ) );\n\tvec4 vResult;\n\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w = fract( Le );\n\tvResult.z = ( Le - ( floor( vResult.w * 255.0 ) ) / 255.0 ) / 255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le = value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y = exp2( ( Le - 127.0 ) / 2.0 );\n\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB = cLogLuvInverseM * Xp_Y_XYZp.rgb;\n\treturn vec4( max( vRGB, 0.0 ), 1.0 );\n}",
envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\t\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t}  else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\tvec2 sampleUV;\n\t\treflectVec = normalize( reflectVec );\n\t\tsampleUV.y = asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\t\tsampleUV.x = atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\tvec4 envColor = texture2D( envMap, sampleUV );\n\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\treflectVec = normalize( reflectVec );\n\t\tvec3 reflectView = normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) );\n\t\tvec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\tenvColor = envMapTexelToLinear( envColor );\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif",
envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\tuniform int maxMipLevel;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",
envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, queryVec, 1.0 );\n\t\t#else\n\t\t\tvec4 envMapColor = vec4( 0.0 );\n\t\t#endif\n\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t}\n\tfloat getSpecularMIPLevel( const in float roughness, const in int maxMIPLevel ) {\n\t\tfloat maxMIPLevelScalar = float( maxMIPLevel );\n\t\tfloat sigma = PI * roughness * roughness / ( 1.0 + roughness );\n\t\tfloat desiredMIPLevel = maxMIPLevelScalar + log2( sigma );\n\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\t}\n\tvec3 getLightProbeIndirectRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in int maxMIPLevel ) {\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t  vec3 reflectVec = reflect( -viewDir, normal );\n\t\t  reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t#else\n\t\t  vec3 reflectVec = refract( -viewDir, normal, refractionRatio );\n\t\t#endif\n\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\tfloat specularMIPLevel = getSpecularMIPLevel( roughness, maxMIPLevel );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, queryReflectVec, roughness );\n\t\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\t\tvec2 sampleUV;\n\t\t\tsampleUV.y = asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\t\t\tsampleUV.x = atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\t\tvec3 reflectView = normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0,0.0,1.0 ) );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#endif\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t}\n#endif",
envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) { \n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",
fog_vertex:"#ifdef USE_FOG\n\tfogDepth = -mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float fogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",
gradientmap_pars_fragment:"#ifdef TOON\n\tuniform sampler2D gradientMap;\n\tvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\t\tfloat dotNL = dot( normal, lightDirection );\n\t\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t\t#ifdef USE_GRADIENTMAP\n\t\t\treturn texture2D( gradientMap, coord ).rgb;\n\t\t#else\n\t\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t\t#endif\n\t}\n#endif",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\treflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif",
lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n#endif",
lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in GeometricContext geometry ) {\n\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treturn irradiance;\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color = directionalLight.color;\n\t\tdirectLight.direction = directionalLight.direction;\n\t\tdirectLight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t\tfloat shadowCameraNear;\n\t\tfloat shadowCameraFar;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tdirectLight.color = pointLight.color;\n\t\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible = ( directLight.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tfloat angleCos = dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos > spotLight.coneCos ) {\n\t\t\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color = spotLight.color;\n\t\t\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible = true;\n\t\t} else {\n\t\t\tdirectLight.color = vec3( 0.0 );\n\t\t\tdirectLight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n\t\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *= PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif",
lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n\tvec3\tdiffuseColor;\n\tvec3\tspecularColor;\n\tfloat\tspecularShininess;\n\tfloat\tspecularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\t#ifdef TOON\n\t\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#else\n\t\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\t\tvec3 irradiance = dotNL * directLight.color;\n\t#endif\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)",
lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );\n#ifdef REFLECTIVITY\n\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#endif\n#ifdef CLEARCOAT\n\tmaterial.clearcoat = saturate( clearcoat );\tmaterial.clearcoatRoughness = clamp( clearcoatRoughness, 0.04, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheen;\n#endif",
lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3\tdiffuseColor;\n\tfloat\tspecularRoughness;\n\tvec3\tspecularColor;\n#ifdef CLEARCOAT\n\tfloat clearcoat;\n\tfloat clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tvec3 sheenColor;\n#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearcoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.specularRoughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNL = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = ccDotNL * directLight.color;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tccIrradiance *= PI;\n\t\t#endif\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t\treflectedLight.directSpecular += ccIrradiance * material.clearcoat * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_Sheen(\n\t\t\tmaterial.specularRoughness,\n\t\t\tdirectLight.direction,\n\t\t\tgeometry,\n\t\t\tmaterial.sheenColor\n\t\t);\n\t#else\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.normal, material.specularColor, material.specularRoughness);\n\t#endif\n\treflectedLight.directDiffuse += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNV = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular += clearcoatRadiance * material.clearcoat * BRDF_Specular_GGX_Environment( geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t\tfloat ccDotNL = ccDotNV;\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\tfloat clearcoatInv = 1.0 - clearcoatDHR;\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tBRDF_Specular_Multiscattering_Environment( geometry, material.specularColor, material.specularRoughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += clearcoatInv * radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",
lights_fragment_begin:"\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tdirectLight.color *= all( bvec3( pointLight.shadow, directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tdirectLight.color *= all( bvec3( spotLight.shadow, directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectLight.color *= all( bvec3( directionalLight.shadow, directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\tirradiance += getLightProbeIrradiance( lightProbe, geometry );\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t}\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",
lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getLightProbeIndirectIrradiance( geometry, maxMipLevel );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.normal, material.specularRoughness, maxMipLevel );\n\t#ifdef CLEARCOAT\n\t\tclearcoatRadiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness, maxMipLevel );\n\t#endif\n#endif",
lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",
logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif",
map_fragment:"#ifdef USE_MAP\n\tvec4 texelColor = texture2D( map, vUv );\n\ttexelColor = mapTexelToLinear( texelColor );\n\tdiffuseColor *= texelColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tvec4 mapTexel = texture2D( map, uv );\n\tdiffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",
map_particle_pars_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",
morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\n\tobjectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\n\tobjectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\n\tobjectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\t#ifndef USE_MORPHNORMALS\n\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif",
morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\n\ttransformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\n\ttransformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\n\ttransformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\ttransformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\n\ttransformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\n\ttransformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\n\ttransformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\n\t#endif\n#endif",
normal_fragment_begin:"#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t\tbitangent = bitangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;",
normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\t#ifdef USE_TANGENT\n\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy = normalScale * mapN.xy;\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( -vViewPosition, normal, normalScale, normalMap );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif",
normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec2 normalScale, in sampler2D normalMap ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tfloat scale = sign( st1.t * st0.s - st0.t * st1.s );\n\t\tvec3 S = normalize( ( q0 * st1.t - q1 * st0.t ) * scale );\n\t\tvec3 T = normalize( ( - q0 * st1.s + q1 * st0.s ) * scale );\n\t\tvec3 N = normalize( surf_norm );\n\t\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy *= normalScale;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tbool frontFacing = dot( cross( S, T ), N ) > 0.0;\n\t\t\tmapN.xy *= ( float( frontFacing ) * 2.0 - 1.0 );\n\t\t#else\n\t\t\tmapN.xy *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t\tmat3 tsn = mat3( S, T, N );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif",
clearcoat_normal_fragment_begin:"#ifdef CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\t#ifdef USE_TANGENT\n\t\tmat3 vTBN = mat3( tangent, bitangent, clearcoatNormal );\n\t\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy = clearcoatNormalScale * mapN.xy;\n\t\tclearcoatNormal = normalize( vTBN * mapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatNormalScale, clearcoatNormalMap );\n\t#endif\n#endif",
clearcoat_normalmap_pars_fragment:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256.,  256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 encodeHalfRGBA ( vec2 v ) {\n\tvec4 encoded = vec4( 0.0 );\n\tconst vec2 offset = vec2( 1.0 / 255.0, 0.0 );\n\tencoded.xy = vec2( v.x, fract( v.x * 255.0 ) );\n\tencoded.xy = encoded.xy - ( encoded.yy * offset );\n\tencoded.zw = vec2( v.y, fract( v.y * 255.0 ) );\n\tencoded.zw = encoded.zw - ( encoded.ww * offset );\n\treturn encoded;\n}\nvec2 decodeHalfRGBA( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn (( near + viewZ ) * far ) / (( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}",
premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",
roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn decodeHalfRGBA( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\n\t\tconst vec2 offset = vec2( 0.0, 1.0 );\n\t\tvec2 texelSize = vec2( 1.0 ) / size;\n\t\tvec2 centroidUV = ( floor( uv * size - 0.5 ) + 0.5 ) * texelSize;\n\t\tfloat lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\n\t\tfloat lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\n\t\tfloat rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\n\t\tfloat rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\n\t\tvec2 f = fract( uv * size + 0.5 );\n\t\tfloat a = mix( lb, lt, f.y );\n\t\tfloat b = mix( rb, rt, f.y );\n\t\tfloat c = mix( a, b, f.x );\n\t\treturn c;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tshadow = (\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif",
shadowmap_pars_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",
shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n#endif",
shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLight directionalLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tshadow *= all( bvec2( directionalLight.shadow, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLight spotLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tshadow *= all( bvec2( spotLight.shadow, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLight pointLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tshadow *= all( bvec2( pointLight.shadow, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#endif\n\t#endif\n\treturn shadow;\n}",
skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",
skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",
specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nuniform float toneMappingWhitePoint;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\nvec3 Uncharted2ToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( ( color * ( 2.51 * color + 0.03 ) ) / ( color * ( 2.43 * color + 0.59 ) + 0.14 ) );\n}",
uv_pars_fragment:"#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif",uv2_pars_fragment:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif",uv2_pars_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n#endif",
uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = uv2;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",
background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",cube_frag:"uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n\tvec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",
cube_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - gl_FragCoord.z ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( gl_FragCoord.z );\n\t#endif\n}",
depth_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n}",
distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}",
distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}",
equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV;\n\tsampleUV.y = asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\tsampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n\tvec4 texColor = texture2D( tEquirect, sampleUV );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",
equirect_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",
linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\tvLineDistance = scale * lineDistance;\n\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",
meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\treflectedLight.indirectDiffuse += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",
meshbasic_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_ENVMAP\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}",
meshlambert_frag:"uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\treflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",
meshlambert_vert:"#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",
meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t\tmatcapColor = matcapTexelToLinear( matcapColor );\n\t#else\n\t\tvec4 matcapColor = vec4( 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",
meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#ifndef FLAT_SHADED\n\t\tvNormal = normalize( transformedNormal );\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}",
meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",
meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",
meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define REFLECTIVITY\n\t#define CLEARCOAT\n\t#define TRANSPARENCY\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef TRANSPARENCY\n\tuniform float transparency;\n#endif\n#ifdef REFLECTIVITY\n\tuniform float reflectivity;\n#endif\n#ifdef CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheen;\n#endif\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_normalmap_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#ifdef TRANSPARENCY\n\t\tdiffuseColor.a *= saturate( 1. - transparency + linearToRelativeLuminance( reflectedLight.directSpecular + reflectedLight.indirectSpecular ) );\n\t#endif\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",
meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",
normal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}",
normal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",
points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",
points_vert:"uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}",
shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <fog_fragment>\n}",shadow_vert:"#include <fog_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",
sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",
sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}"},
L={common:{diffuse:{value:new J(15658734)},opacity:{value:1},map:{value:null},uvTransform:{value:new Z},alphaMap:{value:null}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},refractionRatio:{value:.98},maxMipLevel:{value:0}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},
normalScale:{value:new B(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:2.5E-4},fogNear:{value:1},fogFar:{value:2E3},fogColor:{value:new J(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{},shadow:{},shadowBias:{},
shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{},shadow:{},shadowBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{},shadow:{},shadowBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},
pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}}},points:{diffuse:{value:new J(15658734)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},uvTransform:{value:new Z}},sprite:{diffuse:{value:new J(15658734)},opacity:{value:1},center:{value:new B(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},
uvTransform:{value:new Z}}},cb={basic:{uniforms:ua([L.common,L.specularmap,L.envmap,L.aomap,L.lightmap,L.fog]),vertexShader:S.meshbasic_vert,fragmentShader:S.meshbasic_frag},lambert:{uniforms:ua([L.common,L.specularmap,L.envmap,L.aomap,L.lightmap,L.emissivemap,L.fog,L.lights,{emissive:{value:new J(0)}}]),vertexShader:S.meshlambert_vert,fragmentShader:S.meshlambert_frag},phong:{uniforms:ua([L.common,L.specularmap,L.envmap,L.aomap,L.lightmap,L.emissivemap,L.bumpmap,L.normalmap,L.displacementmap,L.gradientmap,
L.fog,L.lights,{emissive:{value:new J(0)},specular:{value:new J(1118481)},shininess:{value:30}}]),vertexShader:S.meshphong_vert,fragmentShader:S.meshphong_frag},standard:{uniforms:ua([L.common,L.envmap,L.aomap,L.lightmap,L.emissivemap,L.bumpmap,L.normalmap,L.displacementmap,L.roughnessmap,L.metalnessmap,L.fog,L.lights,{emissive:{value:new J(0)},roughness:{value:.5},metalness:{value:.5},envMapIntensity:{value:1}}]),vertexShader:S.meshphysical_vert,fragmentShader:S.meshphysical_frag},matcap:{uniforms:ua([L.common,
L.bumpmap,L.normalmap,L.displacementmap,L.fog,{matcap:{value:null}}]),vertexShader:S.meshmatcap_vert,fragmentShader:S.meshmatcap_frag},points:{uniforms:ua([L.points,L.fog]),vertexShader:S.points_vert,fragmentShader:S.points_frag},dashed:{uniforms:ua([L.common,L.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:S.linedashed_vert,fragmentShader:S.linedashed_frag},depth:{uniforms:ua([L.common,L.displacementmap]),vertexShader:S.depth_vert,fragmentShader:S.depth_frag},normal:{uniforms:ua([L.common,
L.bumpmap,L.normalmap,L.displacementmap,{opacity:{value:1}}]),vertexShader:S.normal_vert,fragmentShader:S.normal_frag},sprite:{uniforms:ua([L.sprite,L.fog]),vertexShader:S.sprite_vert,fragmentShader:S.sprite_frag},background:{uniforms:{uvTransform:{value:new Z},t2D:{value:null}},vertexShader:S.background_vert,fragmentShader:S.background_frag},cube:{uniforms:{tCube:{value:null},tFlip:{value:-1},opacity:{value:1}},vertexShader:S.cube_vert,fragmentShader:S.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},
vertexShader:S.equirect_vert,fragmentShader:S.equirect_frag},distanceRGBA:{uniforms:ua([L.common,L.displacementmap,{referencePosition:{value:new n},nearDistance:{value:1},farDistance:{value:1E3}}]),vertexShader:S.distanceRGBA_vert,fragmentShader:S.distanceRGBA_frag},shadow:{uniforms:ua([L.lights,L.fog,{color:{value:new J(0)},opacity:{value:1}}]),vertexShader:S.shadow_vert,fragmentShader:S.shadow_frag}};cb.physical={uniforms:ua([cb.standard.uniforms,{transparency:{value:0},clearcoat:{value:0},clearcoatRoughness:{value:0},
sheen:{value:new J(0)},clearcoatNormalScale:{value:new B(1,1)},clearcoatNormalMap:{value:null}}]),vertexShader:S.meshphysical_vert,fragmentShader:S.meshphysical_frag};Ed.prototype=Object.create(G.prototype);Ed.prototype.constructor=Ed;Zb.prototype=Object.create(D.prototype);Zb.prototype.constructor=Zb;nb.prototype=Object.create(Y.prototype);nb.prototype.constructor=nb;nb.prototype.isCubeTexture=!0;Object.defineProperty(nb.prototype,"images",{get:function(){return this.image},set:function(a){this.image=
a}});Cc.prototype=Object.create(Y.prototype);Cc.prototype.constructor=Cc;Cc.prototype.isDataTexture2DArray=!0;Dc.prototype=Object.create(Y.prototype);Dc.prototype.constructor=Dc;Dc.prototype.isDataTexture3D=!0;var uh=new Y,rj=new Cc,tj=new Dc,vh=new nb,oh=[],qh=[],th=new Float32Array(16),sh=new Float32Array(9),rh=new Float32Array(4);wh.prototype.updateCache=function(a){var b=this.cache;a instanceof Float32Array&&b.length!==a.length&&(this.cache=new Float32Array(a.length));Ha(b,a)};xh.prototype.setValue=
function(a,b,c){for(var d=this.seq,e=0,f=d.length;e!==f;++e){var g=d[e];g.setValue(a,b[g.id],c)}};var bg=/([\w\d_]+)(\])?(\[|\.)?/g;Cb.prototype.setValue=function(a,b,c,d){b=this.map[b];void 0!==b&&b.setValue(a,c,d)};Cb.prototype.setOptional=function(a,b,c){b=b[c];void 0!==b&&this.setValue(a,c,b)};Cb.upload=function(a,b,c,d){for(var e=0,f=b.length;e!==f;++e){var g=b[e],h=c[g.id];!1!==h.needsUpdate&&g.setValue(a,h.value,d)}};Cb.seqWithValue=function(a,b){for(var c=[],d=0,e=a.length;d!==e;++d){var f=
a[d];f.id in b&&c.push(f)}return c};var Yj=0,dg=/^[ \t]*#include +<([\w\d./]+)>/gm,Fh=/#pragma unroll_loop[\s]+?for \( int i = (\d+); i < (\d+); i \+\+ \) \{([\s\S]+?)(?=\})\}/g,hk=0;Db.prototype=Object.create(O.prototype);Db.prototype.constructor=Db;Db.prototype.isMeshDepthMaterial=!0;Db.prototype.copy=function(a){O.prototype.copy.call(this,a);this.depthPacking=a.depthPacking;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.map=a.map;this.alphaMap=a.alphaMap;this.displacementMap=a.displacementMap;
this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;return this};Eb.prototype=Object.create(O.prototype);Eb.prototype.constructor=Eb;Eb.prototype.isMeshDistanceMaterial=!0;Eb.prototype.copy=function(a){O.prototype.copy.call(this,a);this.referencePosition.copy(a.referencePosition);this.nearDistance=a.nearDistance;this.farDistance=a.farDistance;this.skinning=a.skinning;this.morphTargets=a.morphTargets;
this.map=a.map;this.alphaMap=a.alphaMap;this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;return this};fg.prototype=Object.assign(Object.create(Ba.prototype),{constructor:fg,isWebGLMultiviewRenderTarget:!0,copy:function(a){Ba.prototype.copy.call(this,a);this.numViews=a.numViews;return this},setNumViews:function(a){this.numViews!==a&&(this.numViews=a,this.dispose());return this}});Gc.prototype=Object.assign(Object.create(E.prototype),
{constructor:Gc,isGroup:!0});Jd.prototype=Object.assign(Object.create(U.prototype),{constructor:Jd,isArrayCamera:!0});var Mh=new n,Nh=new n;Object.assign(gg.prototype,Aa.prototype);Object.assign(Oh.prototype,Aa.prototype);Object.assign(Le.prototype,{isFogExp2:!0,clone:function(){return new Le(this.color,this.density)},toJSON:function(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}});Object.assign(Me.prototype,{isFog:!0,clone:function(){return new Me(this.color,this.near,this.far)},
toJSON:function(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}});Object.defineProperty(pb.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.assign(pb.prototype,{isInterleavedBuffer:!0,onUploadCallback:function(){},setUsage:function(a){this.usage=a;return this},copy:function(a){this.array=new a.array.constructor(a.array);this.count=a.count;this.stride=a.stride;this.usage=a.usage;return this},copyAt:function(a,b,c){a*=this.stride;c*=b.stride;for(var d=
0,e=this.stride;d<e;d++)this.array[a+d]=b.array[c+d];return this},set:function(a,b){void 0===b&&(b=0);this.array.set(a,b);return this},clone:function(){return(new this.constructor).copy(this)},onUpload:function(a){this.onUploadCallback=a;return this}});Object.defineProperties(Kd.prototype,{count:{get:function(){return this.data.count}},array:{get:function(){return this.data.array}}});Object.assign(Kd.prototype,{isInterleavedBufferAttribute:!0,setX:function(a,b){this.data.array[a*this.data.stride+
this.offset]=b;return this},setY:function(a,b){this.data.array[a*this.data.stride+this.offset+1]=b;return this},setZ:function(a,b){this.data.array[a*this.data.stride+this.offset+2]=b;return this},setW:function(a,b){this.data.array[a*this.data.stride+this.offset+3]=b;return this},getX:function(a){return this.data.array[a*this.data.stride+this.offset]},getY:function(a){return this.data.array[a*this.data.stride+this.offset+1]},getZ:function(a){return this.data.array[a*this.data.stride+this.offset+2]},
getW:function(a){return this.data.array[a*this.data.stride+this.offset+3]},setXY:function(a,b,c){a=a*this.data.stride+this.offset;this.data.array[a+0]=b;this.data.array[a+1]=c;return this},setXYZ:function(a,b,c,d){a=a*this.data.stride+this.offset;this.data.array[a+0]=b;this.data.array[a+1]=c;this.data.array[a+2]=d;return this},setXYZW:function(a,b,c,d,e){a=a*this.data.stride+this.offset;this.data.array[a+0]=b;this.data.array[a+1]=c;this.data.array[a+2]=d;this.data.array[a+3]=e;return this}});Gb.prototype=
Object.create(O.prototype);Gb.prototype.constructor=Gb;Gb.prototype.isSpriteMaterial=!0;Gb.prototype.copy=function(a){O.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.alphaMap=a.alphaMap;this.rotation=a.rotation;this.sizeAttenuation=a.sizeAttenuation;return this};var Hc,ze=new n,td=new n,ud=new n,Ic=new B,Md=new B,Qh=new Q,Ef=new n,Ae=new n,Ff=new n,vi=new B,$g=new B,wi=new B;Ld.prototype=Object.assign(Object.create(E.prototype),{constructor:Ld,isSprite:!0,raycast:function(a,
b){null===a.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.');td.setFromMatrixScale(this.matrixWorld);Qh.copy(a.camera.matrixWorld);this.modelViewMatrix.multiplyMatrices(a.camera.matrixWorldInverse,this.matrixWorld);ud.setFromMatrixPosition(this.modelViewMatrix);a.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&td.multiplyScalar(-ud.z);var c=this.material.rotation;if(0!==c){var d=Math.cos(c);var e=Math.sin(c)}c=this.center;
Ne(Ef.set(-.5,-.5,0),ud,c,td,e,d);Ne(Ae.set(.5,-.5,0),ud,c,td,e,d);Ne(Ff.set(.5,.5,0),ud,c,td,e,d);vi.set(0,0);$g.set(1,0);wi.set(1,1);var f=a.ray.intersectTriangle(Ef,Ae,Ff,!1,ze);if(null===f&&(Ne(Ae.set(-.5,.5,0),ud,c,td,e,d),$g.set(0,1),f=a.ray.intersectTriangle(Ef,Ff,Ae,!1,ze),null===f))return;e=a.ray.origin.distanceTo(ze);e<a.near||e>a.far||b.push({distance:e,point:ze.clone(),uv:ba.getUV(ze,Ef,Ae,Ff,vi,$g,wi,new B),face:null,object:this})},clone:function(){return(new this.constructor(this.material)).copy(this)},
copy:function(a){E.prototype.copy.call(this,a);void 0!==a.center&&this.center.copy(a.center);return this}});var Gf=new n,xi=new n;Nd.prototype=Object.assign(Object.create(E.prototype),{constructor:Nd,isLOD:!0,copy:function(a){E.prototype.copy.call(this,a,!1);a=a.levels;for(var b=0,c=a.length;b<c;b++){var d=a[b];this.addLevel(d.object.clone(),d.distance)}return this},addLevel:function(a,b){void 0===b&&(b=0);b=Math.abs(b);for(var c=this.levels,d=0;d<c.length&&!(b<c[d].distance);d++);c.splice(d,0,{distance:b,
object:a});this.add(a);return this},getObjectForDistance:function(a){for(var b=this.levels,c=1,d=b.length;c<d&&!(a<b[c].distance);c++);return b[c-1].object},raycast:function(a,b){Gf.setFromMatrixPosition(this.matrixWorld);var c=a.ray.origin.distanceTo(Gf);this.getObjectForDistance(c).raycast(a,b)},update:function(a){var b=this.levels;if(1<b.length){Gf.setFromMatrixPosition(a.matrixWorld);xi.setFromMatrixPosition(this.matrixWorld);a=Gf.distanceTo(xi);b[0].object.visible=!0;for(var c=1,d=b.length;c<
d;c++)if(a>=b[c].distance)b[c-1].object.visible=!1,b[c].object.visible=!0;else break;for(;c<d;c++)b[c].object.visible=!1}},toJSON:function(a){a=E.prototype.toJSON.call(this,a);a.object.levels=[];for(var b=this.levels,c=0,d=b.length;c<d;c++){var e=b[c];a.object.levels.push({object:e.object.uuid,distance:e.distance})}return a}});Od.prototype=Object.assign(Object.create(ea.prototype),{constructor:Od,isSkinnedMesh:!0,bind:function(a,b){this.skeleton=a;void 0===b&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),
b=this.matrixWorld);this.bindMatrix.copy(b);this.bindMatrixInverse.getInverse(b)},pose:function(){this.skeleton.pose()},normalizeSkinWeights:function(){for(var a=new da,b=this.geometry.attributes.skinWeight,c=0,d=b.count;c<d;c++){a.x=b.getX(c);a.y=b.getY(c);a.z=b.getZ(c);a.w=b.getW(c);var e=1/a.manhattanLength();Infinity!==e?a.multiplyScalar(e):a.set(1,0,0,0);b.setXYZW(c,a.x,a.y,a.z,a.w)}},updateMatrixWorld:function(a){ea.prototype.updateMatrixWorld.call(this,a);"attached"===this.bindMode?this.bindMatrixInverse.getInverse(this.matrixWorld):
"detached"===this.bindMode?this.bindMatrixInverse.getInverse(this.bindMatrix):console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});var yi=new Q,Dk=new Q;Object.assign(Oe.prototype,{calculateInverses:function(){this.boneInverses=[];for(var a=0,b=this.bones.length;a<b;a++){var c=new Q;this.bones[a]&&c.getInverse(this.bones[a].matrixWorld);this.boneInverses.push(c)}},pose:function(){var a,b;
var c=0;for(b=this.bones.length;c<b;c++)(a=this.bones[c])&&a.matrixWorld.getInverse(this.boneInverses[c]);c=0;for(b=this.bones.length;c<b;c++)if(a=this.bones[c])a.parent&&a.parent.isBone?(a.matrix.getInverse(a.parent.matrixWorld),a.matrix.multiply(a.matrixWorld)):a.matrix.copy(a.matrixWorld),a.matrix.decompose(a.position,a.quaternion,a.scale)},update:function(){for(var a=this.bones,b=this.boneInverses,c=this.boneMatrices,d=this.boneTexture,e=0,f=a.length;e<f;e++)yi.multiplyMatrices(a[e]?a[e].matrixWorld:
Dk,b[e]),yi.toArray(c,16*e);void 0!==d&&(d.needsUpdate=!0)},clone:function(){return new Oe(this.bones,this.boneInverses)},getBoneByName:function(a){for(var b=0,c=this.bones.length;b<c;b++){var d=this.bones[b];if(d.name===a)return d}}});ig.prototype=Object.assign(Object.create(E.prototype),{constructor:ig,isBone:!0});Pe.prototype=Object.assign(Object.create(ea.prototype),{constructor:Pe,isInstancedMesh:!0,raycast:function(){},setMatrixAt:function(a,b){b.toArray(this.instanceMatrix.array,16*a)},updateMorphTargets:function(){}});
R.prototype=Object.create(O.prototype);R.prototype.constructor=R;R.prototype.isLineBasicMaterial=!0;R.prototype.copy=function(a){O.prototype.copy.call(this,a);this.color.copy(a.color);this.linewidth=a.linewidth;this.linecap=a.linecap;this.linejoin=a.linejoin;return this};var zi=new n,Ai=new n,Bi=new Q,Hf=new Rb,Be=new mb;ra.prototype=Object.assign(Object.create(E.prototype),{constructor:ra,isLine:!0,computeLineDistances:function(){var a=this.geometry;if(a.isBufferGeometry)if(null===a.index){for(var b=
a.attributes.position,c=[0],d=1,e=b.count;d<e;d++)zi.fromBufferAttribute(b,d-1),Ai.fromBufferAttribute(b,d),c[d]=c[d-1],c[d]+=zi.distanceTo(Ai);a.setAttribute("lineDistance",new A(c,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else if(a.isGeometry)for(b=a.vertices,c=a.lineDistances,c[0]=0,d=1,e=b.length;d<e;d++)c[d]=c[d-1],c[d]+=b[d-1].distanceTo(b[d]);return this},raycast:function(a,b){var c=a.linePrecision,d=this.geometry,
e=this.matrixWorld;null===d.boundingSphere&&d.computeBoundingSphere();Be.copy(d.boundingSphere);Be.applyMatrix4(e);Be.radius+=c;if(!1!==a.ray.intersectsSphere(Be)){Bi.getInverse(e);Hf.copy(a.ray).applyMatrix4(Bi);c/=(this.scale.x+this.scale.y+this.scale.z)/3;c*=c;var f=new n,g=new n;e=new n;var h=new n,l=this&&this.isLineSegments?2:1;if(d.isBufferGeometry){var m=d.index,k=d.attributes.position.array;if(null!==m){m=m.array;d=0;for(var q=m.length-1;d<q;d+=l){var u=m[d+1];f.fromArray(k,3*m[d]);g.fromArray(k,
3*u);u=Hf.distanceSqToSegment(f,g,h,e);u>c||(h.applyMatrix4(this.matrixWorld),u=a.ray.origin.distanceTo(h),u<a.near||u>a.far||b.push({distance:u,point:e.clone().applyMatrix4(this.matrixWorld),index:d,face:null,faceIndex:null,object:this}))}}else for(d=0,q=k.length/3-1;d<q;d+=l)f.fromArray(k,3*d),g.fromArray(k,3*d+3),u=Hf.distanceSqToSegment(f,g,h,e),u>c||(h.applyMatrix4(this.matrixWorld),u=a.ray.origin.distanceTo(h),u<a.near||u>a.far||b.push({distance:u,point:e.clone().applyMatrix4(this.matrixWorld),
index:d,face:null,faceIndex:null,object:this}))}else if(d.isGeometry)for(f=d.vertices,g=f.length,d=0;d<g-1;d+=l)u=Hf.distanceSqToSegment(f[d],f[d+1],h,e),u>c||(h.applyMatrix4(this.matrixWorld),u=a.ray.origin.distanceTo(h),u<a.near||u>a.far||b.push({distance:u,point:e.clone().applyMatrix4(this.matrixWorld),index:d,face:null,faceIndex:null,object:this}))}},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});var If=new n,Jf=new n;X.prototype=Object.assign(Object.create(ra.prototype),
{constructor:X,isLineSegments:!0,computeLineDistances:function(){var a=this.geometry;if(a.isBufferGeometry)if(null===a.index){for(var b=a.attributes.position,c=[],d=0,e=b.count;d<e;d+=2)If.fromBufferAttribute(b,d),Jf.fromBufferAttribute(b,d+1),c[d]=0===d?0:c[d-1],c[d+1]=c[d]+If.distanceTo(Jf);a.setAttribute("lineDistance",new A(c,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else if(a.isGeometry)for(b=a.vertices,c=a.lineDistances,
d=0,e=b.length;d<e;d+=2)If.copy(b[d]),Jf.copy(b[d+1]),c[d]=0===d?0:c[d-1],c[d+1]=c[d]+If.distanceTo(Jf);return this}});Qe.prototype=Object.assign(Object.create(ra.prototype),{constructor:Qe,isLineLoop:!0});Qa.prototype=Object.create(O.prototype);Qa.prototype.constructor=Qa;Qa.prototype.isPointsMaterial=!0;Qa.prototype.copy=function(a){O.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.alphaMap=a.alphaMap;this.size=a.size;this.sizeAttenuation=a.sizeAttenuation;this.morphTargets=
a.morphTargets;return this};var Ci=new Q,kg=new Rb,Ce=new mb,Kf=new n;Jc.prototype=Object.assign(Object.create(E.prototype),{constructor:Jc,isPoints:!0,raycast:function(a,b){var c=this.geometry,d=this.matrixWorld,e=a.params.Points.threshold;null===c.boundingSphere&&c.computeBoundingSphere();Ce.copy(c.boundingSphere);Ce.applyMatrix4(d);Ce.radius+=e;if(!1!==a.ray.intersectsSphere(Ce))if(Ci.getInverse(d),kg.copy(a.ray).applyMatrix4(Ci),e/=(this.scale.x+this.scale.y+this.scale.z)/3,e*=e,c.isBufferGeometry){var f=
c.index;c=c.attributes.position.array;if(null!==f){var g=f.array;f=0;for(var h=g.length;f<h;f++){var l=g[f];Kf.fromArray(c,3*l);jg(Kf,l,e,d,a,b,this)}}else for(f=0,g=c.length/3;f<g;f++)Kf.fromArray(c,3*f),jg(Kf,f,e,d,a,b,this)}else for(c=c.vertices,f=0,g=c.length;f<g;f++)jg(c[f],f,e,d,a,b,this)},updateMorphTargets:function(){var a=this.geometry;if(a.isBufferGeometry){a=a.morphAttributes;var b=Object.keys(a);if(0<b.length){var c=a[b[0]];if(void 0!==c)for(this.morphTargetInfluences=[],this.morphTargetDictionary=
{},a=0,b=c.length;a<b;a++){var d=c[a].name||String(a);this.morphTargetInfluences.push(0);this.morphTargetDictionary[d]=a}}}else a=a.morphTargets,void 0!==a&&0<a.length&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});lg.prototype=Object.assign(Object.create(Y.prototype),{constructor:lg,isVideoTexture:!0,update:function(){var a=this.image;a.readyState>=
a.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}});Kc.prototype=Object.create(Y.prototype);Kc.prototype.constructor=Kc;Kc.prototype.isCompressedTexture=!0;Pd.prototype=Object.create(Y.prototype);Pd.prototype.constructor=Pd;Pd.prototype.isCanvasTexture=!0;Qd.prototype=Object.create(Y.prototype);Qd.prototype.constructor=Qd;Qd.prototype.isDepthTexture=!0;Lc.prototype=Object.create(D.prototype);Lc.prototype.constructor=Lc;Rd.prototype=Object.create(G.prototype);Rd.prototype.constructor=Rd;Mc.prototype=Object.create(D.prototype);
Mc.prototype.constructor=Mc;Sd.prototype=Object.create(G.prototype);Sd.prototype.constructor=Sd;Ea.prototype=Object.create(D.prototype);Ea.prototype.constructor=Ea;Td.prototype=Object.create(G.prototype);Td.prototype.constructor=Td;Nc.prototype=Object.create(Ea.prototype);Nc.prototype.constructor=Nc;Ud.prototype=Object.create(G.prototype);Ud.prototype.constructor=Ud;ac.prototype=Object.create(Ea.prototype);ac.prototype.constructor=ac;Vd.prototype=Object.create(G.prototype);Vd.prototype.constructor=
Vd;Oc.prototype=Object.create(Ea.prototype);Oc.prototype.constructor=Oc;Wd.prototype=Object.create(G.prototype);Wd.prototype.constructor=Wd;Pc.prototype=Object.create(Ea.prototype);Pc.prototype.constructor=Pc;Xd.prototype=Object.create(G.prototype);Xd.prototype.constructor=Xd;bc.prototype=Object.create(D.prototype);bc.prototype.constructor=bc;bc.prototype.toJSON=function(){var a=D.prototype.toJSON.call(this);a.path=this.parameters.path.toJSON();return a};Yd.prototype=Object.create(G.prototype);Yd.prototype.constructor=
Yd;Qc.prototype=Object.create(D.prototype);Qc.prototype.constructor=Qc;Zd.prototype=Object.create(G.prototype);Zd.prototype.constructor=Zd;Rc.prototype=Object.create(D.prototype);Rc.prototype.constructor=Rc;var Ek={triangulate:function(a,b,c){c=c||2;var d=b&&b.length,e=d?b[0]*c:a.length,f=Rh(a,0,e,c,!0),g=[];if(!f||f.next===f.prev)return g;var h;if(d){var l=c;d=[];var m;var k=0;for(m=b.length;k<m;k++){var n=b[k]*l;var u=k<m-1?b[k+1]*l:a.length;n=Rh(a,n,u,l,!1);n===n.next&&(n.steiner=!0);d.push(pk(n))}d.sort(nk);
for(k=0;k<d.length;k++){b=d[k];l=f;if(l=ok(b,l))b=Uh(l,b),ae(b,b.next);f=ae(f,f.next)}}if(a.length>80*c){var p=h=a[0];var t=d=a[1];for(l=c;l<e;l+=c)k=a[l],b=a[l+1],k<p&&(p=k),b<t&&(t=b),k>h&&(h=k),b>d&&(d=b);h=Math.max(h-p,d-t);h=0!==h?1/h:0}be(f,g,c,p,t,h);return g}},qb={area:function(a){for(var b=a.length,c=0,d=b-1,e=0;e<b;d=e++)c+=a[d].x*a[e].y-a[e].x*a[d].y;return.5*c},isClockWise:function(a){return 0>qb.area(a)},triangulateShape:function(a,b){var c=[],d=[],e=[];Vh(a);Wh(c,a);var f=a.length;b.forEach(Vh);
for(a=0;a<b.length;a++)d.push(f),f+=b[a].length,Wh(c,b[a]);b=Ek.triangulate(c,d);for(a=0;a<b.length;a+=3)e.push(b.slice(a,a+3));return e}};dc.prototype=Object.create(G.prototype);dc.prototype.constructor=dc;dc.prototype.toJSON=function(){var a=G.prototype.toJSON.call(this);return Xh(this.parameters.shapes,this.parameters.options,a)};db.prototype=Object.create(D.prototype);db.prototype.constructor=db;db.prototype.toJSON=function(){var a=D.prototype.toJSON.call(this);return Xh(this.parameters.shapes,
this.parameters.options,a)};var qk={generateTopUV:function(a,b,c,d,e){a=b[3*d];d=b[3*d+1];var f=b[3*e];e=b[3*e+1];return[new B(b[3*c],b[3*c+1]),new B(a,d),new B(f,e)]},generateSideWallUV:function(a,b,c,d,e,f){a=b[3*c];var g=b[3*c+1];c=b[3*c+2];var h=b[3*d],l=b[3*d+1];d=b[3*d+2];var k=b[3*e],n=b[3*e+1];e=b[3*e+2];var q=b[3*f],u=b[3*f+1];b=b[3*f+2];return.01>Math.abs(g-l)?[new B(a,1-c),new B(h,1-d),new B(k,1-e),new B(q,1-b)]:[new B(g,1-c),new B(l,1-d),new B(n,1-e),new B(u,1-b)]}};de.prototype=Object.create(G.prototype);
de.prototype.constructor=de;Tc.prototype=Object.create(db.prototype);Tc.prototype.constructor=Tc;ee.prototype=Object.create(G.prototype);ee.prototype.constructor=ee;Hb.prototype=Object.create(D.prototype);Hb.prototype.constructor=Hb;fe.prototype=Object.create(G.prototype);fe.prototype.constructor=fe;Uc.prototype=Object.create(D.prototype);Uc.prototype.constructor=Uc;ge.prototype=Object.create(G.prototype);ge.prototype.constructor=ge;Vc.prototype=Object.create(D.prototype);Vc.prototype.constructor=
Vc;ec.prototype=Object.create(G.prototype);ec.prototype.constructor=ec;ec.prototype.toJSON=function(){var a=G.prototype.toJSON.call(this);return Yh(this.parameters.shapes,a)};fc.prototype=Object.create(D.prototype);fc.prototype.constructor=fc;fc.prototype.toJSON=function(){var a=D.prototype.toJSON.call(this);return Yh(this.parameters.shapes,a)};Wc.prototype=Object.create(D.prototype);Wc.prototype.constructor=Wc;gc.prototype=Object.create(G.prototype);gc.prototype.constructor=gc;rb.prototype=Object.create(D.prototype);
rb.prototype.constructor=rb;he.prototype=Object.create(gc.prototype);he.prototype.constructor=he;ie.prototype=Object.create(rb.prototype);ie.prototype.constructor=ie;je.prototype=Object.create(G.prototype);je.prototype.constructor=je;Xc.prototype=Object.create(D.prototype);Xc.prototype.constructor=Xc;var ja=Object.freeze({__proto__:null,WireframeGeometry:Lc,ParametricGeometry:Rd,ParametricBufferGeometry:Mc,TetrahedronGeometry:Td,TetrahedronBufferGeometry:Nc,OctahedronGeometry:Ud,OctahedronBufferGeometry:ac,
IcosahedronGeometry:Vd,IcosahedronBufferGeometry:Oc,DodecahedronGeometry:Wd,DodecahedronBufferGeometry:Pc,PolyhedronGeometry:Sd,PolyhedronBufferGeometry:Ea,TubeGeometry:Xd,TubeBufferGeometry:bc,TorusKnotGeometry:Yd,TorusKnotBufferGeometry:Qc,TorusGeometry:Zd,TorusBufferGeometry:Rc,TextGeometry:de,TextBufferGeometry:Tc,SphereGeometry:ee,SphereBufferGeometry:Hb,RingGeometry:fe,RingBufferGeometry:Uc,PlaneGeometry:Ed,PlaneBufferGeometry:Zb,LatheGeometry:ge,LatheBufferGeometry:Vc,ShapeGeometry:ec,ShapeBufferGeometry:fc,
ExtrudeGeometry:dc,ExtrudeBufferGeometry:db,EdgesGeometry:Wc,ConeGeometry:he,ConeBufferGeometry:ie,CylinderGeometry:gc,CylinderBufferGeometry:rb,CircleGeometry:je,CircleBufferGeometry:Xc,BoxGeometry:Zg,BoxBufferGeometry:Fd});hc.prototype=Object.create(O.prototype);hc.prototype.constructor=hc;hc.prototype.isShadowMaterial=!0;hc.prototype.copy=function(a){O.prototype.copy.call(this,a);this.color.copy(a.color);return this};Yc.prototype=Object.create(va.prototype);Yc.prototype.constructor=Yc;Yc.prototype.isRawShaderMaterial=
!0;eb.prototype=Object.create(O.prototype);eb.prototype.constructor=eb;eb.prototype.isMeshStandardMaterial=!0;eb.prototype.copy=function(a){O.prototype.copy.call(this,a);this.defines={STANDARD:""};this.color.copy(a.color);this.roughness=a.roughness;this.metalness=a.metalness;this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=a.emissiveIntensity;
this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.roughnessMap=a.roughnessMap;this.metalnessMap=a.metalnessMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;this.envMapIntensity=a.envMapIntensity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=
a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};ic.prototype=Object.create(eb.prototype);ic.prototype.constructor=ic;ic.prototype.isMeshPhysicalMaterial=!0;ic.prototype.copy=function(a){eb.prototype.copy.call(this,a);this.defines={STANDARD:"",PHYSICAL:""};this.reflectivity=a.reflectivity;this.clearcoat=a.clearcoat;this.clearcoatRoughness=
a.clearcoatRoughness;this.sheen=a.sheen?(this.sheen||new J).copy(a.sheen):null;this.clearcoatNormalMap=a.clearcoatNormalMap;this.clearcoatNormalScale.copy(a.clearcoatNormalScale);this.transparency=a.transparency;return this};Ra.prototype=Object.create(O.prototype);Ra.prototype.constructor=Ra;Ra.prototype.isMeshPhongMaterial=!0;Ra.prototype.copy=function(a){O.prototype.copy.call(this,a);this.color.copy(a.color);this.specular.copy(a.specular);this.shininess=a.shininess;this.map=a.map;this.lightMap=
a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=a.emissiveIntensity;this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.specularMap=
a.specularMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};jc.prototype=Object.create(Ra.prototype);jc.prototype.constructor=jc;jc.prototype.isMeshToonMaterial=
!0;jc.prototype.copy=function(a){Ra.prototype.copy.call(this,a);this.gradientMap=a.gradientMap;return this};kc.prototype=Object.create(O.prototype);kc.prototype.constructor=kc;kc.prototype.isMeshNormalMaterial=!0;kc.prototype.copy=function(a){O.prototype.copy.call(this,a);this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;
this.displacementBias=a.displacementBias;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};lc.prototype=Object.create(O.prototype);lc.prototype.constructor=lc;lc.prototype.isMeshLambertMaterial=!0;lc.prototype.copy=function(a){O.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=
a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=a.emissiveIntensity;this.specularMap=a.specularMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;
this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};mc.prototype=Object.create(O.prototype);mc.prototype.constructor=mc;mc.prototype.isMeshMatcapMaterial=!0;mc.prototype.copy=function(a){O.prototype.copy.call(this,a);this.defines={MATCAP:""};this.color.copy(a.color);this.matcap=a.matcap;this.map=a.map;this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;
this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.alphaMap=a.alphaMap;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};nc.prototype=Object.create(R.prototype);nc.prototype.constructor=nc;nc.prototype.isLineDashedMaterial=!0;nc.prototype.copy=function(a){R.prototype.copy.call(this,a);this.scale=a.scale;this.dashSize=a.dashSize;this.gapSize=a.gapSize;return this};var Fk=Object.freeze({__proto__:null,ShadowMaterial:hc,
SpriteMaterial:Gb,RawShaderMaterial:Yc,ShaderMaterial:va,PointsMaterial:Qa,MeshPhysicalMaterial:ic,MeshStandardMaterial:eb,MeshPhongMaterial:Ra,MeshToonMaterial:jc,MeshNormalMaterial:kc,MeshLambertMaterial:lc,MeshDepthMaterial:Db,MeshDistanceMaterial:Eb,MeshBasicMaterial:Ga,MeshMatcapMaterial:mc,LineDashedMaterial:nc,LineBasicMaterial:R,Material:O}),ta={arraySlice:function(a,b,c){return ta.isTypedArray(a)?new a.constructor(a.subarray(b,void 0!==c?c:a.length)):a.slice(b,c)},convertArray:function(a,
b,c){return!a||!c&&a.constructor===b?a:"number"===typeof b.BYTES_PER_ELEMENT?new b(a):Array.prototype.slice.call(a)},isTypedArray:function(a){return ArrayBuffer.isView(a)&&!(a instanceof DataView)},getKeyframeOrder:function(a){for(var b=a.length,c=Array(b),d=0;d!==b;++d)c[d]=d;c.sort(function(b,c){return a[b]-a[c]});return c},sortedArray:function(a,b,c){for(var d=a.length,e=new a.constructor(d),f=0,g=0;g!==d;++f)for(var h=c[f]*b,l=0;l!==b;++l)e[g++]=a[h+l];return e},flattenJSON:function(a,b,c,d){for(var e=
1,f=a[0];void 0!==f&&void 0===f[d];)f=a[e++];if(void 0!==f){var g=f[d];if(void 0!==g)if(Array.isArray(g)){do g=f[d],void 0!==g&&(b.push(f.time),c.push.apply(c,g)),f=a[e++];while(void 0!==f)}else if(void 0!==g.toArray){do g=f[d],void 0!==g&&(b.push(f.time),g.toArray(c,c.length)),f=a[e++];while(void 0!==f)}else{do g=f[d],void 0!==g&&(b.push(f.time),c.push(g)),f=a[e++];while(void 0!==f)}}},subclip:function(a,b,c,d,e){e=e||30;a=a.clone();a.name=b;var f=[];for(b=0;b<a.tracks.length;++b){for(var g=a.tracks[b],
h=g.getValueSize(),l=[],k=[],n=0;n<g.times.length;++n){var q=g.times[n]*e;if(!(q<c||q>=d))for(l.push(g.times[n]),q=0;q<h;++q)k.push(g.values[n*h+q])}0!==l.length&&(g.times=ta.convertArray(l,g.times.constructor),g.values=ta.convertArray(k,g.values.constructor),f.push(g))}a.tracks=f;c=Infinity;for(b=0;b<a.tracks.length;++b)c>a.tracks[b].times[0]&&(c=a.tracks[b].times[0]);for(b=0;b<a.tracks.length;++b)a.tracks[b].shift(-1*c);a.resetDuration();return a}};Object.assign(Ia.prototype,{evaluate:function(a){var b=
this.parameterPositions,c=this._cachedIndex,d=b[c],e=b[c-1];a:{b:{c:{d:if(!(a<d)){for(var f=c+2;;){if(void 0===d){if(a<e)break d;this._cachedIndex=c=b.length;return this.afterEnd_(c-1,a,e)}if(c===f)break;e=d;d=b[++c];if(a<d)break b}d=b.length;break c}if(a>=e)break a;else{f=b[1];a<f&&(c=2,e=f);for(f=c-2;;){if(void 0===e)return this._cachedIndex=0,this.beforeStart_(0,a,d);if(c===f)break;d=e;e=b[--c-1];if(a>=e)break b}d=c;c=0}}for(;c<d;)e=c+d>>>1,a<b[e]?d=e:c=e+1;d=b[c];e=b[c-1];if(void 0===e)return this._cachedIndex=
0,this.beforeStart_(0,a,d);if(void 0===d)return this._cachedIndex=c=b.length,this.afterEnd_(c-1,e,a)}this._cachedIndex=c;this.intervalChanged_(c,e,d)}return this.interpolate_(c,e,a,d)},settings:null,DefaultSettings_:{},getSettings_:function(){return this.settings||this.DefaultSettings_},copySampleValue_:function(a){var b=this.resultBuffer,c=this.sampleValues,d=this.valueSize;a*=d;for(var e=0;e!==d;++e)b[e]=c[a+e];return b},interpolate_:function(){throw Error("call to abstract method");},intervalChanged_:function(){}});
Object.assign(Ia.prototype,{beforeStart_:Ia.prototype.copySampleValue_,afterEnd_:Ia.prototype.copySampleValue_});Re.prototype=Object.assign(Object.create(Ia.prototype),{constructor:Re,DefaultSettings_:{endingStart:2400,endingEnd:2400},intervalChanged_:function(a,b,c){var d=this.parameterPositions,e=a-2,f=a+1,g=d[e],h=d[f];if(void 0===g)switch(this.getSettings_().endingStart){case 2401:e=a;g=2*b-c;break;case 2402:e=d.length-2;g=b+d[e]-d[e+1];break;default:e=a,g=c}if(void 0===h)switch(this.getSettings_().endingEnd){case 2401:f=
a;h=2*c-b;break;case 2402:f=1;h=c+d[1]-d[0];break;default:f=a-1,h=b}a=.5*(c-b);d=this.valueSize;this._weightPrev=a/(b-g);this._weightNext=a/(h-c);this._offsetPrev=e*d;this._offsetNext=f*d},interpolate_:function(a,b,c,d){var e=this.resultBuffer,f=this.sampleValues,g=this.valueSize;a*=g;var h=a-g,l=this._offsetPrev,k=this._offsetNext,n=this._weightPrev,q=this._weightNext,u=(c-b)/(d-b);c=u*u;d=c*u;b=-n*d+2*n*c-n*u;n=(1+n)*d+(-1.5-2*n)*c+(-.5+n)*u+1;u=(-1-q)*d+(1.5+q)*c+.5*u;q=q*d-q*c;for(c=0;c!==g;++c)e[c]=
b*f[l+c]+n*f[h+c]+u*f[a+c]+q*f[k+c];return e}});ke.prototype=Object.assign(Object.create(Ia.prototype),{constructor:ke,interpolate_:function(a,b,c,d){var e=this.resultBuffer,f=this.sampleValues,g=this.valueSize;a*=g;var h=a-g;b=(c-b)/(d-b);c=1-b;for(d=0;d!==g;++d)e[d]=f[h+d]*c+f[a+d]*b;return e}});Se.prototype=Object.assign(Object.create(Ia.prototype),{constructor:Se,interpolate_:function(a){return this.copySampleValue_(a-1)}});Object.assign(sa,{toJSON:function(a){var b=a.constructor;if(void 0!==
b.toJSON)b=b.toJSON(a);else{b={name:a.name,times:ta.convertArray(a.times,Array),values:ta.convertArray(a.values,Array)};var c=a.getInterpolation();c!==a.DefaultInterpolation&&(b.interpolation=c)}b.type=a.ValueTypeName;return b}});Object.assign(sa.prototype,{constructor:sa,TimeBufferType:Float32Array,ValueBufferType:Float32Array,DefaultInterpolation:2301,InterpolantFactoryMethodDiscrete:function(a){return new Se(this.times,this.values,this.getValueSize(),a)},InterpolantFactoryMethodLinear:function(a){return new ke(this.times,
this.values,this.getValueSize(),a)},InterpolantFactoryMethodSmooth:function(a){return new Re(this.times,this.values,this.getValueSize(),a)},setInterpolation:function(a){switch(a){case 2300:var b=this.InterpolantFactoryMethodDiscrete;break;case 2301:b=this.InterpolantFactoryMethodLinear;break;case 2302:b=this.InterpolantFactoryMethodSmooth}if(void 0===b){b="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant)if(a!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);
else throw Error(b);console.warn("THREE.KeyframeTrack:",b);return this}this.createInterpolant=b;return this},getInterpolation:function(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return 2300;case this.InterpolantFactoryMethodLinear:return 2301;case this.InterpolantFactoryMethodSmooth:return 2302}},getValueSize:function(){return this.values.length/this.times.length},shift:function(a){if(0!==a)for(var b=this.times,c=0,d=b.length;c!==d;++c)b[c]+=a;return this},scale:function(a){if(1!==
a)for(var b=this.times,c=0,d=b.length;c!==d;++c)b[c]*=a;return this},trim:function(a,b){for(var c=this.times,d=c.length,e=0,f=d-1;e!==d&&c[e]<a;)++e;for(;-1!==f&&c[f]>b;)--f;++f;if(0!==e||f!==d)e>=f&&(f=Math.max(f,1),e=f-1),a=this.getValueSize(),this.times=ta.arraySlice(c,e,f),this.values=ta.arraySlice(this.values,e*a,f*a);return this},validate:function(){var a=!0,b=this.getValueSize();0!==b-Math.floor(b)&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),a=!1);var c=this.times;
b=this.values;var d=c.length;0===d&&(console.error("THREE.KeyframeTrack: Track is empty.",this),a=!1);for(var e=null,f=0;f!==d;f++){var g=c[f];if("number"===typeof g&&isNaN(g)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,f,g);a=!1;break}if(null!==e&&e>g){console.error("THREE.KeyframeTrack: Out of order keys.",this,f,g,e);a=!1;break}e=g}if(void 0!==b&&ta.isTypedArray(b))for(f=0,c=b.length;f!==c;++f)if(d=b[f],isNaN(d)){console.error("THREE.KeyframeTrack: Value is not a valid number.",
this,f,d);a=!1;break}return a},optimize:function(){for(var a=this.times,b=this.values,c=this.getValueSize(),d=2302===this.getInterpolation(),e=1,f=a.length-1,g=1;g<f;++g){var h=!1,l=a[g];if(l!==a[g+1]&&(1!==g||l!==l[0]))if(d)h=!0;else{var k=g*c,n=k-c,q=k+c;for(l=0;l!==c;++l){var u=b[k+l];if(u!==b[n+l]||u!==b[q+l]){h=!0;break}}}if(h){if(g!==e)for(a[e]=a[g],h=g*c,k=e*c,l=0;l!==c;++l)b[k+l]=b[h+l];++e}}if(0<f){a[e]=a[f];h=f*c;k=e*c;for(l=0;l!==c;++l)b[k+l]=b[h+l];++e}e!==a.length&&(this.times=ta.arraySlice(a,
0,e),this.values=ta.arraySlice(b,0,e*c));return this},clone:function(){var a=ta.arraySlice(this.times,0),b=ta.arraySlice(this.values,0);a=new this.constructor(this.name,a,b);a.createInterpolant=this.createInterpolant;return a}});Te.prototype=Object.assign(Object.create(sa.prototype),{constructor:Te,ValueTypeName:"bool",ValueBufferType:Array,DefaultInterpolation:2300,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0});Ue.prototype=Object.assign(Object.create(sa.prototype),
{constructor:Ue,ValueTypeName:"color"});Zc.prototype=Object.assign(Object.create(sa.prototype),{constructor:Zc,ValueTypeName:"number"});Ve.prototype=Object.assign(Object.create(Ia.prototype),{constructor:Ve,interpolate_:function(a,b,c,d){var e=this.resultBuffer,f=this.sampleValues,g=this.valueSize;a*=g;b=(c-b)/(d-b);for(c=a+g;a!==c;a+=4)wa.slerpFlat(e,0,f,a-g,f,a,b);return e}});le.prototype=Object.assign(Object.create(sa.prototype),{constructor:le,ValueTypeName:"quaternion",DefaultInterpolation:2301,
InterpolantFactoryMethodLinear:function(a){return new Ve(this.times,this.values,this.getValueSize(),a)},InterpolantFactoryMethodSmooth:void 0});We.prototype=Object.assign(Object.create(sa.prototype),{constructor:We,ValueTypeName:"string",ValueBufferType:Array,DefaultInterpolation:2300,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0});$c.prototype=Object.assign(Object.create(sa.prototype),{constructor:$c,ValueTypeName:"vector"});Object.assign(Ma,{parse:function(a){for(var b=
[],c=a.tracks,d=1/(a.fps||1),e=0,f=c.length;e!==f;++e)b.push(sk(c[e]).scale(d));return new Ma(a.name,a.duration,b)},toJSON:function(a){var b=[],c=a.tracks;a={name:a.name,duration:a.duration,tracks:b,uuid:a.uuid};for(var d=0,e=c.length;d!==e;++d)b.push(sa.toJSON(c[d]));return a},CreateFromMorphTargetSequence:function(a,b,c,d){for(var e=b.length,f=[],g=0;g<e;g++){var h=[],l=[];h.push((g+e-1)%e,g,(g+1)%e);l.push(0,1,0);var k=ta.getKeyframeOrder(h);h=ta.sortedArray(h,1,k);l=ta.sortedArray(l,1,k);d||0!==
h[0]||(h.push(e),l.push(l[0]));f.push((new Zc(".morphTargetInfluences["+b[g].name+"]",h,l)).scale(1/c))}return new Ma(a,-1,f)},findByName:function(a,b){var c=a;Array.isArray(a)||(c=a.geometry&&a.geometry.animations||a.animations);for(a=0;a<c.length;a++)if(c[a].name===b)return c[a];return null},CreateClipsFromMorphTargetSequences:function(a,b,c){for(var d={},e=/^([\w-]*?)([\d]+)$/,f=0,g=a.length;f<g;f++){var h=a[f],l=h.name.match(e);if(l&&1<l.length){var k=l[1];(l=d[k])||(d[k]=l=[]);l.push(h)}}a=[];
for(k in d)a.push(Ma.CreateFromMorphTargetSequence(k,d[k],b,c));return a},parseAnimation:function(a,b){if(!a)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;var c=function(a,b,c,d,e){if(0!==c.length){var f=[],g=[];ta.flattenJSON(c,f,g,d);0!==f.length&&e.push(new a(b,f,g))}},d=[],e=a.name||"default",f=a.length||-1,g=a.fps||30;a=a.hierarchy||[];for(var h=0;h<a.length;h++){var l=a[h].keys;if(l&&0!==l.length)if(l[0].morphTargets){f={};for(var k=0;k<l.length;k++)if(l[k].morphTargets)for(var n=
0;n<l[k].morphTargets.length;n++)f[l[k].morphTargets[n]]=-1;for(var q in f){var u=[],p=[];for(n=0;n!==l[k].morphTargets.length;++n){var t=l[k];u.push(t.time);p.push(t.morphTarget===q?1:0)}d.push(new Zc(".morphTargetInfluence["+q+"]",u,p))}f=f.length*(g||1)}else k=".bones["+b[h].name+"]",c($c,k+".position",l,"pos",d),c(le,k+".quaternion",l,"rot",d),c($c,k+".scale",l,"scl",d)}return 0===d.length?null:new Ma(e,f,d)}});Object.assign(Ma.prototype,{resetDuration:function(){for(var a=0,b=0,c=this.tracks.length;b!==
c;++b){var d=this.tracks[b];a=Math.max(a,d.times[d.times.length-1])}this.duration=a;return this},trim:function(){for(var a=0;a<this.tracks.length;a++)this.tracks[a].trim(0,this.duration);return this},validate:function(){for(var a=!0,b=0;b<this.tracks.length;b++)a=a&&this.tracks[b].validate();return a},optimize:function(){for(var a=0;a<this.tracks.length;a++)this.tracks[a].optimize();return this},clone:function(){for(var a=[],b=0;b<this.tracks.length;b++)a.push(this.tracks[b].clone());return new Ma(this.name,
this.duration,a)}});var sc={enabled:!1,files:{},add:function(a,b){!1!==this.enabled&&(this.files[a]=b)},get:function(a){if(!1!==this.enabled)return this.files[a]},remove:function(a){delete this.files[a]},clear:function(){this.files={}}},Zh=new og;Object.assign(V.prototype,{load:function(){},parse:function(){},setCrossOrigin:function(a){this.crossOrigin=a;return this},setPath:function(a){this.path=a;return this},setResourcePath:function(a){this.resourcePath=a;return this}});var $a={};Na.prototype=
Object.assign(Object.create(V.prototype),{constructor:Na,load:function(a,b,c,d){void 0===a&&(a="");void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var e=this,f=sc.get(a);if(void 0!==f)return e.manager.itemStart(a),setTimeout(function(){b&&b(f);e.manager.itemEnd(a)},0),f;if(void 0!==$a[a])$a[a].push({onLoad:b,onProgress:c,onError:d});else{var g=a.match(/^data:(.*?)(;base64)?,(.*)$/);if(g){c=g[1];var h=!!g[2];g=g[3];g=decodeURIComponent(g);h&&(g=atob(g));try{var l=(this.responseType||
"").toLowerCase();switch(l){case "arraybuffer":case "blob":var k=new Uint8Array(g.length);for(h=0;h<g.length;h++)k[h]=g.charCodeAt(h);var n="blob"===l?new Blob([k.buffer],{type:c}):k.buffer;break;case "document":n=(new DOMParser).parseFromString(g,c);break;case "json":n=JSON.parse(g);break;default:n=g}setTimeout(function(){b&&b(n);e.manager.itemEnd(a)},0)}catch(u){setTimeout(function(){d&&d(u);e.manager.itemError(a);e.manager.itemEnd(a)},0)}}else{$a[a]=[];$a[a].push({onLoad:b,onProgress:c,onError:d});
var q=new XMLHttpRequest;q.open("GET",a,!0);q.addEventListener("load",function(b){var c=this.response,d=$a[a];delete $a[a];if(200===this.status||0===this.status){0===this.status&&console.warn("THREE.FileLoader: HTTP Status 0 received.");sc.add(a,c);for(var f=0,g=d.length;f<g;f++){var h=d[f];if(h.onLoad)h.onLoad(c)}}else{f=0;for(g=d.length;f<g;f++)if(h=d[f],h.onError)h.onError(b);e.manager.itemError(a)}e.manager.itemEnd(a)},!1);q.addEventListener("progress",function(b){for(var c=$a[a],d=0,e=c.length;d<
e;d++){var f=c[d];if(f.onProgress)f.onProgress(b)}},!1);q.addEventListener("error",function(b){var c=$a[a];delete $a[a];for(var d=0,f=c.length;d<f;d++){var g=c[d];if(g.onError)g.onError(b)}e.manager.itemError(a);e.manager.itemEnd(a)},!1);q.addEventListener("abort",function(b){var c=$a[a];delete $a[a];for(var d=0,f=c.length;d<f;d++){var g=c[d];if(g.onError)g.onError(b)}e.manager.itemError(a);e.manager.itemEnd(a)},!1);void 0!==this.responseType&&(q.responseType=this.responseType);void 0!==this.withCredentials&&
(q.withCredentials=this.withCredentials);q.overrideMimeType&&q.overrideMimeType(void 0!==this.mimeType?this.mimeType:"text/plain");for(h in this.requestHeader)q.setRequestHeader(h,this.requestHeader[h]);q.send(null)}e.manager.itemStart(a);return q}},setResponseType:function(a){this.responseType=a;return this},setWithCredentials:function(a){this.withCredentials=a;return this},setMimeType:function(a){this.mimeType=a;return this},setRequestHeader:function(a){this.requestHeader=a;return this}});pg.prototype=
Object.assign(Object.create(V.prototype),{constructor:pg,load:function(a,b,c,d){var e=this,f=new Na(e.manager);f.setPath(e.path);f.load(a,function(a){b(e.parse(JSON.parse(a)))},c,d)},parse:function(a){for(var b=[],c=0;c<a.length;c++){var d=Ma.parse(a[c]);b.push(d)}return b}});qg.prototype=Object.assign(Object.create(V.prototype),{constructor:qg,load:function(a,b,c,d){function e(e){l.load(a[e],function(a){a=f.parse(a,!0);g[e]={width:a.width,height:a.height,format:a.format,mipmaps:a.mipmaps};k+=1;6===
k&&(1===a.mipmapCount&&(h.minFilter=1006),h.format=a.format,h.needsUpdate=!0,b&&b(h))},c,d)}var f=this,g=[],h=new Kc;h.image=g;var l=new Na(this.manager);l.setPath(this.path);l.setResponseType("arraybuffer");if(Array.isArray(a))for(var k=0,n=0,q=a.length;n<q;++n)e(n);else l.load(a,function(a){a=f.parse(a,!0);if(a.isCubemap)for(var c=a.mipmaps.length/a.mipmapCount,d=0;d<c;d++){g[d]={mipmaps:[]};for(var e=0;e<a.mipmapCount;e++)g[d].mipmaps.push(a.mipmaps[d*a.mipmapCount+e]),g[d].format=a.format,g[d].width=
a.width,g[d].height=a.height}else h.image.width=a.width,h.image.height=a.height,h.mipmaps=a.mipmaps;1===a.mipmapCount&&(h.minFilter=1006);h.format=a.format;h.needsUpdate=!0;b&&b(h)},c,d);return h}});Xe.prototype=Object.assign(Object.create(V.prototype),{constructor:Xe,load:function(a,b,c,d){var e=this,f=new Yb,g=new Na(this.manager);g.setResponseType("arraybuffer");g.setPath(this.path);g.load(a,function(a){if(a=e.parse(a))void 0!==a.image?f.image=a.image:void 0!==a.data&&(f.image.width=a.width,f.image.height=
a.height,f.image.data=a.data),f.wrapS=void 0!==a.wrapS?a.wrapS:1001,f.wrapT=void 0!==a.wrapT?a.wrapT:1001,f.magFilter=void 0!==a.magFilter?a.magFilter:1006,f.minFilter=void 0!==a.minFilter?a.minFilter:1006,f.anisotropy=void 0!==a.anisotropy?a.anisotropy:1,void 0!==a.format&&(f.format=a.format),void 0!==a.type&&(f.type=a.type),void 0!==a.mipmaps&&(f.mipmaps=a.mipmaps,f.minFilter=1008),1===a.mipmapCount&&(f.minFilter=1006),f.needsUpdate=!0,b&&b(f,a)},c,d);return f}});ad.prototype=Object.assign(Object.create(V.prototype),
{constructor:ad,load:function(a,b,c,d){function e(){l.removeEventListener("load",e,!1);l.removeEventListener("error",f,!1);sc.add(a,this);b&&b(this);g.manager.itemEnd(a)}function f(b){l.removeEventListener("load",e,!1);l.removeEventListener("error",f,!1);d&&d(b);g.manager.itemError(a);g.manager.itemEnd(a)}void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var g=this,h=sc.get(a);if(void 0!==h)return g.manager.itemStart(a),setTimeout(function(){b&&b(h);g.manager.itemEnd(a)},0),h;var l=
document.createElementNS("http://www.w3.org/1999/xhtml","img");l.addEventListener("load",e,!1);l.addEventListener("error",f,!1);"data:"!==a.substr(0,5)&&void 0!==this.crossOrigin&&(l.crossOrigin=this.crossOrigin);g.manager.itemStart(a);l.src=a;return l}});Ye.prototype=Object.assign(Object.create(V.prototype),{constructor:Ye,load:function(a,b,c,d){function e(c){g.load(a[c],function(a){f.images[c]=a;h++;6===h&&(f.needsUpdate=!0,b&&b(f))},void 0,d)}var f=new nb,g=new ad(this.manager);g.setCrossOrigin(this.crossOrigin);
g.setPath(this.path);var h=0;for(c=0;c<a.length;++c)e(c);return f}});Ze.prototype=Object.assign(Object.create(V.prototype),{constructor:Ze,load:function(a,b,c,d){var e=new Y,f=new ad(this.manager);f.setCrossOrigin(this.crossOrigin);f.setPath(this.path);f.load(a,function(c){e.image=c;c=0<a.search(/\.jpe?g($|\?)/i)||0===a.search(/^data:image\/jpeg/);e.format=c?1022:1023;e.needsUpdate=!0;void 0!==b&&b(e)},c,d);return e}});Object.assign(C.prototype,{getPoint:function(){console.warn("THREE.Curve: .getPoint() not implemented.");
return null},getPointAt:function(a,b){a=this.getUtoTmapping(a);return this.getPoint(a,b)},getPoints:function(a){void 0===a&&(a=5);for(var b=[],c=0;c<=a;c++)b.push(this.getPoint(c/a));return b},getSpacedPoints:function(a){void 0===a&&(a=5);for(var b=[],c=0;c<=a;c++)b.push(this.getPointAt(c/a));return b},getLength:function(){var a=this.getLengths();return a[a.length-1]},getLengths:function(a){void 0===a&&(a=this.arcLengthDivisions);if(this.cacheArcLengths&&this.cacheArcLengths.length===a+1&&!this.needsUpdate)return this.cacheArcLengths;
this.needsUpdate=!1;var b=[],c=this.getPoint(0),d,e=0;b.push(0);for(d=1;d<=a;d++){var f=this.getPoint(d/a);e+=f.distanceTo(c);b.push(e);c=f}return this.cacheArcLengths=b},updateArcLengths:function(){this.needsUpdate=!0;this.getLengths()},getUtoTmapping:function(a,b){var c=this.getLengths(),d=c.length;b=b?b:a*c[d-1];for(var e=0,f=d-1,g;e<=f;)if(a=Math.floor(e+(f-e)/2),g=c[a]-b,0>g)e=a+1;else if(0<g)f=a-1;else{f=a;break}a=f;if(c[a]===b)return a/(d-1);e=c[a];return(a+(b-e)/(c[a+1]-e))/(d-1)},getTangent:function(a){var b=
a-1E-4;a+=1E-4;0>b&&(b=0);1<a&&(a=1);b=this.getPoint(b);return this.getPoint(a).clone().sub(b).normalize()},getTangentAt:function(a){a=this.getUtoTmapping(a);return this.getTangent(a)},computeFrenetFrames:function(a,b){var c=new n,d=[],e=[],f=[],g=new n,h=new Q,l;for(l=0;l<=a;l++){var k=l/a;d[l]=this.getTangentAt(k);d[l].normalize()}e[0]=new n;f[0]=new n;l=Number.MAX_VALUE;k=Math.abs(d[0].x);var r=Math.abs(d[0].y),q=Math.abs(d[0].z);k<=l&&(l=k,c.set(1,0,0));r<=l&&(l=r,c.set(0,1,0));q<=l&&c.set(0,
0,1);g.crossVectors(d[0],c).normalize();e[0].crossVectors(d[0],g);f[0].crossVectors(d[0],e[0]);for(l=1;l<=a;l++)e[l]=e[l-1].clone(),f[l]=f[l-1].clone(),g.crossVectors(d[l-1],d[l]),g.length()>Number.EPSILON&&(g.normalize(),c=Math.acos(P.clamp(d[l-1].dot(d[l]),-1,1)),e[l].applyMatrix4(h.makeRotationAxis(g,c))),f[l].crossVectors(d[l],e[l]);if(!0===b)for(c=Math.acos(P.clamp(e[0].dot(e[a]),-1,1)),c/=a,0<d[0].dot(g.crossVectors(e[0],e[a]))&&(c=-c),l=1;l<=a;l++)e[l].applyMatrix4(h.makeRotationAxis(d[l],
c*l)),f[l].crossVectors(d[l],e[l]);return{tangents:d,normals:e,binormals:f}},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.arcLengthDivisions=a.arcLengthDivisions;return this},toJSON:function(){var a={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};a.arcLengthDivisions=this.arcLengthDivisions;a.type=this.type;return a},fromJSON:function(a){this.arcLengthDivisions=a.arcLengthDivisions;return this}});Ja.prototype=Object.create(C.prototype);Ja.prototype.constructor=
Ja;Ja.prototype.isEllipseCurve=!0;Ja.prototype.getPoint=function(a,b){b=b||new B;for(var c=2*Math.PI,d=this.aEndAngle-this.aStartAngle,e=Math.abs(d)<Number.EPSILON;0>d;)d+=c;for(;d>c;)d-=c;d<Number.EPSILON&&(d=e?0:c);!0!==this.aClockwise||e||(d=d===c?-c:d-c);c=this.aStartAngle+a*d;a=this.aX+this.xRadius*Math.cos(c);var f=this.aY+this.yRadius*Math.sin(c);0!==this.aRotation&&(c=Math.cos(this.aRotation),d=Math.sin(this.aRotation),e=a-this.aX,f-=this.aY,a=e*c-f*d+this.aX,f=e*d+f*c+this.aY);return b.set(a,
f)};Ja.prototype.copy=function(a){C.prototype.copy.call(this,a);this.aX=a.aX;this.aY=a.aY;this.xRadius=a.xRadius;this.yRadius=a.yRadius;this.aStartAngle=a.aStartAngle;this.aEndAngle=a.aEndAngle;this.aClockwise=a.aClockwise;this.aRotation=a.aRotation;return this};Ja.prototype.toJSON=function(){var a=C.prototype.toJSON.call(this);a.aX=this.aX;a.aY=this.aY;a.xRadius=this.xRadius;a.yRadius=this.yRadius;a.aStartAngle=this.aStartAngle;a.aEndAngle=this.aEndAngle;a.aClockwise=this.aClockwise;a.aRotation=
this.aRotation;return a};Ja.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.aX=a.aX;this.aY=a.aY;this.xRadius=a.xRadius;this.yRadius=a.yRadius;this.aStartAngle=a.aStartAngle;this.aEndAngle=a.aEndAngle;this.aClockwise=a.aClockwise;this.aRotation=a.aRotation;return this};bd.prototype=Object.create(Ja.prototype);bd.prototype.constructor=bd;bd.prototype.isArcCurve=!0;var Lf=new n,ah=new rg,bh=new rg,ch=new rg;ma.prototype=Object.create(C.prototype);ma.prototype.constructor=ma;ma.prototype.isCatmullRomCurve3=
!0;ma.prototype.getPoint=function(a,b){b=b||new n;var c=this.points,d=c.length;a*=d-(this.closed?0:1);var e=Math.floor(a);a-=e;this.closed?e+=0<e?0:(Math.floor(Math.abs(e)/d)+1)*d:0===a&&e===d-1&&(e=d-2,a=1);if(this.closed||0<e)var f=c[(e-1)%d];else Lf.subVectors(c[0],c[1]).add(c[0]),f=Lf;var g=c[e%d];var h=c[(e+1)%d];this.closed||e+2<d?c=c[(e+2)%d]:(Lf.subVectors(c[d-1],c[d-2]).add(c[d-1]),c=Lf);if("centripetal"===this.curveType||"chordal"===this.curveType){var l="chordal"===this.curveType?.5:.25;
d=Math.pow(f.distanceToSquared(g),l);e=Math.pow(g.distanceToSquared(h),l);l=Math.pow(h.distanceToSquared(c),l);1E-4>e&&(e=1);1E-4>d&&(d=e);1E-4>l&&(l=e);ah.initNonuniformCatmullRom(f.x,g.x,h.x,c.x,d,e,l);bh.initNonuniformCatmullRom(f.y,g.y,h.y,c.y,d,e,l);ch.initNonuniformCatmullRom(f.z,g.z,h.z,c.z,d,e,l)}else"catmullrom"===this.curveType&&(ah.initCatmullRom(f.x,g.x,h.x,c.x,this.tension),bh.initCatmullRom(f.y,g.y,h.y,c.y,this.tension),ch.initCatmullRom(f.z,g.z,h.z,c.z,this.tension));b.set(ah.calc(a),
bh.calc(a),ch.calc(a));return b};ma.prototype.copy=function(a){C.prototype.copy.call(this,a);this.points=[];for(var b=0,c=a.points.length;b<c;b++)this.points.push(a.points[b].clone());this.closed=a.closed;this.curveType=a.curveType;this.tension=a.tension;return this};ma.prototype.toJSON=function(){var a=C.prototype.toJSON.call(this);a.points=[];for(var b=0,c=this.points.length;b<c;b++)a.points.push(this.points[b].toArray());a.closed=this.closed;a.curveType=this.curveType;a.tension=this.tension;return a};
ma.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.points=[];for(var b=0,c=a.points.length;b<c;b++){var d=a.points[b];this.points.push((new n).fromArray(d))}this.closed=a.closed;this.curveType=a.curveType;this.tension=a.tension;return this};Sa.prototype=Object.create(C.prototype);Sa.prototype.constructor=Sa;Sa.prototype.isCubicBezierCurve=!0;Sa.prototype.getPoint=function(a,b){b=b||new B;var c=this.v0,d=this.v1,e=this.v2,f=this.v3;b.set(ne(a,c.x,d.x,e.x,f.x),ne(a,c.y,d.y,e.y,
f.y));return b};Sa.prototype.copy=function(a){C.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);this.v3.copy(a.v3);return this};Sa.prototype.toJSON=function(){var a=C.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();a.v3=this.v3.toArray();return a};Sa.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);this.v3.fromArray(a.v3);return this};
fb.prototype=Object.create(C.prototype);fb.prototype.constructor=fb;fb.prototype.isCubicBezierCurve3=!0;fb.prototype.getPoint=function(a,b){b=b||new n;var c=this.v0,d=this.v1,e=this.v2,f=this.v3;b.set(ne(a,c.x,d.x,e.x,f.x),ne(a,c.y,d.y,e.y,f.y),ne(a,c.z,d.z,e.z,f.z));return b};fb.prototype.copy=function(a){C.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);this.v3.copy(a.v3);return this};fb.prototype.toJSON=function(){var a=C.prototype.toJSON.call(this);a.v0=this.v0.toArray();
a.v1=this.v1.toArray();a.v2=this.v2.toArray();a.v3=this.v3.toArray();return a};fb.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);this.v3.fromArray(a.v3);return this};Da.prototype=Object.create(C.prototype);Da.prototype.constructor=Da;Da.prototype.isLineCurve=!0;Da.prototype.getPoint=function(a,b){b=b||new B;1===a?b.copy(this.v2):(b.copy(this.v2).sub(this.v1),b.multiplyScalar(a).add(this.v1));return b};Da.prototype.getPointAt=
function(a,b){return this.getPoint(a,b)};Da.prototype.getTangent=function(){return this.v2.clone().sub(this.v1).normalize()};Da.prototype.copy=function(a){C.prototype.copy.call(this,a);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};Da.prototype.toJSON=function(){var a=C.prototype.toJSON.call(this);a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};Da.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);return this};Ta.prototype=
Object.create(C.prototype);Ta.prototype.constructor=Ta;Ta.prototype.isLineCurve3=!0;Ta.prototype.getPoint=function(a,b){b=b||new n;1===a?b.copy(this.v2):(b.copy(this.v2).sub(this.v1),b.multiplyScalar(a).add(this.v1));return b};Ta.prototype.getPointAt=function(a,b){return this.getPoint(a,b)};Ta.prototype.copy=function(a){C.prototype.copy.call(this,a);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};Ta.prototype.toJSON=function(){var a=C.prototype.toJSON.call(this);a.v1=this.v1.toArray();a.v2=this.v2.toArray();
return a};Ta.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);return this};Ua.prototype=Object.create(C.prototype);Ua.prototype.constructor=Ua;Ua.prototype.isQuadraticBezierCurve=!0;Ua.prototype.getPoint=function(a,b){b=b||new B;var c=this.v0,d=this.v1,e=this.v2;b.set(me(a,c.x,d.x,e.x),me(a,c.y,d.y,e.y));return b};Ua.prototype.copy=function(a){C.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};
Ua.prototype.toJSON=function(){var a=C.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};Ua.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);return this};gb.prototype=Object.create(C.prototype);gb.prototype.constructor=gb;gb.prototype.isQuadraticBezierCurve3=!0;gb.prototype.getPoint=function(a,b){b=b||new n;var c=this.v0,d=this.v1,e=this.v2;b.set(me(a,c.x,
d.x,e.x),me(a,c.y,d.y,e.y),me(a,c.z,d.z,e.z));return b};gb.prototype.copy=function(a){C.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};gb.prototype.toJSON=function(){var a=C.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};gb.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);return this};Va.prototype=Object.create(C.prototype);
Va.prototype.constructor=Va;Va.prototype.isSplineCurve=!0;Va.prototype.getPoint=function(a,b){b=b||new B;var c=this.points,d=(c.length-1)*a;a=Math.floor(d);d-=a;var e=c[0===a?a:a-1],f=c[a],g=c[a>c.length-2?c.length-1:a+1];c=c[a>c.length-3?c.length-1:a+2];b.set($h(d,e.x,f.x,g.x,c.x),$h(d,e.y,f.y,g.y,c.y));return b};Va.prototype.copy=function(a){C.prototype.copy.call(this,a);this.points=[];for(var b=0,c=a.points.length;b<c;b++)this.points.push(a.points[b].clone());return this};Va.prototype.toJSON=function(){var a=
C.prototype.toJSON.call(this);a.points=[];for(var b=0,c=this.points.length;b<c;b++)a.points.push(this.points[b].toArray());return a};Va.prototype.fromJSON=function(a){C.prototype.fromJSON.call(this,a);this.points=[];for(var b=0,c=a.points.length;b<c;b++){var d=a.points[b];this.points.push((new B).fromArray(d))}return this};var dh=Object.freeze({__proto__:null,ArcCurve:bd,CatmullRomCurve3:ma,CubicBezierCurve:Sa,CubicBezierCurve3:fb,EllipseCurve:Ja,LineCurve:Da,LineCurve3:Ta,QuadraticBezierCurve:Ua,
QuadraticBezierCurve3:gb,SplineCurve:Va});sb.prototype=Object.assign(Object.create(C.prototype),{constructor:sb,add:function(a){this.curves.push(a)},closePath:function(){var a=this.curves[0].getPoint(0),b=this.curves[this.curves.length-1].getPoint(1);a.equals(b)||this.curves.push(new Da(b,a))},getPoint:function(a){var b=a*this.getLength(),c=this.getCurveLengths();for(a=0;a<c.length;){if(c[a]>=b)return b=c[a]-b,a=this.curves[a],c=a.getLength(),a.getPointAt(0===c?0:1-b/c);a++}return null},getLength:function(){var a=
this.getCurveLengths();return a[a.length-1]},updateArcLengths:function(){this.needsUpdate=!0;this.cacheLengths=null;this.getCurveLengths()},getCurveLengths:function(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;for(var a=[],b=0,c=0,d=this.curves.length;c<d;c++)b+=this.curves[c].getLength(),a.push(b);return this.cacheLengths=a},getSpacedPoints:function(a){void 0===a&&(a=40);for(var b=[],c=0;c<=a;c++)b.push(this.getPoint(c/a));this.autoClose&&b.push(b[0]);
return b},getPoints:function(a){a=a||12;for(var b=[],c,d=0,e=this.curves;d<e.length;d++){var f=e[d];f=f.getPoints(f&&f.isEllipseCurve?2*a:f&&(f.isLineCurve||f.isLineCurve3)?1:f&&f.isSplineCurve?a*f.points.length:a);for(var g=0;g<f.length;g++){var h=f[g];c&&c.equals(h)||(b.push(h),c=h)}}this.autoClose&&1<b.length&&!b[b.length-1].equals(b[0])&&b.push(b[0]);return b},copy:function(a){C.prototype.copy.call(this,a);this.curves=[];for(var b=0,c=a.curves.length;b<c;b++)this.curves.push(a.curves[b].clone());
this.autoClose=a.autoClose;return this},toJSON:function(){var a=C.prototype.toJSON.call(this);a.autoClose=this.autoClose;a.curves=[];for(var b=0,c=this.curves.length;b<c;b++)a.curves.push(this.curves[b].toJSON());return a},fromJSON:function(a){C.prototype.fromJSON.call(this,a);this.autoClose=a.autoClose;this.curves=[];for(var b=0,c=a.curves.length;b<c;b++){var d=a.curves[b];this.curves.push((new dh[d.type]).fromJSON(d))}return this}});Wa.prototype=Object.assign(Object.create(sb.prototype),{constructor:Wa,
setFromPoints:function(a){this.moveTo(a[0].x,a[0].y);for(var b=1,c=a.length;b<c;b++)this.lineTo(a[b].x,a[b].y);return this},moveTo:function(a,b){this.currentPoint.set(a,b);return this},lineTo:function(a,b){var c=new Da(this.currentPoint.clone(),new B(a,b));this.curves.push(c);this.currentPoint.set(a,b);return this},quadraticCurveTo:function(a,b,c,d){a=new Ua(this.currentPoint.clone(),new B(a,b),new B(c,d));this.curves.push(a);this.currentPoint.set(c,d);return this},bezierCurveTo:function(a,b,c,d,
e,f){a=new Sa(this.currentPoint.clone(),new B(a,b),new B(c,d),new B(e,f));this.curves.push(a);this.currentPoint.set(e,f);return this},splineThru:function(a){var b=[this.currentPoint.clone()].concat(a);b=new Va(b);this.curves.push(b);this.currentPoint.copy(a[a.length-1]);return this},arc:function(a,b,c,d,e,f){this.absarc(a+this.currentPoint.x,b+this.currentPoint.y,c,d,e,f);return this},absarc:function(a,b,c,d,e,f){this.absellipse(a,b,c,c,d,e,f);return this},ellipse:function(a,b,c,d,e,f,g,h){this.absellipse(a+
this.currentPoint.x,b+this.currentPoint.y,c,d,e,f,g,h);return this},absellipse:function(a,b,c,d,e,f,g,h){a=new Ja(a,b,c,d,e,f,g,h);0<this.curves.length&&(b=a.getPoint(0),b.equals(this.currentPoint)||this.lineTo(b.x,b.y));this.curves.push(a);a=a.getPoint(1);this.currentPoint.copy(a);return this},copy:function(a){sb.prototype.copy.call(this,a);this.currentPoint.copy(a.currentPoint);return this},toJSON:function(){var a=sb.prototype.toJSON.call(this);a.currentPoint=this.currentPoint.toArray();return a},
fromJSON:function(a){sb.prototype.fromJSON.call(this,a);this.currentPoint.fromArray(a.currentPoint);return this}});Ib.prototype=Object.assign(Object.create(Wa.prototype),{constructor:Ib,getPointsHoles:function(a){for(var b=[],c=0,d=this.holes.length;c<d;c++)b[c]=this.holes[c].getPoints(a);return b},extractPoints:function(a){return{shape:this.getPoints(a),holes:this.getPointsHoles(a)}},copy:function(a){Wa.prototype.copy.call(this,a);this.holes=[];for(var b=0,c=a.holes.length;b<c;b++)this.holes.push(a.holes[b].clone());
return this},toJSON:function(){var a=Wa.prototype.toJSON.call(this);a.uuid=this.uuid;a.holes=[];for(var b=0,c=this.holes.length;b<c;b++)a.holes.push(this.holes[b].toJSON());return a},fromJSON:function(a){Wa.prototype.fromJSON.call(this,a);this.uuid=a.uuid;this.holes=[];for(var b=0,c=a.holes.length;b<c;b++){var d=a.holes[b];this.holes.push((new Wa).fromJSON(d))}return this}});T.prototype=Object.assign(Object.create(E.prototype),{constructor:T,isLight:!0,copy:function(a){E.prototype.copy.call(this,
a);this.color.copy(a.color);this.intensity=a.intensity;return this},toJSON:function(a){a=E.prototype.toJSON.call(this,a);a.object.color=this.color.getHex();a.object.intensity=this.intensity;void 0!==this.groundColor&&(a.object.groundColor=this.groundColor.getHex());void 0!==this.distance&&(a.object.distance=this.distance);void 0!==this.angle&&(a.object.angle=this.angle);void 0!==this.decay&&(a.object.decay=this.decay);void 0!==this.penumbra&&(a.object.penumbra=this.penumbra);void 0!==this.shadow&&
(a.object.shadow=this.shadow.toJSON());return a}});$e.prototype=Object.assign(Object.create(T.prototype),{constructor:$e,isHemisphereLight:!0,copy:function(a){T.prototype.copy.call(this,a);this.groundColor.copy(a.groundColor);return this}});Object.assign(hb.prototype,{_projScreenMatrix:new Q,_lightPositionWorld:new n,_lookTarget:new n,getViewportCount:function(){return this._viewportCount},getFrustum:function(){return this._frustum},updateMatrices:function(a){var b=this.camera,c=this.matrix,d=this._projScreenMatrix,
e=this._lookTarget,f=this._lightPositionWorld;f.setFromMatrixPosition(a.matrixWorld);b.position.copy(f);e.setFromMatrixPosition(a.target.matrixWorld);b.lookAt(e);b.updateMatrixWorld();d.multiplyMatrices(b.projectionMatrix,b.matrixWorldInverse);this._frustum.setFromMatrix(d);c.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1);c.multiply(b.projectionMatrix);c.multiply(b.matrixWorldInverse)},getViewport:function(a){return this._viewports[a]},getFrameExtents:function(){return this._frameExtents},copy:function(a){this.camera=
a.camera.clone();this.bias=a.bias;this.radius=a.radius;this.mapSize.copy(a.mapSize);return this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){var a={};0!==this.bias&&(a.bias=this.bias);1!==this.radius&&(a.radius=this.radius);if(512!==this.mapSize.x||512!==this.mapSize.y)a.mapSize=this.mapSize.toArray();a.camera=this.camera.toJSON(!1).object;delete a.camera.matrix;return a}});af.prototype=Object.assign(Object.create(hb.prototype),{constructor:af,isSpotLightShadow:!0,
updateMatrices:function(a){var b=this.camera,c=2*P.RAD2DEG*a.angle,d=this.mapSize.width/this.mapSize.height,e=a.distance||b.far;if(c!==b.fov||d!==b.aspect||e!==b.far)b.fov=c,b.aspect=d,b.far=e,b.updateProjectionMatrix();hb.prototype.updateMatrices.call(this,a)}});bf.prototype=Object.assign(Object.create(T.prototype),{constructor:bf,isSpotLight:!0,copy:function(a){T.prototype.copy.call(this,a);this.distance=a.distance;this.angle=a.angle;this.penumbra=a.penumbra;this.decay=a.decay;this.target=a.target.clone();
this.shadow=a.shadow.clone();return this}});sg.prototype=Object.assign(Object.create(hb.prototype),{constructor:sg,isPointLightShadow:!0,updateMatrices:function(a,b){void 0===b&&(b=0);var c=this.camera,d=this.matrix,e=this._lightPositionWorld,f=this._lookTarget,g=this._projScreenMatrix;e.setFromMatrixPosition(a.matrixWorld);c.position.copy(e);f.copy(c.position);f.add(this._cubeDirections[b]);c.up.copy(this._cubeUps[b]);c.lookAt(f);c.updateMatrixWorld();d.makeTranslation(-e.x,-e.y,-e.z);g.multiplyMatrices(c.projectionMatrix,
c.matrixWorldInverse);this._frustum.setFromMatrix(g)}});cf.prototype=Object.assign(Object.create(T.prototype),{constructor:cf,isPointLight:!0,copy:function(a){T.prototype.copy.call(this,a);this.distance=a.distance;this.decay=a.decay;this.shadow=a.shadow.clone();return this}});oe.prototype=Object.assign(Object.create(bb.prototype),{constructor:oe,isOrthographicCamera:!0,copy:function(a,b){bb.prototype.copy.call(this,a,b);this.left=a.left;this.right=a.right;this.top=a.top;this.bottom=a.bottom;this.near=
a.near;this.far=a.far;this.zoom=a.zoom;this.view=null===a.view?null:Object.assign({},a.view);return this},setViewOffset:function(a,b,c,d,e,f){null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1});this.view.enabled=!0;this.view.fullWidth=a;this.view.fullHeight=b;this.view.offsetX=c;this.view.offsetY=d;this.view.width=e;this.view.height=f;this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1);this.updateProjectionMatrix()},
updateProjectionMatrix:function(){var a=(this.right-this.left)/(2*this.zoom),b=(this.top-this.bottom)/(2*this.zoom),c=(this.right+this.left)/2,d=(this.top+this.bottom)/2,e=c-a;c+=a;a=d+b;b=d-b;if(null!==this.view&&this.view.enabled){c=this.zoom/(this.view.width/this.view.fullWidth);b=this.zoom/(this.view.height/this.view.fullHeight);var f=(this.right-this.left)/this.view.width;d=(this.top-this.bottom)/this.view.height;e+=this.view.offsetX/c*f;c=e+this.view.width/c*f;a-=this.view.offsetY/b*d;b=a-this.view.height/
b*d}this.projectionMatrix.makeOrthographic(e,c,a,b,this.near,this.far);this.projectionMatrixInverse.getInverse(this.projectionMatrix)},toJSON:function(a){a=E.prototype.toJSON.call(this,a);a.object.zoom=this.zoom;a.object.left=this.left;a.object.right=this.right;a.object.top=this.top;a.object.bottom=this.bottom;a.object.near=this.near;a.object.far=this.far;null!==this.view&&(a.object.view=Object.assign({},this.view));return a}});df.prototype=Object.assign(Object.create(hb.prototype),{constructor:df,
isDirectionalLightShadow:!0,updateMatrices:function(a){hb.prototype.updateMatrices.call(this,a)}});ef.prototype=Object.assign(Object.create(T.prototype),{constructor:ef,isDirectionalLight:!0,copy:function(a){T.prototype.copy.call(this,a);this.target=a.target.clone();this.shadow=a.shadow.clone();return this}});ff.prototype=Object.assign(Object.create(T.prototype),{constructor:ff,isAmbientLight:!0});gf.prototype=Object.assign(Object.create(T.prototype),{constructor:gf,isRectAreaLight:!0,copy:function(a){T.prototype.copy.call(this,
a);this.width=a.width;this.height=a.height;return this},toJSON:function(a){a=T.prototype.toJSON.call(this,a);a.object.width=this.width;a.object.height=this.height;return a}});hf.prototype=Object.assign(Object.create(V.prototype),{constructor:hf,load:function(a,b,c,d){var e=this,f=new Na(e.manager);f.setPath(e.path);f.load(a,function(a){b(e.parse(JSON.parse(a)))},c,d)},parse:function(a){function b(a){void 0===c[a]&&console.warn("THREE.MaterialLoader: Undefined texture",a);return c[a]}var c=this.textures,
d=new Fk[a.type];void 0!==a.uuid&&(d.uuid=a.uuid);void 0!==a.name&&(d.name=a.name);void 0!==a.color&&d.color.setHex(a.color);void 0!==a.roughness&&(d.roughness=a.roughness);void 0!==a.metalness&&(d.metalness=a.metalness);void 0!==a.sheen&&(d.sheen=(new J).setHex(a.sheen));void 0!==a.emissive&&d.emissive.setHex(a.emissive);void 0!==a.specular&&d.specular.setHex(a.specular);void 0!==a.shininess&&(d.shininess=a.shininess);void 0!==a.clearcoat&&(d.clearcoat=a.clearcoat);void 0!==a.clearcoatRoughness&&
(d.clearcoatRoughness=a.clearcoatRoughness);void 0!==a.vertexColors&&(d.vertexColors=a.vertexColors);void 0!==a.fog&&(d.fog=a.fog);void 0!==a.flatShading&&(d.flatShading=a.flatShading);void 0!==a.blending&&(d.blending=a.blending);void 0!==a.combine&&(d.combine=a.combine);void 0!==a.side&&(d.side=a.side);void 0!==a.opacity&&(d.opacity=a.opacity);void 0!==a.transparent&&(d.transparent=a.transparent);void 0!==a.alphaTest&&(d.alphaTest=a.alphaTest);void 0!==a.depthTest&&(d.depthTest=a.depthTest);void 0!==
a.depthWrite&&(d.depthWrite=a.depthWrite);void 0!==a.colorWrite&&(d.colorWrite=a.colorWrite);void 0!==a.stencilWrite&&(d.stencilWrite=a.stencilWrite);void 0!==a.stencilWriteMask&&(d.stencilWriteMask=a.stencilWriteMask);void 0!==a.stencilFunc&&(d.stencilFunc=a.stencilFunc);void 0!==a.stencilRef&&(d.stencilRef=a.stencilRef);void 0!==a.stencilFuncMask&&(d.stencilFuncMask=a.stencilFuncMask);void 0!==a.stencilFail&&(d.stencilFail=a.stencilFail);void 0!==a.stencilZFail&&(d.stencilZFail=a.stencilZFail);
void 0!==a.stencilZPass&&(d.stencilZPass=a.stencilZPass);void 0!==a.wireframe&&(d.wireframe=a.wireframe);void 0!==a.wireframeLinewidth&&(d.wireframeLinewidth=a.wireframeLinewidth);void 0!==a.wireframeLinecap&&(d.wireframeLinecap=a.wireframeLinecap);void 0!==a.wireframeLinejoin&&(d.wireframeLinejoin=a.wireframeLinejoin);void 0!==a.rotation&&(d.rotation=a.rotation);1!==a.linewidth&&(d.linewidth=a.linewidth);void 0!==a.dashSize&&(d.dashSize=a.dashSize);void 0!==a.gapSize&&(d.gapSize=a.gapSize);void 0!==
a.scale&&(d.scale=a.scale);void 0!==a.polygonOffset&&(d.polygonOffset=a.polygonOffset);void 0!==a.polygonOffsetFactor&&(d.polygonOffsetFactor=a.polygonOffsetFactor);void 0!==a.polygonOffsetUnits&&(d.polygonOffsetUnits=a.polygonOffsetUnits);void 0!==a.skinning&&(d.skinning=a.skinning);void 0!==a.morphTargets&&(d.morphTargets=a.morphTargets);void 0!==a.morphNormals&&(d.morphNormals=a.morphNormals);void 0!==a.dithering&&(d.dithering=a.dithering);void 0!==a.visible&&(d.visible=a.visible);void 0!==a.toneMapped&&
(d.toneMapped=a.toneMapped);void 0!==a.userData&&(d.userData=a.userData);if(void 0!==a.uniforms)for(var e in a.uniforms){var f=a.uniforms[e];d.uniforms[e]={};switch(f.type){case "t":d.uniforms[e].value=b(f.value);break;case "c":d.uniforms[e].value=(new J).setHex(f.value);break;case "v2":d.uniforms[e].value=(new B).fromArray(f.value);break;case "v3":d.uniforms[e].value=(new n).fromArray(f.value);break;case "v4":d.uniforms[e].value=(new da).fromArray(f.value);break;case "m3":d.uniforms[e].value=(new Z).fromArray(f.value);
case "m4":d.uniforms[e].value=(new Q).fromArray(f.value);break;default:d.uniforms[e].value=f.value}}void 0!==a.defines&&(d.defines=a.defines);void 0!==a.vertexShader&&(d.vertexShader=a.vertexShader);void 0!==a.fragmentShader&&(d.fragmentShader=a.fragmentShader);if(void 0!==a.extensions)for(var g in a.extensions)d.extensions[g]=a.extensions[g];void 0!==a.shading&&(d.flatShading=1===a.shading);void 0!==a.size&&(d.size=a.size);void 0!==a.sizeAttenuation&&(d.sizeAttenuation=a.sizeAttenuation);void 0!==
a.map&&(d.map=b(a.map));void 0!==a.matcap&&(d.matcap=b(a.matcap));void 0!==a.alphaMap&&(d.alphaMap=b(a.alphaMap),d.transparent=!0);void 0!==a.bumpMap&&(d.bumpMap=b(a.bumpMap));void 0!==a.bumpScale&&(d.bumpScale=a.bumpScale);void 0!==a.normalMap&&(d.normalMap=b(a.normalMap));void 0!==a.normalMapType&&(d.normalMapType=a.normalMapType);void 0!==a.normalScale&&(e=a.normalScale,!1===Array.isArray(e)&&(e=[e,e]),d.normalScale=(new B).fromArray(e));void 0!==a.displacementMap&&(d.displacementMap=b(a.displacementMap));
void 0!==a.displacementScale&&(d.displacementScale=a.displacementScale);void 0!==a.displacementBias&&(d.displacementBias=a.displacementBias);void 0!==a.roughnessMap&&(d.roughnessMap=b(a.roughnessMap));void 0!==a.metalnessMap&&(d.metalnessMap=b(a.metalnessMap));void 0!==a.emissiveMap&&(d.emissiveMap=b(a.emissiveMap));void 0!==a.emissiveIntensity&&(d.emissiveIntensity=a.emissiveIntensity);void 0!==a.specularMap&&(d.specularMap=b(a.specularMap));void 0!==a.envMap&&(d.envMap=b(a.envMap));void 0!==a.envMapIntensity&&
(d.envMapIntensity=a.envMapIntensity);void 0!==a.reflectivity&&(d.reflectivity=a.reflectivity);void 0!==a.refractionRatio&&(d.refractionRatio=a.refractionRatio);void 0!==a.lightMap&&(d.lightMap=b(a.lightMap));void 0!==a.lightMapIntensity&&(d.lightMapIntensity=a.lightMapIntensity);void 0!==a.aoMap&&(d.aoMap=b(a.aoMap));void 0!==a.aoMapIntensity&&(d.aoMapIntensity=a.aoMapIntensity);void 0!==a.gradientMap&&(d.gradientMap=b(a.gradientMap));void 0!==a.clearcoatNormalMap&&(d.clearcoatNormalMap=b(a.clearcoatNormalMap));
void 0!==a.clearcoatNormalScale&&(d.clearcoatNormalScale=(new B).fromArray(a.clearcoatNormalScale));return d},setTextures:function(a){this.textures=a;return this}});var eh={decodeText:function(a){if("undefined"!==typeof TextDecoder)return(new TextDecoder).decode(a);for(var b="",c=0,d=a.length;c<d;c++)b+=String.fromCharCode(a[c]);try{return decodeURIComponent(escape(b))}catch(e){return b}},extractUrlBase:function(a){var b=a.lastIndexOf("/");return-1===b?"./":a.substr(0,b+1)}};jf.prototype=Object.assign(Object.create(D.prototype),
{constructor:jf,isInstancedBufferGeometry:!0,copy:function(a){D.prototype.copy.call(this,a);this.maxInstancedCount=a.maxInstancedCount;return this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){var a=D.prototype.toJSON.call(this);a.maxInstancedCount=this.maxInstancedCount;a.isInstancedBufferGeometry=!0;return a}});kf.prototype=Object.assign(Object.create(N.prototype),{constructor:kf,isInstancedBufferAttribute:!0,copy:function(a){N.prototype.copy.call(this,a);this.meshPerAttribute=
a.meshPerAttribute;return this},toJSON:function(){var a=N.prototype.toJSON.call(this);a.meshPerAttribute=this.meshPerAttribute;a.isInstancedBufferAttribute=!0;return a}});lf.prototype=Object.assign(Object.create(V.prototype),{constructor:lf,load:function(a,b,c,d){var e=this,f=new Na(e.manager);f.setPath(e.path);f.load(a,function(a){b(e.parse(JSON.parse(a)))},c,d)},parse:function(a){var b=a.isInstancedBufferGeometry?new jf:new D,c=a.data.index;if(void 0!==c){var d=new fh[c.type](c.array);b.setIndex(new N(d,
1))}c=a.data.attributes;for(var e in c){var f=c[e];d=new fh[f.type](f.array);d=new (f.isInstancedBufferAttribute?kf:N)(d,f.itemSize,f.normalized);void 0!==f.name&&(d.name=f.name);b.setAttribute(e,d)}var g=a.data.morphAttributes;if(g)for(e in g){var h=g[e],l=[];c=0;for(var k=h.length;c<k;c++)f=h[c],d=new fh[f.type](f.array),d=new N(d,f.itemSize,f.normalized),void 0!==f.name&&(d.name=f.name),l.push(d);b.morphAttributes[e]=l}e=a.data.groups||a.data.drawcalls||a.data.offsets;if(void 0!==e)for(c=0,f=e.length;c!==
f;++c)d=e[c],b.addGroup(d.start,d.count,d.materialIndex);c=a.data.boundingSphere;void 0!==c&&(e=new n,void 0!==c.center&&e.fromArray(c.center),b.boundingSphere=new mb(e,c.radius));a.name&&(b.name=a.name);a.userData&&(b.userData=a.userData);return b}});var fh={Int8Array:Int8Array,Uint8Array:Uint8Array,Uint8ClampedArray:"undefined"!==typeof Uint8ClampedArray?Uint8ClampedArray:Uint8Array,Int16Array:Int16Array,Uint16Array:Uint16Array,Int32Array:Int32Array,Uint32Array:Uint32Array,Float32Array:Float32Array,
Float64Array:Float64Array};mf.prototype=Object.assign(Object.create(V.prototype),{constructor:mf,load:function(a,b,c,d){var e=this,f=""===this.path?eh.extractUrlBase(a):this.path;this.resourcePath=this.resourcePath||f;f=new Na(e.manager);f.setPath(this.path);f.load(a,function(c){var f=null;try{f=JSON.parse(c)}catch(l){void 0!==d&&d(l);console.error("THREE:ObjectLoader: Can't parse "+a+".",l.message);return}c=f.metadata;void 0===c||void 0===c.type||"geometry"===c.type.toLowerCase()?console.error("THREE.ObjectLoader: Can't load "+
a):e.parse(f,b)},c,d)},parse:function(a,b){var c=this.parseShape(a.shapes);c=this.parseGeometries(a.geometries,c);var d=this.parseImages(a.images,function(){void 0!==b&&b(e)});d=this.parseTextures(a.textures,d);d=this.parseMaterials(a.materials,d);var e=this.parseObject(a.object,c,d);a.animations&&(e.animations=this.parseAnimations(a.animations));void 0!==a.images&&0!==a.images.length||void 0===b||b(e);return e},parseShape:function(a){var b={};if(void 0!==a)for(var c=0,d=a.length;c<d;c++){var e=(new Ib).fromJSON(a[c]);
b[e.uuid]=e}return b},parseGeometries:function(a,b){var c={};if(void 0!==a)for(var d=new lf,e=0,f=a.length;e<f;e++){var g=a[e];switch(g.type){case "PlaneGeometry":case "PlaneBufferGeometry":var h=new ja[g.type](g.width,g.height,g.widthSegments,g.heightSegments);break;case "BoxGeometry":case "BoxBufferGeometry":case "CubeGeometry":h=new ja[g.type](g.width,g.height,g.depth,g.widthSegments,g.heightSegments,g.depthSegments);break;case "CircleGeometry":case "CircleBufferGeometry":h=new ja[g.type](g.radius,
g.segments,g.thetaStart,g.thetaLength);break;case "CylinderGeometry":case "CylinderBufferGeometry":h=new ja[g.type](g.radiusTop,g.radiusBottom,g.height,g.radialSegments,g.heightSegments,g.openEnded,g.thetaStart,g.thetaLength);break;case "ConeGeometry":case "ConeBufferGeometry":h=new ja[g.type](g.radius,g.height,g.radialSegments,g.heightSegments,g.openEnded,g.thetaStart,g.thetaLength);break;case "SphereGeometry":case "SphereBufferGeometry":h=new ja[g.type](g.radius,g.widthSegments,g.heightSegments,
g.phiStart,g.phiLength,g.thetaStart,g.thetaLength);break;case "DodecahedronGeometry":case "DodecahedronBufferGeometry":case "IcosahedronGeometry":case "IcosahedronBufferGeometry":case "OctahedronGeometry":case "OctahedronBufferGeometry":case "TetrahedronGeometry":case "TetrahedronBufferGeometry":h=new ja[g.type](g.radius,g.detail);break;case "RingGeometry":case "RingBufferGeometry":h=new ja[g.type](g.innerRadius,g.outerRadius,g.thetaSegments,g.phiSegments,g.thetaStart,g.thetaLength);break;case "TorusGeometry":case "TorusBufferGeometry":h=
new ja[g.type](g.radius,g.tube,g.radialSegments,g.tubularSegments,g.arc);break;case "TorusKnotGeometry":case "TorusKnotBufferGeometry":h=new ja[g.type](g.radius,g.tube,g.tubularSegments,g.radialSegments,g.p,g.q);break;case "TubeGeometry":case "TubeBufferGeometry":h=new ja[g.type]((new dh[g.path.type]).fromJSON(g.path),g.tubularSegments,g.radius,g.radialSegments,g.closed);break;case "LatheGeometry":case "LatheBufferGeometry":h=new ja[g.type](g.points,g.segments,g.phiStart,g.phiLength);break;case "PolyhedronGeometry":case "PolyhedronBufferGeometry":h=
new ja[g.type](g.vertices,g.indices,g.radius,g.details);break;case "ShapeGeometry":case "ShapeBufferGeometry":h=[];for(var l=0,k=g.shapes.length;l<k;l++){var n=b[g.shapes[l]];h.push(n)}h=new ja[g.type](h,g.curveSegments);break;case "ExtrudeGeometry":case "ExtrudeBufferGeometry":h=[];l=0;for(k=g.shapes.length;l<k;l++)n=b[g.shapes[l]],h.push(n);l=g.options.extrudePath;void 0!==l&&(g.options.extrudePath=(new dh[l.type]).fromJSON(l));h=new ja[g.type](h,g.options);break;case "BufferGeometry":case "InstancedBufferGeometry":h=
d.parse(g);break;case "Geometry":"THREE"in window&&"LegacyJSONLoader"in THREE?h=(new THREE.LegacyJSONLoader).parse(g,this.resourcePath).geometry:console.error('THREE.ObjectLoader: You have to import LegacyJSONLoader in order load geometry data of type "Geometry".');break;default:console.warn('THREE.ObjectLoader: Unsupported geometry type "'+g.type+'"');continue}h.uuid=g.uuid;void 0!==g.name&&(h.name=g.name);!0===h.isBufferGeometry&&void 0!==g.userData&&(h.userData=g.userData);c[g.uuid]=h}return c},
parseMaterials:function(a,b){var c={},d={};if(void 0!==a){var e=new hf;e.setTextures(b);b=0;for(var f=a.length;b<f;b++){var g=a[b];if("MultiMaterial"===g.type){for(var h=[],l=0;l<g.materials.length;l++){var k=g.materials[l];void 0===c[k.uuid]&&(c[k.uuid]=e.parse(k));h.push(c[k.uuid])}d[g.uuid]=h}else void 0===c[g.uuid]&&(c[g.uuid]=e.parse(g)),d[g.uuid]=c[g.uuid]}}return d},parseAnimations:function(a){for(var b=[],c=0;c<a.length;c++){var d=a[c],e=Ma.parse(d);void 0!==d.uuid&&(e.uuid=d.uuid);b.push(e)}return b},
parseImages:function(a,b){function c(a){d.manager.itemStart(a);return f.load(a,function(){d.manager.itemEnd(a)},void 0,function(){d.manager.itemError(a);d.manager.itemEnd(a)})}var d=this,e={};if(void 0!==a&&0<a.length){b=new og(b);var f=new ad(b);f.setCrossOrigin(this.crossOrigin);b=0;for(var g=a.length;b<g;b++){var h=a[b],l=h.url;if(Array.isArray(l)){e[h.uuid]=[];for(var k=0,n=l.length;k<n;k++){var q=l[k];q=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(q)?q:d.resourcePath+q;e[h.uuid].push(c(q))}}else q=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(h.url)?
h.url:d.resourcePath+h.url,e[h.uuid]=c(q)}}return e},parseTextures:function(a,b){function c(a,b){if("number"===typeof a)return a;console.warn("THREE.ObjectLoader.parseTexture: Constant should be in numeric form.",a);return b[a]}var d={};if(void 0!==a)for(var e=0,f=a.length;e<f;e++){var g=a[e];void 0===g.image&&console.warn('THREE.ObjectLoader: No "image" specified for',g.uuid);void 0===b[g.image]&&console.warn("THREE.ObjectLoader: Undefined image",g.image);var h=Array.isArray(b[g.image])?new nb(b[g.image]):
new Y(b[g.image]);h.needsUpdate=!0;h.uuid=g.uuid;void 0!==g.name&&(h.name=g.name);void 0!==g.mapping&&(h.mapping=c(g.mapping,Gk));void 0!==g.offset&&h.offset.fromArray(g.offset);void 0!==g.repeat&&h.repeat.fromArray(g.repeat);void 0!==g.center&&h.center.fromArray(g.center);void 0!==g.rotation&&(h.rotation=g.rotation);void 0!==g.wrap&&(h.wrapS=c(g.wrap[0],Di),h.wrapT=c(g.wrap[1],Di));void 0!==g.format&&(h.format=g.format);void 0!==g.type&&(h.type=g.type);void 0!==g.encoding&&(h.encoding=g.encoding);
void 0!==g.minFilter&&(h.minFilter=c(g.minFilter,Ei));void 0!==g.magFilter&&(h.magFilter=c(g.magFilter,Ei));void 0!==g.anisotropy&&(h.anisotropy=g.anisotropy);void 0!==g.flipY&&(h.flipY=g.flipY);void 0!==g.premultiplyAlpha&&(h.premultiplyAlpha=g.premultiplyAlpha);void 0!==g.unpackAlignment&&(h.unpackAlignment=g.unpackAlignment);d[g.uuid]=h}return d},parseObject:function(a,b,c){function d(a){void 0===b[a]&&console.warn("THREE.ObjectLoader: Undefined geometry",a);return b[a]}function e(a){if(void 0!==
a){if(Array.isArray(a)){for(var b=[],d=0,e=a.length;d<e;d++){var f=a[d];void 0===c[f]&&console.warn("THREE.ObjectLoader: Undefined material",f);b.push(c[f])}return b}void 0===c[a]&&console.warn("THREE.ObjectLoader: Undefined material",a);return c[a]}}switch(a.type){case "Scene":var f=new vd;void 0!==a.background&&Number.isInteger(a.background)&&(f.background=new J(a.background));void 0!==a.fog&&("Fog"===a.fog.type?f.fog=new Me(a.fog.color,a.fog.near,a.fog.far):"FogExp2"===a.fog.type&&(f.fog=new Le(a.fog.color,
a.fog.density)));break;case "PerspectiveCamera":f=new U(a.fov,a.aspect,a.near,a.far);void 0!==a.focus&&(f.focus=a.focus);void 0!==a.zoom&&(f.zoom=a.zoom);void 0!==a.filmGauge&&(f.filmGauge=a.filmGauge);void 0!==a.filmOffset&&(f.filmOffset=a.filmOffset);void 0!==a.view&&(f.view=Object.assign({},a.view));break;case "OrthographicCamera":f=new oe(a.left,a.right,a.top,a.bottom,a.near,a.far);void 0!==a.zoom&&(f.zoom=a.zoom);void 0!==a.view&&(f.view=Object.assign({},a.view));break;case "AmbientLight":f=
new ff(a.color,a.intensity);break;case "DirectionalLight":f=new ef(a.color,a.intensity);break;case "PointLight":f=new cf(a.color,a.intensity,a.distance,a.decay);break;case "RectAreaLight":f=new gf(a.color,a.intensity,a.width,a.height);break;case "SpotLight":f=new bf(a.color,a.intensity,a.distance,a.angle,a.penumbra,a.decay);break;case "HemisphereLight":f=new $e(a.color,a.groundColor,a.intensity);break;case "SkinnedMesh":console.warn("THREE.ObjectLoader.parseObject() does not support SkinnedMesh yet.");
case "Mesh":f=d(a.geometry);var g=e(a.material);f=f.bones&&0<f.bones.length?new Od(f,g):new ea(f,g);break;case "InstancedMesh":f=d(a.geometry);g=e(a.material);var h=a.instanceMatrix;f=new Pe(f,g,a.count);f.instanceMatrix=new N(new Float32Array(h.array),16);break;case "LOD":f=new Nd;break;case "Line":f=new ra(d(a.geometry),e(a.material),a.mode);break;case "LineLoop":f=new Qe(d(a.geometry),e(a.material));break;case "LineSegments":f=new X(d(a.geometry),e(a.material));break;case "PointCloud":case "Points":f=
new Jc(d(a.geometry),e(a.material));break;case "Sprite":f=new Ld(e(a.material));break;case "Group":f=new Gc;break;default:f=new E}f.uuid=a.uuid;void 0!==a.name&&(f.name=a.name);void 0!==a.matrix?(f.matrix.fromArray(a.matrix),void 0!==a.matrixAutoUpdate&&(f.matrixAutoUpdate=a.matrixAutoUpdate),f.matrixAutoUpdate&&f.matrix.decompose(f.position,f.quaternion,f.scale)):(void 0!==a.position&&f.position.fromArray(a.position),void 0!==a.rotation&&f.rotation.fromArray(a.rotation),void 0!==a.quaternion&&f.quaternion.fromArray(a.quaternion),
void 0!==a.scale&&f.scale.fromArray(a.scale));void 0!==a.castShadow&&(f.castShadow=a.castShadow);void 0!==a.receiveShadow&&(f.receiveShadow=a.receiveShadow);a.shadow&&(void 0!==a.shadow.bias&&(f.shadow.bias=a.shadow.bias),void 0!==a.shadow.radius&&(f.shadow.radius=a.shadow.radius),void 0!==a.shadow.mapSize&&f.shadow.mapSize.fromArray(a.shadow.mapSize),void 0!==a.shadow.camera&&(f.shadow.camera=this.parseObject(a.shadow.camera)));void 0!==a.visible&&(f.visible=a.visible);void 0!==a.frustumCulled&&
(f.frustumCulled=a.frustumCulled);void 0!==a.renderOrder&&(f.renderOrder=a.renderOrder);void 0!==a.userData&&(f.userData=a.userData);void 0!==a.layers&&(f.layers.mask=a.layers);void 0!==a.drawMode&&f.setDrawMode(a.drawMode);if(void 0!==a.children)for(h=a.children,g=0;g<h.length;g++)f.add(this.parseObject(h[g],b,c));if("LOD"===a.type)for(a=a.levels,h=0;h<a.length;h++){g=a[h];var l=f.getObjectByProperty("uuid",g.object);void 0!==l&&f.addLevel(l,g.distance)}return f}});var Gk={UVMapping:300,CubeReflectionMapping:301,
CubeRefractionMapping:302,EquirectangularReflectionMapping:303,EquirectangularRefractionMapping:304,SphericalReflectionMapping:305,CubeUVReflectionMapping:306,CubeUVRefractionMapping:307},Di={RepeatWrapping:1E3,ClampToEdgeWrapping:1001,MirroredRepeatWrapping:1002},Ei={NearestFilter:1003,NearestMipmapNearestFilter:1004,NearestMipmapLinearFilter:1005,LinearFilter:1006,LinearMipmapNearestFilter:1007,LinearMipmapLinearFilter:1008};tg.prototype=Object.assign(Object.create(V.prototype),{constructor:tg,
setOptions:function(a){this.options=a;return this},load:function(a,b,c,d){void 0===a&&(a="");void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var e=this,f=sc.get(a);if(void 0!==f)return e.manager.itemStart(a),setTimeout(function(){b&&b(f);e.manager.itemEnd(a)},0),f;fetch(a).then(function(a){return a.blob()}).then(function(a){return void 0===e.options?createImageBitmap(a):createImageBitmap(a,e.options)}).then(function(c){sc.add(a,c);b&&b(c);e.manager.itemEnd(a)}).catch(function(b){d&&
d(b);e.manager.itemError(a);e.manager.itemEnd(a)});e.manager.itemStart(a)}});Object.assign(ug.prototype,{moveTo:function(a,b){this.currentPath=new Wa;this.subPaths.push(this.currentPath);this.currentPath.moveTo(a,b);return this},lineTo:function(a,b){this.currentPath.lineTo(a,b);return this},quadraticCurveTo:function(a,b,c,d){this.currentPath.quadraticCurveTo(a,b,c,d);return this},bezierCurveTo:function(a,b,c,d,e,f){this.currentPath.bezierCurveTo(a,b,c,d,e,f);return this},splineThru:function(a){this.currentPath.splineThru(a);
return this},toShapes:function(a,b){function c(a){for(var b=[],c=0,d=a.length;c<d;c++){var e=a[c],f=new Ib;f.curves=e.curves;b.push(f)}return b}function d(a,b){for(var c=b.length,d=!1,e=c-1,f=0;f<c;e=f++){var g=b[e],h=b[f],l=h.x-g.x,k=h.y-g.y;if(Math.abs(k)>Number.EPSILON){if(0>k&&(g=b[f],l=-l,h=b[e],k=-k),!(a.y<g.y||a.y>h.y))if(a.y===g.y){if(a.x===g.x)return!0}else{e=k*(a.x-g.x)-l*(a.y-g.y);if(0===e)return!0;0>e||(d=!d)}}else if(a.y===g.y&&(h.x<=a.x&&a.x<=g.x||g.x<=a.x&&a.x<=h.x))return!0}return d}
var e=qb.isClockWise,f=this.subPaths;if(0===f.length)return[];if(!0===b)return c(f);b=[];if(1===f.length){var g=f[0];var h=new Ib;h.curves=g.curves;b.push(h);return b}var l=!e(f[0].getPoints());l=a?!l:l;h=[];var k=[],n=[],q=0;k[q]=void 0;n[q]=[];for(var u=0,p=f.length;u<p;u++){g=f[u];var t=g.getPoints();var v=e(t);(v=a?!v:v)?(!l&&k[q]&&q++,k[q]={s:new Ib,p:t},k[q].s.curves=g.curves,l&&q++,n[q]=[]):n[q].push({h:g,p:t[0]})}if(!k[0])return c(f);if(1<k.length){u=!1;a=[];e=0;for(f=k.length;e<f;e++)h[e]=
[];e=0;for(f=k.length;e<f;e++)for(g=n[e],v=0;v<g.length;v++){l=g[v];q=!0;for(t=0;t<k.length;t++)d(l.p,k[t].p)&&(e!==t&&a.push({froms:e,tos:t,hole:v}),q?(q=!1,h[t].push(l)):u=!0);q&&h[e].push(l)}0<a.length&&(u||(n=h))}u=0;for(e=k.length;u<e;u++)for(h=k[u].s,b.push(h),a=n[u],f=0,g=a.length;f<g;f++)h.holes.push(a[f].h);return b}});Object.assign(vg.prototype,{isFont:!0,generateShapes:function(a,b){void 0===b&&(b=100);var c=[],d=b;b=this.data;var e=Array.from?Array.from(a):String(a).split("");d/=b.resolution;
var f=(b.boundingBox.yMax-b.boundingBox.yMin+b.underlineThickness)*d;a=[];for(var g=0,h=0,l=0;l<e.length;l++){var k=e[l];if("\n"===k)g=0,h-=f;else{var n=k;k=d;var q=g,u=h,p=b,t=p.glyphs[n]||p.glyphs["?"];if(t){n=new ug;if(t.o){p=t._cachedOutline||(t._cachedOutline=t.o.split(" "));for(var v=0,y=p.length;v<y;)switch(p[v++]){case "m":var w=p[v++]*k+q;var x=p[v++]*k+u;n.moveTo(w,x);break;case "l":w=p[v++]*k+q;x=p[v++]*k+u;n.lineTo(w,x);break;case "q":var A=p[v++]*k+q;var B=p[v++]*k+u;var z=p[v++]*k+q;
var C=p[v++]*k+u;n.quadraticCurveTo(z,C,A,B);break;case "b":A=p[v++]*k+q,B=p[v++]*k+u,z=p[v++]*k+q,C=p[v++]*k+u,w=p[v++]*k+q,x=p[v++]*k+u,n.bezierCurveTo(z,C,w,x,A,B)}}k={offsetX:t.ha*k,path:n}}else console.error('THREE.Font: character "'+n+'" does not exists in font family '+p.familyName+"."),k=void 0;g+=k.offsetX;a.push(k.path)}}b=0;for(e=a.length;b<e;b++)Array.prototype.push.apply(c,a[b].toShapes());return c}});wg.prototype=Object.assign(Object.create(V.prototype),{constructor:wg,load:function(a,
b,c,d){var e=this,f=new Na(this.manager);f.setPath(this.path);f.load(a,function(a){try{var c=JSON.parse(a)}catch(l){console.warn("THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead."),c=JSON.parse(a.substring(65,a.length-2))}a=e.parse(c);b&&b(a)},c,d)},parse:function(a){return new vg(a)}});var Mf,Bg={getContext:function(){void 0===Mf&&(Mf=new (window.AudioContext||window.webkitAudioContext));return Mf},setContext:function(a){Mf=a}};nf.prototype=Object.assign(Object.create(V.prototype),
{constructor:nf,load:function(a,b,c,d){var e=new Na(this.manager);e.setResponseType("arraybuffer");e.setPath(this.path);e.load(a,function(a){a=a.slice(0);Bg.getContext().decodeAudioData(a,function(a){b(a)})},c,d)}});Object.assign(of.prototype,{isSphericalHarmonics3:!0,set:function(a){for(var b=0;9>b;b++)this.coefficients[b].copy(a[b]);return this},zero:function(){for(var a=0;9>a;a++)this.coefficients[a].set(0,0,0);return this},getAt:function(a,b){var c=a.x,d=a.y;a=a.z;var e=this.coefficients;b.copy(e[0]).multiplyScalar(.282095);
b.addScale(e[1],.488603*d);b.addScale(e[2],.488603*a);b.addScale(e[3],.488603*c);b.addScale(e[4],1.092548*c*d);b.addScale(e[5],1.092548*d*a);b.addScale(e[6],.315392*(3*a*a-1));b.addScale(e[7],1.092548*c*a);b.addScale(e[8],.546274*(c*c-d*d));return b},getIrradianceAt:function(a,b){var c=a.x,d=a.y;a=a.z;var e=this.coefficients;b.copy(e[0]).multiplyScalar(.886227);b.addScale(e[1],1.023328*d);b.addScale(e[2],1.023328*a);b.addScale(e[3],1.023328*c);b.addScale(e[4],.858086*c*d);b.addScale(e[5],.858086*
d*a);b.addScale(e[6],.743125*a*a-.247708);b.addScale(e[7],.858086*c*a);b.addScale(e[8],.429043*(c*c-d*d));return b},add:function(a){for(var b=0;9>b;b++)this.coefficients[b].add(a.coefficients[b]);return this},scale:function(a){for(var b=0;9>b;b++)this.coefficients[b].multiplyScalar(a);return this},lerp:function(a,b){for(var c=0;9>c;c++)this.coefficients[c].lerp(a.coefficients[c],b);return this},equals:function(a){for(var b=0;9>b;b++)if(!this.coefficients[b].equals(a.coefficients[b]))return!1;return!0},
copy:function(a){return this.set(a.coefficients)},clone:function(){return(new this.constructor).copy(this)},fromArray:function(a,b){void 0===b&&(b=0);for(var c=this.coefficients,d=0;9>d;d++)c[d].fromArray(a,b+3*d);return this},toArray:function(a,b){void 0===a&&(a=[]);void 0===b&&(b=0);for(var c=this.coefficients,d=0;9>d;d++)c[d].toArray(a,b+3*d);return a}});Object.assign(of,{getBasisAt:function(a,b){var c=a.x,d=a.y;a=a.z;b[0]=.282095;b[1]=.488603*d;b[2]=.488603*a;b[3]=.488603*c;b[4]=1.092548*c*d;
b[5]=1.092548*d*a;b[6]=.315392*(3*a*a-1);b[7]=1.092548*c*a;b[8]=.546274*(c*c-d*d)}});Xa.prototype=Object.assign(Object.create(T.prototype),{constructor:Xa,isLightProbe:!0,copy:function(a){T.prototype.copy.call(this,a);this.sh.copy(a.sh);this.intensity=a.intensity;return this},toJSON:function(a){return T.prototype.toJSON.call(this,a)}});xg.prototype=Object.assign(Object.create(Xa.prototype),{constructor:xg,isHemisphereLightProbe:!0,copy:function(a){Xa.prototype.copy.call(this,a);return this},toJSON:function(a){return Xa.prototype.toJSON.call(this,
a)}});yg.prototype=Object.assign(Object.create(Xa.prototype),{constructor:yg,isAmbientLightProbe:!0,copy:function(a){Xa.prototype.copy.call(this,a);return this},toJSON:function(a){return Xa.prototype.toJSON.call(this,a)}});var Fi=new Q,Gi=new Q;Object.assign(ai.prototype,{update:function(a){var b=this._cache;if(b.focus!==a.focus||b.fov!==a.fov||b.aspect!==a.aspect*this.aspect||b.near!==a.near||b.far!==a.far||b.zoom!==a.zoom||b.eyeSep!==this.eyeSep){b.focus=a.focus;b.fov=a.fov;b.aspect=a.aspect*this.aspect;
b.near=a.near;b.far=a.far;b.zoom=a.zoom;b.eyeSep=this.eyeSep;var c=a.projectionMatrix.clone(),d=b.eyeSep/2,e=d*b.near/b.focus,f=b.near*Math.tan(P.DEG2RAD*b.fov*.5)/b.zoom;Gi.elements[12]=-d;Fi.elements[12]=d;d=-f*b.aspect+e;var g=f*b.aspect+e;c.elements[0]=2*b.near/(g-d);c.elements[8]=(g+d)/(g-d);this.cameraL.projectionMatrix.copy(c);d=-f*b.aspect-e;g=f*b.aspect-e;c.elements[0]=2*b.near/(g-d);c.elements[8]=(g+d)/(g-d);this.cameraR.projectionMatrix.copy(c)}this.cameraL.matrixWorld.copy(a.matrixWorld).multiply(Gi);
this.cameraR.matrixWorld.copy(a.matrixWorld).multiply(Fi)}});Object.assign(zg.prototype,{start:function(){this.oldTime=this.startTime=("undefined"===typeof performance?Date:performance).now();this.elapsedTime=0;this.running=!0},stop:function(){this.getElapsedTime();this.autoStart=this.running=!1},getElapsedTime:function(){this.getDelta();return this.elapsedTime},getDelta:function(){var a=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){var b=("undefined"===typeof performance?
Date:performance).now();a=(b-this.oldTime)/1E3;this.oldTime=b;this.elapsedTime+=a}return a}});var tc=new n,Hi=new wa,Hk=new n,uc=new n;Ag.prototype=Object.assign(Object.create(E.prototype),{constructor:Ag,getInput:function(){return this.gain},removeFilter:function(){null!==this.filter&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null);return this},getFilter:function(){return this.filter},setFilter:function(a){null!==
this.filter?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination);this.filter=a;this.gain.connect(this.filter);this.filter.connect(this.context.destination);return this},getMasterVolume:function(){return this.gain.gain.value},setMasterVolume:function(a){this.gain.gain.setTargetAtTime(a,this.context.currentTime,.01);return this},updateMatrixWorld:function(a){E.prototype.updateMatrixWorld.call(this,a);a=this.context.listener;
var b=this.up;this.timeDelta=this._clock.getDelta();this.matrixWorld.decompose(tc,Hi,Hk);uc.set(0,0,-1).applyQuaternion(Hi);if(a.positionX){var c=this.context.currentTime+this.timeDelta;a.positionX.linearRampToValueAtTime(tc.x,c);a.positionY.linearRampToValueAtTime(tc.y,c);a.positionZ.linearRampToValueAtTime(tc.z,c);a.forwardX.linearRampToValueAtTime(uc.x,c);a.forwardY.linearRampToValueAtTime(uc.y,c);a.forwardZ.linearRampToValueAtTime(uc.z,c);a.upX.linearRampToValueAtTime(b.x,c);a.upY.linearRampToValueAtTime(b.y,
c);a.upZ.linearRampToValueAtTime(b.z,c)}else a.setPosition(tc.x,tc.y,tc.z),a.setOrientation(uc.x,uc.y,uc.z,b.x,b.y,b.z)}});cd.prototype=Object.assign(Object.create(E.prototype),{constructor:cd,getOutput:function(){return this.gain},setNodeSource:function(a){this.hasPlaybackControl=!1;this.sourceType="audioNode";this.source=a;this.connect();return this},setMediaElementSource:function(a){this.hasPlaybackControl=!1;this.sourceType="mediaNode";this.source=this.context.createMediaElementSource(a);this.connect();
return this},setMediaStreamSource:function(a){this.hasPlaybackControl=!1;this.sourceType="mediaStreamNode";this.source=this.context.createMediaStreamSource(a);this.connect();return this},setBuffer:function(a){this.buffer=a;this.sourceType="buffer";this.autoplay&&this.play();return this},play:function(a){void 0===a&&(a=0);if(!0===this.isPlaying)console.warn("THREE.Audio: Audio is already playing.");else if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");
else return this._startedAt=this.context.currentTime+a,a=this.context.createBufferSource(),a.buffer=this.buffer,a.loop=this.loop,a.loopStart=this.loopStart,a.loopEnd=this.loopEnd,a.onended=this.onEnded.bind(this),a.start(this._startedAt,this._pausedAt+this.offset,this.duration),this.isPlaying=!0,this.source=a,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()},pause:function(){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");
else return!0===this.isPlaying&&(this._pausedAt=(this.context.currentTime-this._startedAt)*this.playbackRate,this.source.stop(),this.source.onended=null,this.isPlaying=!1),this},stop:function(){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");else return this._pausedAt=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this},connect:function(){if(0<this.filters.length){this.source.connect(this.filters[0]);for(var a=1,b=this.filters.length;a<
b;a++)this.filters[a-1].connect(this.filters[a]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this},disconnect:function(){if(0<this.filters.length){this.source.disconnect(this.filters[0]);for(var a=1,b=this.filters.length;a<b;a++)this.filters[a-1].disconnect(this.filters[a]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this},getFilters:function(){return this.filters},
setFilters:function(a){a||(a=[]);!0===this.isPlaying?(this.disconnect(),this.filters=a,this.connect()):this.filters=a;return this},setDetune:function(a){this.detune=a;if(void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this},getDetune:function(){return this.detune},getFilter:function(){return this.getFilters()[0]},setFilter:function(a){return this.setFilters(a?[a]:[])},setPlaybackRate:function(a){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");
else return this.playbackRate=a,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this},getPlaybackRate:function(){return this.playbackRate},onEnded:function(){this.isPlaying=!1},getLoop:function(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop},setLoop:function(a){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");else return this.loop=
a,!0===this.isPlaying&&(this.source.loop=this.loop),this},setLoopStart:function(a){this.loopStart=a;return this},setLoopEnd:function(a){this.loopEnd=a;return this},getVolume:function(){return this.gain.gain.value},setVolume:function(a){this.gain.gain.setTargetAtTime(a,this.context.currentTime,.01);return this}});var vc=new n,Ii=new wa,Ik=new n,wc=new n;Cg.prototype=Object.assign(Object.create(cd.prototype),{constructor:Cg,getOutput:function(){return this.panner},getRefDistance:function(){return this.panner.refDistance},
setRefDistance:function(a){this.panner.refDistance=a;return this},getRolloffFactor:function(){return this.panner.rolloffFactor},setRolloffFactor:function(a){this.panner.rolloffFactor=a;return this},getDistanceModel:function(){return this.panner.distanceModel},setDistanceModel:function(a){this.panner.distanceModel=a;return this},getMaxDistance:function(){return this.panner.maxDistance},setMaxDistance:function(a){this.panner.maxDistance=a;return this},setDirectionalCone:function(a,b,c){this.panner.coneInnerAngle=
a;this.panner.coneOuterAngle=b;this.panner.coneOuterGain=c;return this},updateMatrixWorld:function(a){E.prototype.updateMatrixWorld.call(this,a);if(!0!==this.hasPlaybackControl||!1!==this.isPlaying)if(this.matrixWorld.decompose(vc,Ii,Ik),wc.set(0,0,1).applyQuaternion(Ii),a=this.panner,a.positionX){var b=this.context.currentTime+this.listener.timeDelta;a.positionX.linearRampToValueAtTime(vc.x,b);a.positionY.linearRampToValueAtTime(vc.y,b);a.positionZ.linearRampToValueAtTime(vc.z,b);a.orientationX.linearRampToValueAtTime(wc.x,
b);a.orientationY.linearRampToValueAtTime(wc.y,b);a.orientationZ.linearRampToValueAtTime(wc.z,b)}else a.setPosition(vc.x,vc.y,vc.z),a.setOrientation(wc.x,wc.y,wc.z)}});Object.assign(Dg.prototype,{getFrequencyData:function(){this.analyser.getByteFrequencyData(this.data);return this.data},getAverageFrequency:function(){for(var a=0,b=this.getFrequencyData(),c=0;c<b.length;c++)a+=b[c];return a/b.length}});Object.assign(Eg.prototype,{accumulate:function(a,b){var c=this.buffer,d=this.valueSize;a=a*d+d;
var e=this.cumulativeWeight;if(0===e){for(e=0;e!==d;++e)c[a+e]=c[e];e=b}else e+=b,this._mixBufferRegion(c,a,0,b/e,d);this.cumulativeWeight=e},apply:function(a){var b=this.valueSize,c=this.buffer;a=a*b+b;var d=this.cumulativeWeight,e=this.binding;this.cumulativeWeight=0;1>d&&this._mixBufferRegion(c,a,3*b,1-d,b);d=b;for(var f=b+b;d!==f;++d)if(c[d]!==c[d+b]){e.setValue(c,a);break}},saveOriginalState:function(){var a=this.buffer,b=this.valueSize,c=3*b;this.binding.getValue(a,c);for(var d=b;d!==c;++d)a[d]=
a[c+d%b];this.cumulativeWeight=0},restoreOriginalState:function(){this.binding.setValue(this.buffer,3*this.valueSize)},_select:function(a,b,c,d,e){if(.5<=d)for(d=0;d!==e;++d)a[b+d]=a[c+d]},_slerp:function(a,b,c,d){wa.slerpFlat(a,b,a,b,a,c,d)},_lerp:function(a,b,c,d,e){for(var f=1-d,g=0;g!==e;++g){var h=b+g;a[h]=a[h]*f+a[c+g]*d}}});var Jk=/[\[\]\.:\/]/g,Kk="[^"+"\\[\\]\\.:\\/".replace("\\.","")+"]",Lk=/((?:WC+[\/:])*)/.source.replace("WC","[^\\[\\]\\.:\\/]"),Mk=/(WCOD+)?/.source.replace("WCOD",Kk),
Nk=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC","[^\\[\\]\\.:\\/]"),Ok=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC","[^\\[\\]\\.:\\/]"),Pk=new RegExp("^"+Lk+Mk+Nk+Ok+"$"),Qk=["material","materials","bones"];Object.assign(bi.prototype,{getValue:function(a,b){this.bind();var c=this._bindings[this._targetGroup.nCachedObjects_];void 0!==c&&c.getValue(a,b)},setValue:function(a,b){for(var c=this._bindings,d=this._targetGroup.nCachedObjects_,e=c.length;d!==e;++d)c[d].setValue(a,b)},bind:function(){for(var a=
this._bindings,b=this._targetGroup.nCachedObjects_,c=a.length;b!==c;++b)a[b].bind()},unbind:function(){for(var a=this._bindings,b=this._targetGroup.nCachedObjects_,c=a.length;b!==c;++b)a[b].unbind()}});Object.assign(ya,{Composite:bi,create:function(a,b,c){return a&&a.isAnimationObjectGroup?new ya.Composite(a,b,c):new ya(a,b,c)},sanitizeNodeName:function(a){return a.replace(/\s/g,"_").replace(Jk,"")},parseTrackName:function(a){var b=Pk.exec(a);if(!b)throw Error("PropertyBinding: Cannot parse trackName: "+
a);b={nodeName:b[2],objectName:b[3],objectIndex:b[4],propertyName:b[5],propertyIndex:b[6]};var c=b.nodeName&&b.nodeName.lastIndexOf(".");if(void 0!==c&&-1!==c){var d=b.nodeName.substring(c+1);-1!==Qk.indexOf(d)&&(b.nodeName=b.nodeName.substring(0,c),b.objectName=d)}if(null===b.propertyName||0===b.propertyName.length)throw Error("PropertyBinding: can not parse propertyName from trackName: "+a);return b},findNode:function(a,b){if(!b||""===b||"root"===b||"."===b||-1===b||b===a.name||b===a.uuid)return a;
if(a.skeleton){var c=a.skeleton.getBoneByName(b);if(void 0!==c)return c}if(a.children){var d=function(a){for(var c=0;c<a.length;c++){var e=a[c];if(e.name===b||e.uuid===b||(e=d(e.children)))return e}return null};if(a=d(a.children))return a}return null}});Object.assign(ya.prototype,{_getValue_unavailable:function(){},_setValue_unavailable:function(){},BindingType:{Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},Versioning:{None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},GetterByBindingType:[function(a,
b){a[b]=this.node[this.propertyName]},function(a,b){for(var c=this.resolvedProperty,d=0,e=c.length;d!==e;++d)a[b++]=c[d]},function(a,b){a[b]=this.resolvedProperty[this.propertyIndex]},function(a,b){this.resolvedProperty.toArray(a,b)}],SetterByBindingTypeAndVersioning:[[function(a,b){this.targetObject[this.propertyName]=a[b]},function(a,b){this.targetObject[this.propertyName]=a[b];this.targetObject.needsUpdate=!0},function(a,b){this.targetObject[this.propertyName]=a[b];this.targetObject.matrixWorldNeedsUpdate=
!0}],[function(a,b){for(var c=this.resolvedProperty,d=0,e=c.length;d!==e;++d)c[d]=a[b++]},function(a,b){for(var c=this.resolvedProperty,d=0,e=c.length;d!==e;++d)c[d]=a[b++];this.targetObject.needsUpdate=!0},function(a,b){for(var c=this.resolvedProperty,d=0,e=c.length;d!==e;++d)c[d]=a[b++];this.targetObject.matrixWorldNeedsUpdate=!0}],[function(a,b){this.resolvedProperty[this.propertyIndex]=a[b]},function(a,b){this.resolvedProperty[this.propertyIndex]=a[b];this.targetObject.needsUpdate=!0},function(a,
b){this.resolvedProperty[this.propertyIndex]=a[b];this.targetObject.matrixWorldNeedsUpdate=!0}],[function(a,b){this.resolvedProperty.fromArray(a,b)},function(a,b){this.resolvedProperty.fromArray(a,b);this.targetObject.needsUpdate=!0},function(a,b){this.resolvedProperty.fromArray(a,b);this.targetObject.matrixWorldNeedsUpdate=!0}]],getValue:function(a,b){this.bind();this.getValue(a,b)},setValue:function(a,b){this.bind();this.setValue(a,b)},bind:function(){var a=this.node,b=this.parsedPath,c=b.objectName,
d=b.propertyName,e=b.propertyIndex;a||(this.node=a=ya.findNode(this.rootNode,b.nodeName)||this.rootNode);this.getValue=this._getValue_unavailable;this.setValue=this._setValue_unavailable;if(a){if(c){var f=b.objectIndex;switch(c){case "materials":if(!a.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!a.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",
this);return}a=a.material.materials;break;case "bones":if(!a.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}a=a.skeleton.bones;for(c=0;c<a.length;c++)if(a[c].name===f){f=c;break}break;default:if(void 0===a[c]){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}a=a[c]}if(void 0!==f){if(void 0===a[f]){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",
this,a);return}a=a[f]}}f=a[d];if(void 0===f)console.error("THREE.PropertyBinding: Trying to update property for track: "+b.nodeName+"."+d+" but it wasn't found.",a);else{b=this.Versioning.None;this.targetObject=a;void 0!==a.needsUpdate?b=this.Versioning.NeedsUpdate:void 0!==a.matrixWorldNeedsUpdate&&(b=this.Versioning.MatrixWorldNeedsUpdate);c=this.BindingType.Direct;if(void 0!==e){if("morphTargetInfluences"===d){if(!a.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",
this);return}if(a.geometry.isBufferGeometry){if(!a.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}for(c=0;c<this.node.geometry.morphAttributes.position.length;c++)if(a.geometry.morphAttributes.position[c].name===e){e=c;break}}else{if(!a.geometry.morphTargets){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphTargets.",
this);return}for(c=0;c<this.node.geometry.morphTargets.length;c++)if(a.geometry.morphTargets[c].name===e){e=c;break}}}c=this.BindingType.ArrayElement;this.resolvedProperty=f;this.propertyIndex=e}else void 0!==f.fromArray&&void 0!==f.toArray?(c=this.BindingType.HasFromToArray,this.resolvedProperty=f):Array.isArray(f)?(c=this.BindingType.EntireArray,this.resolvedProperty=f):this.propertyName=d;this.getValue=this.GetterByBindingType[c];this.setValue=this.SetterByBindingTypeAndVersioning[c][b]}}else console.error("THREE.PropertyBinding: Trying to update node for track: "+
this.path+" but it wasn't found.")},unbind:function(){this.node=null;this.getValue=this._getValue_unbound;this.setValue=this._setValue_unbound}});Object.assign(ya.prototype,{_getValue_unbound:ya.prototype.getValue,_setValue_unbound:ya.prototype.setValue});Object.assign(ci.prototype,{isAnimationObjectGroup:!0,add:function(){for(var a=this._objects,b=a.length,c=this.nCachedObjects_,d=this._indicesByUUID,e=this._paths,f=this._parsedPaths,g=this._bindings,h=g.length,k=void 0,m=0,n=arguments.length;m!==
n;++m){var q=arguments[m],u=q.uuid,p=d[u];if(void 0===p){p=b++;d[u]=p;a.push(q);u=0;for(var t=h;u!==t;++u)g[u].push(new ya(q,e[u],f[u]))}else if(p<c){k=a[p];var v=--c;t=a[v];d[t.uuid]=p;a[p]=t;d[u]=v;a[v]=q;u=0;for(t=h;u!==t;++u){var y=g[u],w=y[p];y[p]=y[v];void 0===w&&(w=new ya(q,e[u],f[u]));y[v]=w}}else a[p]!==k&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=
c},remove:function(){for(var a=this._objects,b=this.nCachedObjects_,c=this._indicesByUUID,d=this._bindings,e=d.length,f=0,g=arguments.length;f!==g;++f){var h=arguments[f],k=h.uuid,m=c[k];if(void 0!==m&&m>=b){var n=b++,q=a[n];c[q.uuid]=m;a[m]=q;c[k]=n;a[n]=h;h=0;for(k=e;h!==k;++h){q=d[h];var u=q[m];q[m]=q[n];q[n]=u}}}this.nCachedObjects_=b},uncache:function(){for(var a=this._objects,b=a.length,c=this.nCachedObjects_,d=this._indicesByUUID,e=this._bindings,f=e.length,g=0,h=arguments.length;g!==h;++g){var k=
arguments[g].uuid,m=d[k];if(void 0!==m)if(delete d[k],m<c){k=--c;var n=a[k],q=--b,u=a[q];d[n.uuid]=m;a[m]=n;d[u.uuid]=k;a[k]=u;a.pop();n=0;for(u=f;n!==u;++n){var p=e[n],t=p[q];p[m]=p[k];p[k]=t;p.pop()}}else for(q=--b,u=a[q],d[u.uuid]=m,a[m]=u,a.pop(),n=0,u=f;n!==u;++n)p=e[n],p[m]=p[q],p.pop()}this.nCachedObjects_=c},subscribe_:function(a,b){var c=this._bindingsIndicesByPath,d=c[a],e=this._bindings;if(void 0!==d)return e[d];var f=this._paths,g=this._parsedPaths,h=this._objects,k=this.nCachedObjects_,
m=Array(h.length);d=e.length;c[a]=d;f.push(a);g.push(b);e.push(m);c=k;for(d=h.length;c!==d;++c)m[c]=new ya(h[c],a,b);return m},unsubscribe_:function(a){var b=this._bindingsIndicesByPath,c=b[a];if(void 0!==c){var d=this._paths,e=this._parsedPaths,f=this._bindings,g=f.length-1,h=f[g];b[a[g]]=c;f[c]=h;f.pop();e[c]=e[g];e.pop();d[c]=d[g];d.pop()}}});Object.assign(di.prototype,{play:function(){this._mixer._activateAction(this);return this},stop:function(){this._mixer._deactivateAction(this);return this.reset()},
reset:function(){this.paused=!1;this.enabled=!0;this.time=0;this._loopCount=-1;this._startTime=null;return this.stopFading().stopWarping()},isRunning:function(){return this.enabled&&!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)},isScheduled:function(){return this._mixer._isActiveAction(this)},startAt:function(a){this._startTime=a;return this},setLoop:function(a,b){this.loop=a;this.repetitions=b;return this},setEffectiveWeight:function(a){this.weight=a;
this._effectiveWeight=this.enabled?a:0;return this.stopFading()},getEffectiveWeight:function(){return this._effectiveWeight},fadeIn:function(a){return this._scheduleFading(a,0,1)},fadeOut:function(a){return this._scheduleFading(a,1,0)},crossFadeFrom:function(a,b,c){a.fadeOut(b);this.fadeIn(b);if(c){c=this._clip.duration;var d=a._clip.duration,e=c/d;a.warp(1,d/c,b);this.warp(e,1,b)}return this},crossFadeTo:function(a,b,c){return a.crossFadeFrom(this,b,c)},stopFading:function(){var a=this._weightInterpolant;
null!==a&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(a));return this},setEffectiveTimeScale:function(a){this.timeScale=a;this._effectiveTimeScale=this.paused?0:a;return this.stopWarping()},getEffectiveTimeScale:function(){return this._effectiveTimeScale},setDuration:function(a){this.timeScale=this._clip.duration/a;return this.stopWarping()},syncWith:function(a){this.time=a.time;this.timeScale=a.timeScale;return this.stopWarping()},halt:function(a){return this.warp(this._effectiveTimeScale,
0,a)},warp:function(a,b,c){var d=this._mixer,e=d.time,f=this._timeScaleInterpolant,g=this.timeScale;null===f&&(this._timeScaleInterpolant=f=d._lendControlInterpolant());d=f.parameterPositions;f=f.sampleValues;d[0]=e;d[1]=e+c;f[0]=a/g;f[1]=b/g;return this},stopWarping:function(){var a=this._timeScaleInterpolant;null!==a&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(a));return this},getMixer:function(){return this._mixer},getClip:function(){return this._clip},getRoot:function(){return this._localRoot||
this._mixer._root},_update:function(a,b,c,d){if(this.enabled){var e=this._startTime;if(null!==e){b=(a-e)*c;if(0>b||0===c)return;this._startTime=null;b*=c}b*=this._updateTimeScale(a);c=this._updateTime(b);a=this._updateWeight(a);if(0<a){b=this._interpolants;e=this._propertyBindings;for(var f=0,g=b.length;f!==g;++f)b[f].evaluate(c),e[f].accumulate(d,a)}}else this._updateWeight(a)},_updateWeight:function(a){var b=0;if(this.enabled){b=this.weight;var c=this._weightInterpolant;if(null!==c){var d=c.evaluate(a)[0];
b*=d;a>c.parameterPositions[1]&&(this.stopFading(),0===d&&(this.enabled=!1))}}return this._effectiveWeight=b},_updateTimeScale:function(a){var b=0;if(!this.paused){b=this.timeScale;var c=this._timeScaleInterpolant;if(null!==c){var d=c.evaluate(a)[0];b*=d;a>c.parameterPositions[1]&&(this.stopWarping(),0===b?this.paused=!0:this.timeScale=b)}}return this._effectiveTimeScale=b},_updateTime:function(a){var b=this.time+a,c=this._clip.duration,d=this.loop,e=this._loopCount,f=2202===d;if(0===a)return-1===
e?b:f&&1===(e&1)?c-b:b;if(2200===d)a:{if(-1===e&&(this._loopCount=0,this._setEndings(!0,!0,!1)),b>=c)b=c;else if(0>b)b=0;else{this.time=b;break a}this.clampWhenFinished?this.paused=!0:this.enabled=!1;this.time=b;this._mixer.dispatchEvent({type:"finished",action:this,direction:0>a?-1:1})}else{-1===e&&(0<=a?(e=0,this._setEndings(!0,0===this.repetitions,f)):this._setEndings(0===this.repetitions,!0,f));if(b>=c||0>b){d=Math.floor(b/c);b-=c*d;e+=Math.abs(d);var g=this.repetitions-e;0>=g?(this.clampWhenFinished?
this.paused=!0:this.enabled=!1,this.time=b=0<a?c:0,this._mixer.dispatchEvent({type:"finished",action:this,direction:0<a?1:-1})):(1===g?(a=0>a,this._setEndings(a,!a,f)):this._setEndings(!1,!1,f),this._loopCount=e,this.time=b,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:d}))}else this.time=b;if(f&&1===(e&1))return c-b}return b},_setEndings:function(a,b,c){var d=this._interpolantSettings;c?(d.endingStart=2401,d.endingEnd=2401):(d.endingStart=a?this.zeroSlopeAtStart?2401:2400:2402,d.endingEnd=
b?this.zeroSlopeAtEnd?2401:2400:2402)},_scheduleFading:function(a,b,c){var d=this._mixer,e=d.time,f=this._weightInterpolant;null===f&&(this._weightInterpolant=f=d._lendControlInterpolant());d=f.parameterPositions;f=f.sampleValues;d[0]=e;f[0]=b;d[1]=e+a;f[1]=c;return this}});Fg.prototype=Object.assign(Object.create(Aa.prototype),{constructor:Fg,_bindAction:function(a,b){var c=a._localRoot||this._root,d=a._clip.tracks,e=d.length,f=a._propertyBindings;a=a._interpolants;var g=c.uuid,h=this._bindingsByRootAndName,
k=h[g];void 0===k&&(k={},h[g]=k);for(h=0;h!==e;++h){var m=d[h],n=m.name,q=k[n];if(void 0===q){q=f[h];if(void 0!==q){null===q._cacheIndex&&(++q.referenceCount,this._addInactiveBinding(q,g,n));continue}q=new Eg(ya.create(c,n,b&&b._propertyBindings[h].binding.parsedPath),m.ValueTypeName,m.getValueSize());++q.referenceCount;this._addInactiveBinding(q,g,n)}f[h]=q;a[h].resultBuffer=q.buffer}},_activateAction:function(a){if(!this._isActiveAction(a)){if(null===a._cacheIndex){var b=(a._localRoot||this._root).uuid,
c=a._clip.uuid,d=this._actionsByClip[c];this._bindAction(a,d&&d.knownActions[0]);this._addInactiveAction(a,c,b)}b=a._propertyBindings;c=0;for(d=b.length;c!==d;++c){var e=b[c];0===e.useCount++&&(this._lendBinding(e),e.saveOriginalState())}this._lendAction(a)}},_deactivateAction:function(a){if(this._isActiveAction(a)){for(var b=a._propertyBindings,c=0,d=b.length;c!==d;++c){var e=b[c];0===--e.useCount&&(e.restoreOriginalState(),this._takeBackBinding(e))}this._takeBackAction(a)}},_initMemoryManager:function(){this._actions=
[];this._nActiveActions=0;this._actionsByClip={};this._bindings=[];this._nActiveBindings=0;this._bindingsByRootAndName={};this._controlInterpolants=[];this._nActiveControlInterpolants=0;var a=this;this.stats={actions:{get total(){return a._actions.length},get inUse(){return a._nActiveActions}},bindings:{get total(){return a._bindings.length},get inUse(){return a._nActiveBindings}},controlInterpolants:{get total(){return a._controlInterpolants.length},get inUse(){return a._nActiveControlInterpolants}}}},
_isActiveAction:function(a){a=a._cacheIndex;return null!==a&&a<this._nActiveActions},_addInactiveAction:function(a,b,c){var d=this._actions,e=this._actionsByClip,f=e[b];void 0===f?(f={knownActions:[a],actionByRoot:{}},a._byClipCacheIndex=0,e[b]=f):(b=f.knownActions,a._byClipCacheIndex=b.length,b.push(a));a._cacheIndex=d.length;d.push(a);f.actionByRoot[c]=a},_removeInactiveAction:function(a){var b=this._actions,c=b[b.length-1],d=a._cacheIndex;c._cacheIndex=d;b[d]=c;b.pop();a._cacheIndex=null;b=a._clip.uuid;
c=this._actionsByClip;d=c[b];var e=d.knownActions,f=e[e.length-1],g=a._byClipCacheIndex;f._byClipCacheIndex=g;e[g]=f;e.pop();a._byClipCacheIndex=null;delete d.actionByRoot[(a._localRoot||this._root).uuid];0===e.length&&delete c[b];this._removeInactiveBindingsForAction(a)},_removeInactiveBindingsForAction:function(a){a=a._propertyBindings;for(var b=0,c=a.length;b!==c;++b){var d=a[b];0===--d.referenceCount&&this._removeInactiveBinding(d)}},_lendAction:function(a){var b=this._actions,c=a._cacheIndex,
d=this._nActiveActions++,e=b[d];a._cacheIndex=d;b[d]=a;e._cacheIndex=c;b[c]=e},_takeBackAction:function(a){var b=this._actions,c=a._cacheIndex,d=--this._nActiveActions,e=b[d];a._cacheIndex=d;b[d]=a;e._cacheIndex=c;b[c]=e},_addInactiveBinding:function(a,b,c){var d=this._bindingsByRootAndName,e=d[b],f=this._bindings;void 0===e&&(e={},d[b]=e);e[c]=a;a._cacheIndex=f.length;f.push(a)},_removeInactiveBinding:function(a){var b=this._bindings,c=a.binding,d=c.rootNode.uuid;c=c.path;var e=this._bindingsByRootAndName,
f=e[d],g=b[b.length-1];a=a._cacheIndex;g._cacheIndex=a;b[a]=g;b.pop();delete f[c];0===Object.keys(f).length&&delete e[d]},_lendBinding:function(a){var b=this._bindings,c=a._cacheIndex,d=this._nActiveBindings++,e=b[d];a._cacheIndex=d;b[d]=a;e._cacheIndex=c;b[c]=e},_takeBackBinding:function(a){var b=this._bindings,c=a._cacheIndex,d=--this._nActiveBindings,e=b[d];a._cacheIndex=d;b[d]=a;e._cacheIndex=c;b[c]=e},_lendControlInterpolant:function(){var a=this._controlInterpolants,b=this._nActiveControlInterpolants++,
c=a[b];void 0===c&&(c=new ke(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),c.__cacheIndex=b,a[b]=c);return c},_takeBackControlInterpolant:function(a){var b=this._controlInterpolants,c=a.__cacheIndex,d=--this._nActiveControlInterpolants,e=b[d];a.__cacheIndex=d;b[d]=a;e.__cacheIndex=c;b[c]=e},_controlInterpolantsResultBuffer:new Float32Array(1),clipAction:function(a,b){var c=b||this._root,d=c.uuid;c="string"===typeof a?Ma.findByName(c,a):a;a=null!==c?c.uuid:a;var e=
this._actionsByClip[a],f=null;if(void 0!==e){f=e.actionByRoot[d];if(void 0!==f)return f;f=e.knownActions[0];null===c&&(c=f._clip)}if(null===c)return null;b=new di(this,c,b);this._bindAction(b,f);this._addInactiveAction(b,a,d);return b},existingAction:function(a,b){var c=b||this._root;b=c.uuid;c="string"===typeof a?Ma.findByName(c,a):a;a=this._actionsByClip[c?c.uuid:a];return void 0!==a?a.actionByRoot[b]||null:null},stopAllAction:function(){for(var a=this._actions,b=this._nActiveActions,c=this._bindings,
d=this._nActiveBindings,e=this._nActiveBindings=this._nActiveActions=0;e!==b;++e)a[e].reset();for(e=0;e!==d;++e)c[e].useCount=0;return this},update:function(a){a*=this.timeScale;for(var b=this._actions,c=this._nActiveActions,d=this.time+=a,e=Math.sign(a),f=this._accuIndex^=1,g=0;g!==c;++g)b[g]._update(d,a,e,f);a=this._bindings;b=this._nActiveBindings;for(g=0;g!==b;++g)a[g].apply(f);return this},setTime:function(a){for(var b=this.time=0;b<this._actions.length;b++)this._actions[b].time=0;return this.update(a)},
getRoot:function(){return this._root},uncacheClip:function(a){var b=this._actions;a=a.uuid;var c=this._actionsByClip,d=c[a];if(void 0!==d){d=d.knownActions;for(var e=0,f=d.length;e!==f;++e){var g=d[e];this._deactivateAction(g);var h=g._cacheIndex,k=b[b.length-1];g._cacheIndex=null;g._byClipCacheIndex=null;k._cacheIndex=h;b[h]=k;b.pop();this._removeInactiveBindingsForAction(g)}delete c[a]}},uncacheRoot:function(a){a=a.uuid;var b=this._actionsByClip;for(d in b){var c=b[d].actionByRoot[a];void 0!==c&&
(this._deactivateAction(c),this._removeInactiveAction(c))}var d=this._bindingsByRootAndName[a];if(void 0!==d)for(var e in d)a=d[e],a.restoreOriginalState(),this._removeInactiveBinding(a)},uncacheAction:function(a,b){a=this.existingAction(a,b);null!==a&&(this._deactivateAction(a),this._removeInactiveAction(a))}});pf.prototype.clone=function(){return new pf(void 0===this.value.clone?this.value:this.value.clone())};Gg.prototype=Object.assign(Object.create(pb.prototype),{constructor:Gg,isInstancedInterleavedBuffer:!0,
copy:function(a){pb.prototype.copy.call(this,a);this.meshPerAttribute=a.meshPerAttribute;return this}});Object.assign(ei.prototype,{linePrecision:1,set:function(a,b){this.ray.set(a,b)},setFromCamera:function(a,b){b&&b.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(b.matrixWorld),this.ray.direction.set(a.x,a.y,.5).unproject(b).sub(this.ray.origin).normalize(),this.camera=b):b&&b.isOrthographicCamera?(this.ray.origin.set(a.x,a.y,(b.near+b.far)/(b.near-b.far)).unproject(b),this.ray.direction.set(0,
0,-1).transformDirection(b.matrixWorld),this.camera=b):console.error("THREE.Raycaster: Unsupported camera type.")},intersectObject:function(a,b,c){c=c||[];Hg(a,this,c,b);c.sort(fi);return c},intersectObjects:function(a,b,c){c=c||[];if(!1===Array.isArray(a))return console.warn("THREE.Raycaster.intersectObjects: objects is not an Array."),c;for(var d=0,e=a.length;d<e;d++)Hg(a[d],this,c,b);c.sort(fi);return c}});Object.assign(gi.prototype,{set:function(a,b,c){this.radius=a;this.phi=b;this.theta=c;return this},
clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.radius=a.radius;this.phi=a.phi;this.theta=a.theta;return this},makeSafe:function(){this.phi=Math.max(1E-6,Math.min(Math.PI-1E-6,this.phi));return this},setFromVector3:function(a){return this.setFromCartesianCoords(a.x,a.y,a.z)},setFromCartesianCoords:function(a,b,c){this.radius=Math.sqrt(a*a+b*b+c*c);0===this.radius?this.phi=this.theta=0:(this.theta=Math.atan2(a,c),this.phi=Math.acos(P.clamp(b/this.radius,-1,1)));return this}});
Object.assign(hi.prototype,{set:function(a,b,c){this.radius=a;this.theta=b;this.y=c;return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.radius=a.radius;this.theta=a.theta;this.y=a.y;return this},setFromVector3:function(a){return this.setFromCartesianCoords(a.x,a.y,a.z)},setFromCartesianCoords:function(a,b,c){this.radius=Math.sqrt(a*a+c*c);this.theta=Math.atan2(a,c);this.y=b;return this}});var Ji=new B;Object.assign(Ig.prototype,{set:function(a,b){this.min.copy(a);
this.max.copy(b);return this},setFromPoints:function(a){this.makeEmpty();for(var b=0,c=a.length;b<c;b++)this.expandByPoint(a[b]);return this},setFromCenterAndSize:function(a,b){b=Ji.copy(b).multiplyScalar(.5);this.min.copy(a).sub(b);this.max.copy(a).add(b);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.min.copy(a.min);this.max.copy(a.max);return this},makeEmpty:function(){this.min.x=this.min.y=Infinity;this.max.x=this.max.y=-Infinity;return this},isEmpty:function(){return this.max.x<
this.min.x||this.max.y<this.min.y},getCenter:function(a){void 0===a&&(console.warn("THREE.Box2: .getCenter() target is now required"),a=new B);return this.isEmpty()?a.set(0,0):a.addVectors(this.min,this.max).multiplyScalar(.5)},getSize:function(a){void 0===a&&(console.warn("THREE.Box2: .getSize() target is now required"),a=new B);return this.isEmpty()?a.set(0,0):a.subVectors(this.max,this.min)},expandByPoint:function(a){this.min.min(a);this.max.max(a);return this},expandByVector:function(a){this.min.sub(a);
this.max.add(a);return this},expandByScalar:function(a){this.min.addScalar(-a);this.max.addScalar(a);return this},containsPoint:function(a){return a.x<this.min.x||a.x>this.max.x||a.y<this.min.y||a.y>this.max.y?!1:!0},containsBox:function(a){return this.min.x<=a.min.x&&a.max.x<=this.max.x&&this.min.y<=a.min.y&&a.max.y<=this.max.y},getParameter:function(a,b){void 0===b&&(console.warn("THREE.Box2: .getParameter() target is now required"),b=new B);return b.set((a.x-this.min.x)/(this.max.x-this.min.x),
(a.y-this.min.y)/(this.max.y-this.min.y))},intersectsBox:function(a){return a.max.x<this.min.x||a.min.x>this.max.x||a.max.y<this.min.y||a.min.y>this.max.y?!1:!0},clampPoint:function(a,b){void 0===b&&(console.warn("THREE.Box2: .clampPoint() target is now required"),b=new B);return b.copy(a).clamp(this.min,this.max)},distanceToPoint:function(a){return Ji.copy(a).clamp(this.min,this.max).sub(a).length()},intersect:function(a){this.min.max(a.min);this.max.min(a.max);return this},union:function(a){this.min.min(a.min);
this.max.max(a.max);return this},translate:function(a){this.min.add(a);this.max.add(a);return this},equals:function(a){return a.min.equals(this.min)&&a.max.equals(this.max)}});var Ki=new n,Nf=new n;Object.assign(Jg.prototype,{set:function(a,b){this.start.copy(a);this.end.copy(b);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.start.copy(a.start);this.end.copy(a.end);return this},getCenter:function(a){void 0===a&&(console.warn("THREE.Line3: .getCenter() target is now required"),
a=new n);return a.addVectors(this.start,this.end).multiplyScalar(.5)},delta:function(a){void 0===a&&(console.warn("THREE.Line3: .delta() target is now required"),a=new n);return a.subVectors(this.end,this.start)},distanceSq:function(){return this.start.distanceToSquared(this.end)},distance:function(){return this.start.distanceTo(this.end)},at:function(a,b){void 0===b&&(console.warn("THREE.Line3: .at() target is now required"),b=new n);return this.delta(b).multiplyScalar(a).add(this.start)},closestPointToPointParameter:function(a,
b){Ki.subVectors(a,this.start);Nf.subVectors(this.end,this.start);a=Nf.dot(Nf);a=Nf.dot(Ki)/a;b&&(a=P.clamp(a,0,1));return a},closestPointToPoint:function(a,b,c){a=this.closestPointToPointParameter(a,b);void 0===c&&(console.warn("THREE.Line3: .closestPointToPoint() target is now required"),c=new n);return this.delta(c).multiplyScalar(a).add(this.start)},applyMatrix4:function(a){this.start.applyMatrix4(a);this.end.applyMatrix4(a);return this},equals:function(a){return a.start.equals(this.start)&&a.end.equals(this.end)}});
pe.prototype=Object.create(E.prototype);pe.prototype.constructor=pe;pe.prototype.isImmediateRenderObject=!0;var lb=new n,Ab=new n,gh=new Z,Rk=["a","b","c"];qe.prototype=Object.create(X.prototype);qe.prototype.constructor=qe;qe.prototype.update=function(){this.object.updateMatrixWorld(!0);gh.getNormalMatrix(this.object.matrixWorld);var a=this.object.matrixWorld,b=this.geometry.attributes.position,c=this.object.geometry;if(c&&c.isGeometry)for(var d=c.vertices,e=c.faces,f=c=0,g=e.length;f<g;f++)for(var h=
e[f],k=0,m=h.vertexNormals.length;k<m;k++){var n=h.vertexNormals[k];lb.copy(d[h[Rk[k]]]).applyMatrix4(a);Ab.copy(n).applyMatrix3(gh).normalize().multiplyScalar(this.size).add(lb);b.setXYZ(c,lb.x,lb.y,lb.z);c+=1;b.setXYZ(c,Ab.x,Ab.y,Ab.z);c+=1}else if(c&&c.isBufferGeometry)for(d=c.attributes.position,e=c.attributes.normal,k=c=0,m=d.count;k<m;k++)lb.set(d.getX(k),d.getY(k),d.getZ(k)).applyMatrix4(a),Ab.set(e.getX(k),e.getY(k),e.getZ(k)),Ab.applyMatrix3(gh).normalize().multiplyScalar(this.size).add(lb),
b.setXYZ(c,lb.x,lb.y,lb.z),c+=1,b.setXYZ(c,Ab.x,Ab.y,Ab.z),c+=1;b.needsUpdate=!0};var Li=new n;dd.prototype=Object.create(E.prototype);dd.prototype.constructor=dd;dd.prototype.dispose=function(){this.cone.geometry.dispose();this.cone.material.dispose()};dd.prototype.update=function(){this.light.updateMatrixWorld();var a=this.light.distance?this.light.distance:1E3,b=a*Math.tan(this.light.angle);this.cone.scale.set(b,b,a);Li.setFromMatrixPosition(this.light.target.matrixWorld);this.cone.lookAt(Li);
void 0!==this.color?this.cone.material.color.set(this.color):this.cone.material.color.copy(this.light.color)};var Ob=new n,Of=new Q,hh=new Q;ed.prototype=Object.create(X.prototype);ed.prototype.constructor=ed;ed.prototype.updateMatrixWorld=function(a){var b=this.bones,c=this.geometry,d=c.getAttribute("position");hh.getInverse(this.root.matrixWorld);for(var e=0,f=0;e<b.length;e++){var g=b[e];g.parent&&g.parent.isBone&&(Of.multiplyMatrices(hh,g.matrixWorld),Ob.setFromMatrixPosition(Of),d.setXYZ(f,Ob.x,
Ob.y,Ob.z),Of.multiplyMatrices(hh,g.parent.matrixWorld),Ob.setFromMatrixPosition(Of),d.setXYZ(f+1,Ob.x,Ob.y,Ob.z),f+=2)}c.getAttribute("position").needsUpdate=!0;E.prototype.updateMatrixWorld.call(this,a)};fd.prototype=Object.create(ea.prototype);fd.prototype.constructor=fd;fd.prototype.dispose=function(){this.geometry.dispose();this.material.dispose()};fd.prototype.update=function(){void 0!==this.color?this.material.color.set(this.color):this.material.color.copy(this.light.color)};gd.prototype=Object.create(ra.prototype);
gd.prototype.constructor=gd;gd.prototype.update=function(){this.scale.set(.5*this.light.width,.5*this.light.height,1);if(void 0!==this.color)this.material.color.set(this.color),this.children[0].material.color.set(this.color);else{this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity);var a=this.material.color,b=Math.max(a.r,a.g,a.b);1<b&&a.multiplyScalar(1/b);this.children[0].material.color.copy(this.material.color)}};gd.prototype.dispose=function(){this.geometry.dispose();
this.material.dispose();this.children[0].geometry.dispose();this.children[0].material.dispose()};var Sk=new n,Mi=new J,Ni=new J;hd.prototype=Object.create(E.prototype);hd.prototype.constructor=hd;hd.prototype.dispose=function(){this.children[0].geometry.dispose();this.children[0].material.dispose()};hd.prototype.update=function(){var a=this.children[0];if(void 0!==this.color)this.material.color.set(this.color);else{var b=a.geometry.getAttribute("color");Mi.copy(this.light.color);Ni.copy(this.light.groundColor);
for(var c=0,d=b.count;c<d;c++){var e=c<d/2?Mi:Ni;b.setXYZ(c,e.r,e.g,e.b)}b.needsUpdate=!0}a.lookAt(Sk.setFromMatrixPosition(this.light.matrixWorld).negate())};id.prototype=Object.create(ea.prototype);id.prototype.constructor=id;id.prototype.dispose=function(){this.geometry.dispose();this.material.dispose()};id.prototype.onBeforeRender=function(){this.position.copy(this.lightProbe.position);this.scale.set(1,1,1).multiplyScalar(this.size);this.material.uniforms.intensity.value=this.lightProbe.intensity};
qf.prototype=Object.assign(Object.create(X.prototype),{constructor:qf,copy:function(a){X.prototype.copy.call(this,a);this.geometry.copy(a.geometry);this.material.copy(a.material);return this},clone:function(){return(new this.constructor).copy(this)}});rf.prototype=Object.create(X.prototype);rf.prototype.constructor=rf;jd.prototype=Object.create(ra.prototype);jd.prototype.constructor=jd;jd.prototype.update=function(){function a(a,b,d,e){d=(b-a)/d;p.setXYZ(k,0,0,0);m++;for(n=a;n<b;n+=d)q=k+m,p.setXYZ(q,
Math.sin(n)*c,0,Math.cos(n)*c),p.setXYZ(q+1,Math.sin(Math.min(n+d,b))*c,0,Math.cos(Math.min(n+d,b))*c),p.setXYZ(q+2,0,0,0),m+=3;u.addGroup(k,m,e);k+=m;m=0}var b=this.audio,c=this.range,d=this.divisionsInnerAngle,e=this.divisionsOuterAngle,f=P.degToRad(b.panner.coneInnerAngle);b=P.degToRad(b.panner.coneOuterAngle);var g=f/2,h=b/2,k=0,m=0,n,q,u=this.geometry,p=u.attributes.position;u.clearGroups();a(-h,-g,e,0);a(-g,g,d,1);a(g,h,e,0);p.needsUpdate=!0;f===b&&(this.material[0].visible=!1)};jd.prototype.dispose=
function(){this.geometry.dispose();this.material[0].dispose();this.material[1].dispose()};var De=new n,Pf=new n,Oi=new Z;re.prototype=Object.create(X.prototype);re.prototype.constructor=re;re.prototype.update=function(){this.object.updateMatrixWorld(!0);Oi.getNormalMatrix(this.object.matrixWorld);var a=this.object.matrixWorld,b=this.geometry.attributes.position,c=this.object.geometry,d=c.vertices;c=c.faces;for(var e=0,f=0,g=c.length;f<g;f++){var h=c[f],k=h.normal;De.copy(d[h.a]).add(d[h.b]).add(d[h.c]).divideScalar(3).applyMatrix4(a);
Pf.copy(k).applyMatrix3(Oi).normalize().multiplyScalar(this.size).add(De);b.setXYZ(e,De.x,De.y,De.z);e+=1;b.setXYZ(e,Pf.x,Pf.y,Pf.z);e+=1}b.needsUpdate=!0};var Pi=new n,Qf=new n,Qi=new n;kd.prototype=Object.create(E.prototype);kd.prototype.constructor=kd;kd.prototype.dispose=function(){this.lightPlane.geometry.dispose();this.lightPlane.material.dispose();this.targetLine.geometry.dispose();this.targetLine.material.dispose()};kd.prototype.update=function(){Pi.setFromMatrixPosition(this.light.matrixWorld);
Qf.setFromMatrixPosition(this.light.target.matrixWorld);Qi.subVectors(Qf,Pi);this.lightPlane.lookAt(Qf);void 0!==this.color?(this.lightPlane.material.color.set(this.color),this.targetLine.material.color.set(this.color)):(this.lightPlane.material.color.copy(this.light.color),this.targetLine.material.color.copy(this.light.color));this.targetLine.lookAt(Qf);this.targetLine.scale.z=Qi.length()};var sf=new n,ka=new bb;se.prototype=Object.create(X.prototype);se.prototype.constructor=se;se.prototype.update=
function(){var a=this.geometry,b=this.pointMap;ka.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse);na("c",b,a,ka,0,0,-1);na("t",b,a,ka,0,0,1);na("n1",b,a,ka,-1,-1,-1);na("n2",b,a,ka,1,-1,-1);na("n3",b,a,ka,-1,1,-1);na("n4",b,a,ka,1,1,-1);na("f1",b,a,ka,-1,-1,1);na("f2",b,a,ka,1,-1,1);na("f3",b,a,ka,-1,1,1);na("f4",b,a,ka,1,1,1);na("u1",b,a,ka,.7,1.1,-1);na("u2",b,a,ka,-.7,1.1,-1);na("u3",b,a,ka,0,2,-1);na("cf1",b,a,ka,-1,0,1);na("cf2",b,a,ka,1,0,1);na("cf3",b,a,ka,0,-1,1);na("cf4",
b,a,ka,0,1,1);na("cn1",b,a,ka,-1,0,-1);na("cn2",b,a,ka,1,0,-1);na("cn3",b,a,ka,0,-1,-1);na("cn4",b,a,ka,0,1,-1);a.getAttribute("position").needsUpdate=!0};var Rf=new ab;tb.prototype=Object.create(X.prototype);tb.prototype.constructor=tb;tb.prototype.update=function(a){void 0!==a&&console.warn("THREE.BoxHelper: .update() has no longer arguments.");void 0!==this.object&&Rf.setFromObject(this.object);if(!Rf.isEmpty()){a=Rf.min;var b=Rf.max,c=this.geometry.attributes.position,d=c.array;d[0]=b.x;d[1]=
b.y;d[2]=b.z;d[3]=a.x;d[4]=b.y;d[5]=b.z;d[6]=a.x;d[7]=a.y;d[8]=b.z;d[9]=b.x;d[10]=a.y;d[11]=b.z;d[12]=b.x;d[13]=b.y;d[14]=a.z;d[15]=a.x;d[16]=b.y;d[17]=a.z;d[18]=a.x;d[19]=a.y;d[20]=a.z;d[21]=b.x;d[22]=a.y;d[23]=a.z;c.needsUpdate=!0;this.geometry.computeBoundingSphere()}};tb.prototype.setFromObject=function(a){this.object=a;this.update();return this};tb.prototype.copy=function(a){X.prototype.copy.call(this,a);this.object=a.object;return this};tb.prototype.clone=function(){return(new this.constructor).copy(this)};
te.prototype=Object.create(X.prototype);te.prototype.constructor=te;te.prototype.updateMatrixWorld=function(a){var b=this.box;b.isEmpty()||(b.getCenter(this.position),b.getSize(this.scale),this.scale.multiplyScalar(.5),E.prototype.updateMatrixWorld.call(this,a))};ue.prototype=Object.create(ra.prototype);ue.prototype.constructor=ue;ue.prototype.updateMatrixWorld=function(a){var b=-this.plane.constant;1E-8>Math.abs(b)&&(b=1E-8);this.scale.set(.5*this.size,.5*this.size,b);this.children[0].material.side=
0>b?1:0;this.lookAt(this.plane.normal);E.prototype.updateMatrixWorld.call(this,a)};var Ri=new n,tf,Kg;ub.prototype=Object.create(E.prototype);ub.prototype.constructor=ub;ub.prototype.setDirection=function(a){.99999<a.y?this.quaternion.set(0,0,0,1):-.99999>a.y?this.quaternion.set(1,0,0,0):(Ri.set(a.z,0,-a.x).normalize(),this.quaternion.setFromAxisAngle(Ri,Math.acos(a.y)))};ub.prototype.setLength=function(a,b,c){void 0===b&&(b=.2*a);void 0===c&&(c=.2*b);this.line.scale.set(1,Math.max(1E-4,a-b),1);this.line.updateMatrix();
this.cone.scale.set(c,b,c);this.cone.position.y=a;this.cone.updateMatrix()};ub.prototype.setColor=function(a){this.line.material.color.set(a);this.cone.material.color.set(a)};ub.prototype.copy=function(a){E.prototype.copy.call(this,a,!1);this.line.copy(a.line);this.cone.copy(a.cone);return this};ub.prototype.clone=function(){return(new this.constructor).copy(this)};ve.prototype=Object.create(X.prototype);ve.prototype.constructor=ve;C.create=function(a,b){console.log("THREE.Curve.create() has been deprecated");
a.prototype=Object.create(C.prototype);a.prototype.constructor=a;a.prototype.getPoint=b;return a};Object.assign(sb.prototype,{createPointsGeometry:function(a){console.warn("THREE.CurvePath: .createPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");a=this.getPoints(a);return this.createGeometry(a)},createSpacedPointsGeometry:function(a){console.warn("THREE.CurvePath: .createSpacedPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");
a=this.getSpacedPoints(a);return this.createGeometry(a)},createGeometry:function(a){console.warn("THREE.CurvePath: .createGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");for(var b=new G,c=0,d=a.length;c<d;c++){var e=a[c];b.vertices.push(new n(e.x,e.y,e.z||0))}return b}});Object.assign(Wa.prototype,{fromPoints:function(a){console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints().");return this.setFromPoints(a)}});ji.prototype=Object.create(ma.prototype);
ki.prototype=Object.create(ma.prototype);Lg.prototype=Object.create(ma.prototype);Object.assign(Lg.prototype,{initFromArray:function(){console.error("THREE.Spline: .initFromArray() has been removed.")},getControlPointsArray:function(){console.error("THREE.Spline: .getControlPointsArray() has been removed.")},reparametrizeByArcLength:function(){console.error("THREE.Spline: .reparametrizeByArcLength() has been removed.")}});qf.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};
ed.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};Object.assign(V.prototype,{extractUrlBase:function(a){console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.");return eh.extractUrlBase(a)}});V.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};
Object.assign(mf.prototype,{setTexturePath:function(a){console.warn("THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath().");return this.setResourcePath(a)}});Object.assign(Ig.prototype,{center:function(a){console.warn("THREE.Box2: .center() has been renamed to .getCenter().");return this.getCenter(a)},empty:function(){console.warn("THREE.Box2: .empty() has been renamed to .isEmpty().");return this.isEmpty()},isIntersectionBox:function(a){console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().");
return this.intersectsBox(a)},size:function(a){console.warn("THREE.Box2: .size() has been renamed to .getSize().");return this.getSize(a)}});Object.assign(ab.prototype,{center:function(a){console.warn("THREE.Box3: .center() has been renamed to .getCenter().");return this.getCenter(a)},empty:function(){console.warn("THREE.Box3: .empty() has been renamed to .isEmpty().");return this.isEmpty()},isIntersectionBox:function(a){console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().");
return this.intersectsBox(a)},isIntersectionSphere:function(a){console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().");return this.intersectsSphere(a)},size:function(a){console.warn("THREE.Box3: .size() has been renamed to .getSize().");return this.getSize(a)}});Jg.prototype.center=function(a){console.warn("THREE.Line3: .center() has been renamed to .getCenter().");return this.getCenter(a)};Object.assign(P,{random16:function(){console.warn("THREE.Math: .random16() has been deprecated. Use Math.random() instead.");
return Math.random()},nearestPowerOfTwo:function(a){console.warn("THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().");return P.floorPowerOfTwo(a)},nextPowerOfTwo:function(a){console.warn("THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().");return P.ceilPowerOfTwo(a)}});Object.assign(Z.prototype,{flattenToArrayOffset:function(a,b){console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.");return this.toArray(a,b)},multiplyVector3:function(a){console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.");
return a.applyMatrix3(this)},multiplyVector3Array:function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},applyToBuffer:function(a){console.warn("THREE.Matrix3: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.");return this.applyToBufferAttribute(a)},applyToVector3Array:function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")}});Object.assign(Q.prototype,{extractPosition:function(a){console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().");
return this.copyPosition(a)},flattenToArrayOffset:function(a,b){console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.");return this.toArray(a,b)},getPosition:function(){console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.");return(new n).setFromMatrixColumn(this,3)},setRotationFromQuaternion:function(a){console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().");
return this.makeRotationFromQuaternion(a)},multiplyToArray:function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},multiplyVector3:function(a){console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},multiplyVector4:function(a){console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},multiplyVector3Array:function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},
rotateAxis:function(a){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.");a.transformDirection(this)},crossVector:function(a){console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},translate:function(){console.error("THREE.Matrix4: .translate() has been removed.")},rotateX:function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},rotateY:function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},
rotateZ:function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},rotateByAxis:function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},applyToBuffer:function(a){console.warn("THREE.Matrix4: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.");return this.applyToBufferAttribute(a)},applyToVector3Array:function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},makeFrustum:function(a,b,c,d,e,f){console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.");
return this.makePerspective(a,b,d,c,e,f)}});Oa.prototype.isIntersectionLine=function(a){console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().");return this.intersectsLine(a)};wa.prototype.multiplyVector3=function(a){console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.");return a.applyQuaternion(this)};Object.assign(Rb.prototype,{isIntersectionBox:function(a){console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().");
return this.intersectsBox(a)},isIntersectionPlane:function(a){console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().");return this.intersectsPlane(a)},isIntersectionSphere:function(a){console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().");return this.intersectsSphere(a)}});Object.assign(ba.prototype,{area:function(){console.warn("THREE.Triangle: .area() has been renamed to .getArea().");return this.getArea()},barycoordFromPoint:function(a,
b){console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().");return this.getBarycoord(a,b)},midpoint:function(a){console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint().");return this.getMidpoint(a)},normal:function(a){console.warn("THREE.Triangle: .normal() has been renamed to .getNormal().");return this.getNormal(a)},plane:function(a){console.warn("THREE.Triangle: .plane() has been renamed to .getPlane().");return this.getPlane(a)}});Object.assign(ba,
{barycoordFromPoint:function(a,b,c,d,e){console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().");return ba.getBarycoord(a,b,c,d,e)},normal:function(a,b,c,d){console.warn("THREE.Triangle: .normal() has been renamed to .getNormal().");return ba.getNormal(a,b,c,d)}});Object.assign(Ib.prototype,{extractAllPoints:function(a){console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.");return this.extractPoints(a)},extrude:function(a){console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.");
return new dc(this,a)},makeGeometry:function(a){console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.");return new ec(this,a)}});Object.assign(B.prototype,{fromAttribute:function(a,b,c){console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,b,c)},distanceToManhattan:function(a){console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().");return this.manhattanDistanceTo(a)},
lengthManhattan:function(){console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(n.prototype,{setEulerFromRotationMatrix:function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},setEulerFromQuaternion:function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},getPositionFromMatrix:function(a){console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().");
return this.setFromMatrixPosition(a)},getScaleFromMatrix:function(a){console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().");return this.setFromMatrixScale(a)},getColumnFromMatrix:function(a,b){console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().");return this.setFromMatrixColumn(b,a)},applyProjection:function(a){console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.");return this.applyMatrix4(a)},
fromAttribute:function(a,b,c){console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,b,c)},distanceToManhattan:function(a){console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().");return this.manhattanDistanceTo(a)},lengthManhattan:function(){console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(da.prototype,
{fromAttribute:function(a,b,c){console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,b,c)},lengthManhattan:function(){console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(G.prototype,{computeTangents:function(){console.error("THREE.Geometry: .computeTangents() has been removed.")},computeLineDistances:function(){console.error("THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.")}});
Object.assign(E.prototype,{getChildByName:function(a){console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().");return this.getObjectByName(a)},renderDepth:function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},translate:function(a,b){console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.");return this.translateOnAxis(b,a)},getWorldRotation:function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")}});
Object.defineProperties(E.prototype,{eulerOrder:{get:function(){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order.");return this.rotation.order},set:function(a){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order.");this.rotation.order=a}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});
Object.defineProperties(Nd.prototype,{objects:{get:function(){console.warn("THREE.LOD: .objects has been renamed to .levels.");return this.levels}}});Object.defineProperty(Oe.prototype,"useVertexTexture",{get:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")},set:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")}});Od.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Object.defineProperty(C.prototype,
"__arcLengthDivisions",{get:function(){console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.");return this.arcLengthDivisions},set:function(a){console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.");this.arcLengthDivisions=a}});U.prototype.setLens=function(a,b){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup.");void 0!==b&&(this.filmGauge=b);this.setFocalLength(a)};Object.defineProperties(T.prototype,
{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(a){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov.");this.shadow.camera.fov=a}},shadowCameraLeft:{set:function(a){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left.");this.shadow.camera.left=a}},shadowCameraRight:{set:function(a){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right.");this.shadow.camera.right=a}},shadowCameraTop:{set:function(a){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top.");
this.shadow.camera.top=a}},shadowCameraBottom:{set:function(a){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.");this.shadow.camera.bottom=a}},shadowCameraNear:{set:function(a){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near.");this.shadow.camera.near=a}},shadowCameraFar:{set:function(a){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far.");this.shadow.camera.far=a}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},
shadowBias:{set:function(a){console.warn("THREE.Light: .shadowBias is now .shadow.bias.");this.shadow.bias=a}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(a){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.");this.shadow.mapSize.width=a}},shadowMapHeight:{set:function(a){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.");this.shadow.mapSize.height=a}}});Object.defineProperties(N.prototype,
{length:{get:function(){console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead.");return this.array.length}},dynamic:{get:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead.");return 35048===this.usage},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead.");this.setUsage(35048)}}});Object.assign(N.prototype,{setDynamic:function(a){console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead.");
this.setUsage(!0===a?35048:35044);return this},copyIndicesArray:function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},setArray:function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")}});Object.assign(D.prototype,{addIndex:function(a){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().");this.setIndex(a)},addAttribute:function(a,b,c){console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute().");
return b&&b.isBufferAttribute||b&&b.isInterleavedBufferAttribute?"index"===a?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(b),this):this.setAttribute(a,b):(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(a,new N(b,c)))},addDrawCall:function(a,b,c){void 0!==c&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.");console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup().");
this.addGroup(a,b)},clearDrawCalls:function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().");this.clearGroups()},computeTangents:function(){console.warn("THREE.BufferGeometry: .computeTangents() has been removed.")},computeOffsets:function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")},removeAttribute:function(a){console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute().");return this.deleteAttribute(a)}});
Object.defineProperties(D.prototype,{drawcalls:{get:function(){console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups.");return this.groups}},offsets:{get:function(){console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups.");return this.groups}}});Object.defineProperties(pb.prototype,{dynamic:{get:function(){console.warn("THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead.");return 35048===this.usage},set:function(a){console.warn("THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead.");
this.setUsage(a)}}});Object.assign(pb.prototype,{setDynamic:function(a){console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead.");this.setUsage(!0===a?35048:35044);return this},setArray:function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")}});Object.assign(db.prototype,{getArrays:function(){console.error("THREE.ExtrudeBufferGeometry: .getArrays() has been removed.")},
addShapeList:function(){console.error("THREE.ExtrudeBufferGeometry: .addShapeList() has been removed.")},addShape:function(){console.error("THREE.ExtrudeBufferGeometry: .addShape() has been removed.")}});Object.defineProperties(pf.prototype,{dynamic:{set:function(){console.warn("THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.")}},onUpdate:{value:function(){console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.");return this}}});
Object.defineProperties(O.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){console.warn("THREE.Material: .wrapRGB has been removed.");return new J}},shading:{get:function(){console.error("THREE."+
this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(a){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.");this.flatShading=1===a}},stencilMask:{get:function(){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead.");return this.stencilFuncMask},set:function(a){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead.");this.stencilFuncMask=
a}}});Object.defineProperties(Ra.prototype,{metal:{get:function(){console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.");return!1},set:function(){console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead")}}});Object.defineProperties(va.prototype,{derivatives:{get:function(){console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.");return this.extensions.derivatives},
set:function(a){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.");this.extensions.derivatives=a}}});Object.assign(hg.prototype,{clearTarget:function(a,b,c,d){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead.");this.setRenderTarget(a);this.clear(b,c,d)},animate:function(a){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop().");this.setAnimationLoop(a)},getCurrentRenderTarget:function(){console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().");
return this.getRenderTarget()},getMaxAnisotropy:function(){console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().");return this.capabilities.getMaxAnisotropy()},getPrecision:function(){console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.");return this.capabilities.precision},resetGLState:function(){console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset().");return this.state.reset()},supportsFloatTextures:function(){console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' ).");
return this.extensions.get("OES_texture_float")},supportsHalfFloatTextures:function(){console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' ).");return this.extensions.get("OES_texture_half_float")},supportsStandardDerivatives:function(){console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' ).");return this.extensions.get("OES_standard_derivatives")},supportsCompressedTextureS3TC:function(){console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' ).");
return this.extensions.get("WEBGL_compressed_texture_s3tc")},supportsCompressedTexturePVRTC:function(){console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' ).");return this.extensions.get("WEBGL_compressed_texture_pvrtc")},supportsBlendMinMax:function(){console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' ).");return this.extensions.get("EXT_blend_minmax")},supportsVertexTextures:function(){console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.");
return this.capabilities.vertexTextures},supportsInstancedArrays:function(){console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' ).");return this.extensions.get("ANGLE_instanced_arrays")},enableScissorTest:function(a){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().");this.setScissorTest(a)},initMaterial:function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},addPrePlugin:function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},
addPostPlugin:function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},updateShadowMap:function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},setFaceCulling:function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},allocTextureUnit:function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},setTexture:function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},setTexture2D:function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},
setTextureCube:function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},getActiveMipMapLevel:function(){console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel().");return this.getActiveMipmapLevel()}});Object.defineProperties(hg.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(a){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.");this.shadowMap.enabled=a}},shadowMapType:{get:function(){return this.shadowMap.type},
set:function(a){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.");this.shadowMap.type=a}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead.");return this.getContext()}}});
Object.defineProperties(Ih.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},
renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});Object.defineProperties(Bb.prototype,{activeCubeFace:{set:function(){console.warn("THREE.WebGLRenderTargetCube: .activeCubeFace has been removed. It is now the second parameter of WebGLRenderer.setRenderTarget().")}},
activeMipMapLevel:{set:function(){console.warn("THREE.WebGLRenderTargetCube: .activeMipMapLevel has been removed. It is now the third parameter of WebGLRenderer.setRenderTarget().")}}});Object.defineProperties(Ba.prototype,{wrapS:{get:function(){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.");return this.texture.wrapS},set:function(a){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.");this.texture.wrapS=a}},wrapT:{get:function(){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.");
return this.texture.wrapT},set:function(a){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.");this.texture.wrapT=a}},magFilter:{get:function(){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.");return this.texture.magFilter},set:function(a){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.");this.texture.magFilter=a}},minFilter:{get:function(){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.");return this.texture.minFilter},
set:function(a){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.");this.texture.minFilter=a}},anisotropy:{get:function(){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.");return this.texture.anisotropy},set:function(a){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.");this.texture.anisotropy=a}},offset:{get:function(){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset.");return this.texture.offset},
set:function(a){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset.");this.texture.offset=a}},repeat:{get:function(){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat.");return this.texture.repeat},set:function(a){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat.");this.texture.repeat=a}},format:{get:function(){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format.");return this.texture.format},set:function(a){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format.");
this.texture.format=a}},type:{get:function(){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type.");return this.texture.type},set:function(a){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type.");this.texture.type=a}},generateMipmaps:{get:function(){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.");return this.texture.generateMipmaps},set:function(a){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.");
this.texture.generateMipmaps=a}}});Object.defineProperties(gg.prototype,{standing:{set:function(){console.warn("THREE.WebVRManager: .standing has been removed.")}},userHeight:{set:function(){console.warn("THREE.WebVRManager: .userHeight has been removed.")}}});Object.defineProperties(cd.prototype,{load:{value:function(a){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");var b=this;(new nf).load(a,function(a){b.setBuffer(a)});return this}},startTime:{set:function(){console.warn("THREE.Audio: .startTime is now .play( delay ).")}}});
Dg.prototype.getData=function(){console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData().");return this.getFrequencyData()};Bc.prototype.updateCubeMap=function(a,b){console.warn("THREE.CubeCamera: .updateCubeMap() is now .update().");return this.update(a,b)};Jb.crossOrigin=void 0;Jb.loadTexture=function(a,b,c,d){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");var e=new Ze;e.setCrossOrigin(this.crossOrigin);a=e.load(a,c,void 0,d);
b&&(a.mapping=b);return a};Jb.loadTextureCube=function(a,b,c,d){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");var e=new Ye;e.setCrossOrigin(this.crossOrigin);a=e.load(a,c,void 0,d);b&&(a.mapping=b);return a};Jb.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Jb.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};
"undefined"!==typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:"110"}}));k.ACESFilmicToneMapping=5;k.AddEquation=100;k.AddOperation=2;k.AdditiveBlending=2;k.AlphaFormat=1021;k.AlwaysDepth=1;k.AlwaysStencilFunc=519;k.AmbientLight=ff;k.AmbientLightProbe=yg;k.AnimationClip=Ma;k.AnimationLoader=pg;k.AnimationMixer=Fg;k.AnimationObjectGroup=ci;k.AnimationUtils=ta;k.ArcCurve=bd;k.ArrayCamera=Jd;k.ArrowHelper=ub;k.Audio=cd;k.AudioAnalyser=Dg;k.AudioContext=
Bg;k.AudioListener=Ag;k.AudioLoader=nf;k.AxesHelper=ve;k.AxisHelper=function(a){console.warn("THREE.AxisHelper has been renamed to THREE.AxesHelper.");return new ve(a)};k.BackSide=1;k.BasicDepthPacking=3200;k.BasicShadowMap=0;k.BinaryTextureLoader=function(a){console.warn("THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader.");return new Xe(a)};k.Bone=ig;k.BooleanKeyframeTrack=Te;k.BoundingBoxHelper=function(a,b){console.warn("THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead.");
return new tb(a,b)};k.Box2=Ig;k.Box3=ab;k.Box3Helper=te;k.BoxBufferGeometry=Fd;k.BoxGeometry=Zg;k.BoxHelper=tb;k.BufferAttribute=N;k.BufferGeometry=D;k.BufferGeometryLoader=lf;k.ByteType=1010;k.Cache=sc;k.Camera=bb;k.CameraHelper=se;k.CanvasRenderer=function(){console.error("THREE.CanvasRenderer has been removed")};k.CanvasTexture=Pd;k.CatmullRomCurve3=ma;k.CineonToneMapping=4;k.CircleBufferGeometry=Xc;k.CircleGeometry=je;k.ClampToEdgeWrapping=1001;k.Clock=zg;k.ClosedSplineCurve3=ji;k.Color=J;k.ColorKeyframeTrack=
Ue;k.CompressedTexture=Kc;k.CompressedTextureLoader=qg;k.ConeBufferGeometry=ie;k.ConeGeometry=he;k.CubeCamera=Bc;k.CubeGeometry=Zg;k.CubeReflectionMapping=301;k.CubeRefractionMapping=302;k.CubeTexture=nb;k.CubeTextureLoader=Ye;k.CubeUVReflectionMapping=306;k.CubeUVRefractionMapping=307;k.CubicBezierCurve=Sa;k.CubicBezierCurve3=fb;k.CubicInterpolant=Re;k.CullFaceBack=1;k.CullFaceFront=2;k.CullFaceFrontBack=3;k.CullFaceNone=0;k.Curve=C;k.CurvePath=sb;k.CustomBlending=5;k.CylinderBufferGeometry=rb;k.CylinderGeometry=
gc;k.Cylindrical=hi;k.DataTexture=Yb;k.DataTexture2DArray=Cc;k.DataTexture3D=Dc;k.DataTextureLoader=Xe;k.DecrementStencilOp=7683;k.DecrementWrapStencilOp=34056;k.DefaultLoadingManager=Zh;k.DepthFormat=1026;k.DepthStencilFormat=1027;k.DepthTexture=Qd;k.DirectionalLight=ef;k.DirectionalLightHelper=kd;k.DirectionalLightShadow=df;k.DiscreteInterpolant=Se;k.DodecahedronBufferGeometry=Pc;k.DodecahedronGeometry=Wd;k.DoubleSide=2;k.DstAlphaFactor=206;k.DstColorFactor=208;k.DynamicBufferAttribute=function(a,
b){console.warn("THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.");return(new N(a,b)).setDynamic(!0)};k.DynamicCopyUsage=35050;k.DynamicDrawUsage=35048;k.DynamicReadUsage=35049;k.EdgesGeometry=Wc;k.EdgesHelper=function(a,b){console.warn("THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead.");return new X(new Wc(a.geometry),new R({color:void 0!==b?b:16777215}))};k.EllipseCurve=Ja;k.EqualDepth=4;k.EqualStencilFunc=514;k.EquirectangularReflectionMapping=
303;k.EquirectangularRefractionMapping=304;k.Euler=Pb;k.EventDispatcher=Aa;k.ExtrudeBufferGeometry=db;k.ExtrudeGeometry=dc;k.Face3=xc;k.Face4=function(a,b,c,d,e,f,g){console.warn("THREE.Face4 has been removed. A THREE.Face3 will be created instead.");return new xc(a,b,c,e,f,g)};k.FaceColors=1;k.FaceNormalsHelper=re;k.FileLoader=Na;k.FlatShading=1;k.Float32Attribute=function(a,b){console.warn("THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.");return new A(a,
b)};k.Float32BufferAttribute=A;k.Float64Attribute=function(a,b){console.warn("THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.");return new Bd(a,b)};k.Float64BufferAttribute=Bd;k.FloatType=1015;k.Fog=Me;k.FogExp2=Le;k.Font=vg;k.FontLoader=wg;k.FrontFaceDirectionCCW=1;k.FrontFaceDirectionCW=0;k.FrontSide=0;k.Frustum=Dd;k.GammaEncoding=3007;k.Geometry=G;k.GeometryUtils={merge:function(a,b,c){console.warn("THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.");
if(b.isMesh){b.matrixAutoUpdate&&b.updateMatrix();var d=b.matrix;b=b.geometry}a.merge(b,d,c)},center:function(a){console.warn("THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.");return a.center()}};k.GreaterDepth=6;k.GreaterEqualDepth=5;k.GreaterEqualStencilFunc=518;k.GreaterStencilFunc=516;k.GridHelper=qf;k.Group=Gc;k.HalfFloatType=1016;k.HemisphereLight=$e;k.HemisphereLightHelper=hd;k.HemisphereLightProbe=xg;k.IcosahedronBufferGeometry=Oc;k.IcosahedronGeometry=
Vd;k.ImageBitmapLoader=tg;k.ImageLoader=ad;k.ImageUtils=Jb;k.ImmediateRenderObject=pe;k.IncrementStencilOp=7682;k.IncrementWrapStencilOp=34055;k.InstancedBufferAttribute=kf;k.InstancedBufferGeometry=jf;k.InstancedInterleavedBuffer=Gg;k.InstancedMesh=Pe;k.Int16Attribute=function(a,b){console.warn("THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.");return new zd(a,b)};k.Int16BufferAttribute=zd;k.Int32Attribute=function(a,b){console.warn("THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.");
return new Ad(a,b)};k.Int32BufferAttribute=Ad;k.Int8Attribute=function(a,b){console.warn("THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.");return new wd(a,b)};k.Int8BufferAttribute=wd;k.IntType=1013;k.InterleavedBuffer=pb;k.InterleavedBufferAttribute=Kd;k.Interpolant=Ia;k.InterpolateDiscrete=2300;k.InterpolateLinear=2301;k.InterpolateSmooth=2302;k.InvertStencilOp=5386;k.JSONLoader=function(){console.error("THREE.JSONLoader has been removed.")};k.KeepStencilOp=7680;
k.KeyframeTrack=sa;k.LOD=Nd;k.LatheBufferGeometry=Vc;k.LatheGeometry=ge;k.Layers=Tf;k.LensFlare=function(){console.error("THREE.LensFlare has been moved to /examples/js/objects/Lensflare.js")};k.LessDepth=2;k.LessEqualDepth=3;k.LessEqualStencilFunc=515;k.LessStencilFunc=513;k.Light=T;k.LightProbe=Xa;k.LightProbeHelper=id;k.LightShadow=hb;k.Line=ra;k.Line3=Jg;k.LineBasicMaterial=R;k.LineCurve=Da;k.LineCurve3=Ta;k.LineDashedMaterial=nc;k.LineLoop=Qe;k.LinePieces=1;k.LineSegments=X;k.LineStrip=0;k.LinearEncoding=
3E3;k.LinearFilter=1006;k.LinearInterpolant=ke;k.LinearMipMapLinearFilter=1008;k.LinearMipMapNearestFilter=1007;k.LinearMipmapLinearFilter=1008;k.LinearMipmapNearestFilter=1007;k.LinearToneMapping=1;k.Loader=V;k.LoaderUtils=eh;k.LoadingManager=og;k.LogLuvEncoding=3003;k.LoopOnce=2200;k.LoopPingPong=2202;k.LoopRepeat=2201;k.LuminanceAlphaFormat=1025;k.LuminanceFormat=1024;k.MOUSE={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2};k.Material=O;k.MaterialLoader=hf;k.Math=P;k.Matrix3=Z;k.Matrix4=Q;k.MaxEquation=
104;k.Mesh=ea;k.MeshBasicMaterial=Ga;k.MeshDepthMaterial=Db;k.MeshDistanceMaterial=Eb;k.MeshFaceMaterial=function(a){console.warn("THREE.MeshFaceMaterial has been removed. Use an Array instead.");return a};k.MeshLambertMaterial=lc;k.MeshMatcapMaterial=mc;k.MeshNormalMaterial=kc;k.MeshPhongMaterial=Ra;k.MeshPhysicalMaterial=ic;k.MeshStandardMaterial=eb;k.MeshToonMaterial=jc;k.MinEquation=103;k.MirroredRepeatWrapping=1002;k.MixOperation=1;k.MultiMaterial=function(a){void 0===a&&(a=[]);console.warn("THREE.MultiMaterial has been removed. Use an Array instead.");
a.isMultiMaterial=!0;a.materials=a;a.clone=function(){return a.slice()};return a};k.MultiplyBlending=4;k.MultiplyOperation=0;k.NearestFilter=1003;k.NearestMipMapLinearFilter=1005;k.NearestMipMapNearestFilter=1004;k.NearestMipmapLinearFilter=1005;k.NearestMipmapNearestFilter=1004;k.NeverDepth=0;k.NeverStencilFunc=512;k.NoBlending=0;k.NoColors=0;k.NoToneMapping=0;k.NormalBlending=1;k.NotEqualDepth=7;k.NotEqualStencilFunc=517;k.NumberKeyframeTrack=Zc;k.Object3D=E;k.ObjectLoader=mf;k.ObjectSpaceNormalMap=
1;k.OctahedronBufferGeometry=ac;k.OctahedronGeometry=Ud;k.OneFactor=201;k.OneMinusDstAlphaFactor=207;k.OneMinusDstColorFactor=209;k.OneMinusSrcAlphaFactor=205;k.OneMinusSrcColorFactor=203;k.OrthographicCamera=oe;k.PCFShadowMap=1;k.PCFSoftShadowMap=2;k.ParametricBufferGeometry=Mc;k.ParametricGeometry=Rd;k.Particle=function(a){console.warn("THREE.Particle has been renamed to THREE.Sprite.");return new Ld(a)};k.ParticleBasicMaterial=function(a){console.warn("THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.");
return new Qa(a)};k.ParticleSystem=function(a,b){console.warn("THREE.ParticleSystem has been renamed to THREE.Points.");return new Jc(a,b)};k.ParticleSystemMaterial=function(a){console.warn("THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.");return new Qa(a)};k.Path=Wa;k.PerspectiveCamera=U;k.Plane=Oa;k.PlaneBufferGeometry=Zb;k.PlaneGeometry=Ed;k.PlaneHelper=ue;k.PointCloud=function(a,b){console.warn("THREE.PointCloud has been renamed to THREE.Points.");return new Jc(a,b)};k.PointCloudMaterial=
function(a){console.warn("THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.");return new Qa(a)};k.PointLight=cf;k.PointLightHelper=fd;k.Points=Jc;k.PointsMaterial=Qa;k.PolarGridHelper=rf;k.PolyhedronBufferGeometry=Ea;k.PolyhedronGeometry=Sd;k.PositionalAudio=Cg;k.PositionalAudioHelper=jd;k.PropertyBinding=ya;k.PropertyMixer=Eg;k.QuadraticBezierCurve=Ua;k.QuadraticBezierCurve3=gb;k.Quaternion=wa;k.QuaternionKeyframeTrack=le;k.QuaternionLinearInterpolant=Ve;k.REVISION="110";k.RGBADepthPacking=
3201;k.RGBAFormat=1023;k.RGBA_ASTC_10x10_Format=37819;k.RGBA_ASTC_10x5_Format=37816;k.RGBA_ASTC_10x6_Format=37817;k.RGBA_ASTC_10x8_Format=37818;k.RGBA_ASTC_12x10_Format=37820;k.RGBA_ASTC_12x12_Format=37821;k.RGBA_ASTC_4x4_Format=37808;k.RGBA_ASTC_5x4_Format=37809;k.RGBA_ASTC_5x5_Format=37810;k.RGBA_ASTC_6x5_Format=37811;k.RGBA_ASTC_6x6_Format=37812;k.RGBA_ASTC_8x5_Format=37813;k.RGBA_ASTC_8x6_Format=37814;k.RGBA_ASTC_8x8_Format=37815;k.RGBA_PVRTC_2BPPV1_Format=35843;k.RGBA_PVRTC_4BPPV1_Format=35842;
k.RGBA_S3TC_DXT1_Format=33777;k.RGBA_S3TC_DXT3_Format=33778;k.RGBA_S3TC_DXT5_Format=33779;k.RGBDEncoding=3006;k.RGBEEncoding=3002;k.RGBEFormat=1023;k.RGBFormat=1022;k.RGBM16Encoding=3005;k.RGBM7Encoding=3004;k.RGB_ETC1_Format=36196;k.RGB_PVRTC_2BPPV1_Format=35841;k.RGB_PVRTC_4BPPV1_Format=35840;k.RGB_S3TC_DXT1_Format=33776;k.RawShaderMaterial=Yc;k.Ray=Rb;k.Raycaster=ei;k.RectAreaLight=gf;k.RectAreaLightHelper=gd;k.RedFormat=1028;k.ReinhardToneMapping=2;k.RepeatWrapping=1E3;k.ReplaceStencilOp=7681;
k.ReverseSubtractEquation=102;k.RingBufferGeometry=Uc;k.RingGeometry=fe;k.Scene=vd;k.SceneUtils={createMultiMaterialObject:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")},detach:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")},attach:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")}};k.ShaderChunk=S;k.ShaderLib=cb;k.ShaderMaterial=va;k.ShadowMaterial=hc;k.Shape=
Ib;k.ShapeBufferGeometry=fc;k.ShapeGeometry=ec;k.ShapePath=ug;k.ShapeUtils=qb;k.ShortType=1011;k.Skeleton=Oe;k.SkeletonHelper=ed;k.SkinnedMesh=Od;k.SmoothShading=2;k.Sphere=mb;k.SphereBufferGeometry=Hb;k.SphereGeometry=ee;k.Spherical=gi;k.SphericalHarmonics3=of;k.SphericalReflectionMapping=305;k.Spline=Lg;k.SplineCurve=Va;k.SplineCurve3=ki;k.SpotLight=bf;k.SpotLightHelper=dd;k.SpotLightShadow=af;k.Sprite=Ld;k.SpriteMaterial=Gb;k.SrcAlphaFactor=204;k.SrcAlphaSaturateFactor=210;k.SrcColorFactor=202;
k.StaticCopyUsage=35046;k.StaticDrawUsage=35044;k.StaticReadUsage=35045;k.StereoCamera=ai;k.StreamCopyUsage=35042;k.StreamDrawUsage=35040;k.StreamReadUsage=35041;k.StringKeyframeTrack=We;k.SubtractEquation=101;k.SubtractiveBlending=3;k.TOUCH={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3};k.TangentSpaceNormalMap=0;k.TetrahedronBufferGeometry=Nc;k.TetrahedronGeometry=Td;k.TextBufferGeometry=Tc;k.TextGeometry=de;k.Texture=Y;k.TextureLoader=Ze;k.TorusBufferGeometry=Rc;k.TorusGeometry=Zd;k.TorusKnotBufferGeometry=
Qc;k.TorusKnotGeometry=Yd;k.Triangle=ba;k.TriangleFanDrawMode=2;k.TriangleStripDrawMode=1;k.TrianglesDrawMode=0;k.TubeBufferGeometry=bc;k.TubeGeometry=Xd;k.UVMapping=300;k.Uint16Attribute=function(a,b){console.warn("THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.");return new Sb(a,b)};k.Uint16BufferAttribute=Sb;k.Uint32Attribute=function(a,b){console.warn("THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.");return new Tb(a,
b)};k.Uint32BufferAttribute=Tb;k.Uint8Attribute=function(a,b){console.warn("THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.");return new xd(a,b)};k.Uint8BufferAttribute=xd;k.Uint8ClampedAttribute=function(a,b){console.warn("THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.");return new yd(a,b)};k.Uint8ClampedBufferAttribute=yd;k.Uncharted2ToneMapping=3;k.Uniform=pf;k.UniformsLib=L;k.UniformsUtils=Ck;k.UnsignedByteType=
1009;k.UnsignedInt248Type=1020;k.UnsignedIntType=1014;k.UnsignedShort4444Type=1017;k.UnsignedShort5551Type=1018;k.UnsignedShort565Type=1019;k.UnsignedShortType=1012;k.VSMShadowMap=3;k.Vector2=B;k.Vector3=n;k.Vector4=da;k.VectorKeyframeTrack=$c;k.Vertex=function(a,b,c){console.warn("THREE.Vertex has been removed. Use THREE.Vector3 instead.");return new n(a,b,c)};k.VertexColors=2;k.VertexNormalsHelper=qe;k.VideoTexture=lg;k.WebGLMultisampleRenderTarget=Sf;k.WebGLRenderTarget=Ba;k.WebGLRenderTargetCube=
Bb;k.WebGLRenderer=hg;k.WebGLUtils=Kh;k.WireframeGeometry=Lc;k.WireframeHelper=function(a,b){console.warn("THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead.");return new X(new Lc(a.geometry),new R({color:void 0!==b?b:16777215}))};k.WrapAroundEnding=2402;k.XHRLoader=function(a){console.warn("THREE.XHRLoader has been renamed to THREE.FileLoader.");return new Na(a)};k.ZeroCurvatureEnding=2400;k.ZeroFactor=200;k.ZeroSlopeEnding=2401;k.ZeroStencilOp=0;k.sRGBEncoding=3001;Object.defineProperty(k,
"__esModule",{value:!0})});
",
{"status":false}
],

[
"ModulesList_1.0.0",
"Ly8g0KPQv9GA0LDQstC70LXQvdC40LUg0LzQvtC00YPQu9GP0LzQuCDQstC40LfRg9Cw0LvRjNC90L4KLy8gTWFuYWdlIG1vZHVsZXMgdmlzdWFsbHkKCmZ1bmN0aW9uIE1vZHVsZXNMaXN0KHBhcmVudCkKewogICAgdGhpcy5tb2QgPSBNT0Q7CiAgICB0aGlzLmNyZWF0ZVVJKHBhcmVudCk7CiAgICB0aGlzLnJlZnJlc2goKTsKICAgIHRoaXMudHJhY2tDaGFuZ2VzKCk7CiAgICB0aGlzLnRyYWNrQW5kUmVwb3J0U2VsZWN0aW9uKCk7Cn0KdmFyINCh0L/QuNGB0L7QutCc0L7QtNGD0LvQtdC5ID0gTW9kdWxlc0xpc3Q7CgovKgogKgogKiDQodC+0LfQtNCw0YLRjCDQv9C+0LvRjNC30L7QstCw0YLQtdC70YzRgdC60LjQuSDQuNC90YLQtdGA0YTQtdC50YEKICogQ3JlYXRlIHVzZXIgaW50ZXJmYWNlCiAqCiAqLwpNb2R1bGVzTGlzdC5wcm90b3R5cGUuY3JlYXRlVUkgPSBmdW5jdGlvbihwYXJlbnQpCnsKICAgIHZhciByb290ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CiAgICByb290LmlkID0gIk1vZHVsZXNMaXN0IgogICAgcGFyZW50LmFwcGVuZENoaWxkKHJvb3QpOwogICAgdmFyIGNzcyA9CmAKI01vZHVsZXNMaXN0CnsKICAgIHdpZHRoOiAxMDAlOwogICAgaGVpZ2h0OiAxMDAlOwp9CmA7CiAgICB2YXIgc3R5bGUgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJzdHlsZSIpOwogICAgc3R5bGUuaW5uZXJIVE1MID0gY3NzOwogICAgZG9jdW1lbnQuaGVhZC5hcHBlbmRDaGlsZChzdHlsZSk7CgogICAgCiAgICB0aGlzLmdyaWQgPSAkKCIjTW9kdWxlc0xpc3QiKS53MmdyaWQoeyAKICAgICAgICBuYW1lOiAiTW9kdWxlc0xpc3QiLAogICAgICAgIHNob3c6IHsKICAgICAgICAgICAgbGluZU51bWJlcnM6IHRydWUsCiAgICAgICAgfSwKICAgICAgICBtdWx0aVNlbGVjdDogZmFsc2UsCiAgICAgICAgcmVvcmRlclJvd3M6IHRydWUsCiAgICAgICAgY29sdW1uczogWyAgICAgICAgICAgICAgICAKICAgICAgICAgICAgeyBmaWVsZDogInN0YXR1cyIsIHRleHQ6ICLQmNGB0L/QvtC70L3Rj9GC0YwiLCBzaXplOiAiMTBlbSIsIHNvcnRhYmxlOiB0cnVlLCBlZGl0YWJsZTogeyB0eXBlOiAiY2hlY2tib3giLCBzdHlsZTogInRleHQtYWxpZ246IGNlbnRlciIgfSB9LAogICAgICAgICAgICB7IGZpZWxkOiAibmFtZSIsIHRleHQ6ICLQmNC80Y8iLCBzaXplOiAiMTAwJSIsIHNvcnRhYmxlOiB0cnVlLCBlZGl0YWJsZTogeyB0eXBlOiAidGV4dCIgfSB9LAogICAgICAgIF0KICAgIH0pOwogICAgLy9jb25zb2xlLmxvZyhhKTsKICAgIC8vdGhpcy5ncmlkID0gdzJ1aVsiTW9kdWxlc0xpc3QiXTsKfTsKCi8qCiAqCiAqINCe0LHQvdC+0LLQuNGC0Ywg0YHQv9C40YHQvtC6INC80L7QtNGD0LvQtdC5CiAqIFJlZnJlc2ggbW9kdWxlIGxpc3QKICoKICovCk1vZHVsZXNMaXN0LnByb3RvdHlwZS5yZWZyZXNoID0gZnVuY3Rpb24oKQp7CiAgICB2YXIgcmVjb3JkcyA9IFtdOwogICAgZm9yICh2YXIgaSBpbiB0aGlzLm1vZC5tb2R1bGVzKQogICAgewogICAgICAgIHZhciBtID0gdGhpcy5tb2QubW9kdWxlc1tpXTsKICAgICAgICB2YXIgaWQgPSBtdXJvbS51dWlkKCk7CiAgICAgICAgcmVjb3Jkcy5wdXNoKAogICAgICAgICAgICB7IHJlY2lkOiBpZCwgc3RhdHVzOiBtLnN0YXR1cywgbmFtZTogbS5uYW1lIH0KICAgICAgICApOwogICAgfQogICAgdGhpcy5ncmlkLmNsZWFyKCk7CiAgICB0aGlzLmdyaWQuYWRkKHJlY29yZHMpOwp9OwpNb2R1bGVzTGlzdC5wcm90b3R5cGUu0L7QsdC90L7QstC40YLRjCA9IGZ1bmN0aW9uKCkKewogICAgdGhpcy5yZWZyZXNoKCk7Cn07CgovKgogKgogKiDQn9C10YDQtdCy0L7QtCDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgNCwINC30LDQv9C40YHQuCDRgdC10YLQutC4INCyINC/0L7RgNGP0LTQutC+0LLRi9C5INC90L7QvNC10YAKICogQ29udmVydCBncmlkIHJlY29yZCBpZCBpbnRvIG9yZGVyIG51bWJlcgogKgogKi8KTW9kdWxlc0xpc3QucHJvdG90eXBlLmlkVG9PcmRlciA9IGZ1bmN0aW9uKGlkKQp7CiAgICBmb3IgKHZhciBpIGluIHRoaXMuZ3JpZC5yZWNvcmRzKQogICAgewogICAgICAgIHZhciByID0gdGhpcy5ncmlkLnJlY29yZHNbaV07CiAgICAgICAgaWYgKHIucmVjaWQgPT0gaWQpCiAgICAgICAgewogICAgICAgICAgICByZXR1cm4gaTsKICAgICAgICB9CiAgICB9CiAgICAKICAgIHJldHVybiBudWxsOwp9OwpNb2R1bGVzTGlzdC5wcm90b3R5cGUu0LjQtNC10L3RgtC40YTQuNC60LDRgtC+0YDQktCd0L7QvNC10YAgPSBmdW5jdGlvbijQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgCkKewogICAgcmV0dXJuIHRoaXMuaWRUb09yZGVyKNC40LTQtdC90YLQuNGE0LjQutCw0YLQvtGAKTsKfTsKCi8qCiAqCiAqINCg0LXQsNC60YbQuNGPINC90LAg0LjQt9C80LXQvdC10L3QuNC1INGB0LLQvtC50YHRgtCy0LAgKNC40LzRjywg0YHRgtCw0YLRg9GBKQogKiBSZWFjdGlvbiB0byBwcm9wZXJ0eSBjaGFuZ2UgKG5hbWUsIHN0YXR1cykKICoKICovCk1vZHVsZXNMaXN0LnByb3RvdHlwZS5yZWFjdFRvUHJvcGVydHlDaGFuZ2UgPSBmdW5jdGlvbihldmVudCkKewogICAgdmFyIG1vZHVsZSA9IHRoaXMubW9kLm1vZHVsZXNbZXZlbnQuaW5kZXhdOwogICAgLy8gU3RhdHVzLgogICAgaWYgKGV2ZW50LmNvbHVtbiA9PSAwKQogICAgewogICAgICAgIHZhciBzdGF0dXMgPSBldmVudC52YWx1ZV9uZXc7CiAgICAgICAgbW9kdWxlLnN0YXR1cyA9IHN0YXR1czsKICAgIH0KICAgIC8vIE5hbWUuCiAgICBlbHNlIGlmIChldmVudC5jb2x1bW4gPT0gMSkKICAgIHsKICAgICAgICB2YXIgbmFtZSA9IGV2ZW50LnZhbHVlX25ldzsKICAgICAgICBtb2R1bGUubmFtZSA9IG5hbWU7CiAgICB9Cn07CgovKgogKgogKiDQoNC10LDQutGG0LjRjyDQvdCwINC40LfQvNC10L3QtdC90LjQtSDQvdC+0LzQtdGA0LAKICogUmVhY3Rpb24gdG8gb3JkZXIgY2hhbmdlCiAqCiAqLwpNb2R1bGVzTGlzdC5wcm90b3R5cGUucmVhY3RUb09yZGVyQ2hhbmdlID0gZnVuY3Rpb24oZXZlbnQpCnsKICAgIHZhciBpZFdhcyA9IGV2ZW50LnJlY2lkOwogICAgdmFyIGlkTm93ID0gZXZlbnQubW92ZUFmdGVyOwogICAgLy8gTm90aGluZyBjaGFuZ2VkLgogICAgaWYgKGlkTm93ID09IG51bGwpCiAgICB7CiAgICAgICAgcmV0dXJuOwogICAgfQogICAgdmFyIG9yZGVyV2FzID0gdGhpcy5pZFRvT3JkZXIoaWRXYXMpOwogICAgdmFyIG9yZGVyTm93ID0gbnVsbDsKICAgIGlmIChpZE5vdyAhPSAiYm90dG9tIikKICAgIHsKICAgICAgICBvcmRlck5vdyA9IHRoaXMuaWRUb09yZGVyKGlkTm93KTsKICAgIH0KICAgIHRoaXMubW9kLm1vdmUob3JkZXJXYXMsIG9yZGVyTm93KTsKfTsKCi8qCiAqCiAqINCh0LvQtdC00LjRgtGMINC30LAg0LjQt9C80LXQvdC10L3QuNGP0LzQuCAo0YHRgtCw0YLRg9GB0LAsINC40LzQtdC90LgsINC90L7QvNC10YDQsCkKICogVHJhY2sgY2hhbmdlcyAob2Ygc3RhdHVzLCBuYW1lLCBpZCkKICoKICovCk1vZHVsZXNMaXN0LnByb3RvdHlwZS50cmFja0NoYW5nZXMgPSBmdW5jdGlvbigpCnsKICAgIHZhciBzZWxmID0gdGhpczsKICAgIHRoaXMuZ3JpZC5vbigiY2hhbmdlIiwgZnVuY3Rpb24oZXZlbnQpIHsKICAgICAgICBzZWxmLnJlYWN0VG9Qcm9wZXJ0eUNoYW5nZShldmVudCk7CiAgICB9KTsKICAgIHRoaXMuZ3JpZC5vbigicmVzdG9yZSIsIGZ1bmN0aW9uKGV2ZW50KSB7CiAgICAgICAgc2VsZi5yZWFjdFRvUHJvcGVydHlDaGFuZ2UoZXZlbnQpOwogICAgfSk7CiAgICB0aGlzLmdyaWQub24oInJlb3JkZXJSb3ciLCBmdW5jdGlvbihldmVudCkgewogICAgICAgIHNlbGYucmVhY3RUb09yZGVyQ2hhbmdlKGV2ZW50KTsKICAgIH0pOwp9OwoKLyoKICoKICog0JLRi9Cx0YDQsNGC0Ywg0LzQvtC00YPQu9GMINCyINGB0LXRgtC60LUKICogU2VsZWN0IGEgbW9kdWxlIGluIGdyaWQKICoKICovCk1vZHVsZXNMaXN0LnByb3RvdHlwZS5zZWxlY3QgPSBmdW5jdGlvbihpZCkKewogICAgdmFyIHJlY2lkID0gdGhpcy5ncmlkLnJlY29yZHNbaWRdLnJlY2lkOwogICAgdGhpcy5ncmlkLnNlbGVjdChyZWNpZCk7CiAgICB0aGlzLmdyaWQuc2Nyb2xsSW50b1ZpZXcoaWQsIG51bGwsIHRydWUpOwp9Ck1vZHVsZXNMaXN0LnByb3RvdHlwZS7QstGL0LHRgNCw0YLRjCA9IGZ1bmN0aW9uKNC90L7QvNC10YApCnsKICAgIHRoaXMuc2VsZWN0KNC90L7QvNC10YApOwp9CgovKgogKgogKiDQktGL0LHRgNCw0YLRjCDQv9C+0YHQu9C10LTQvdC40Lkg0LzQvtC00YPQu9GMINCyINGB0LXRgtC60LUKICogU2VsZWN0IHRoZSBsYXN0IG1vZHVsZSBpbiBncmlkCiAqCiAqLwpNb2R1bGVzTGlzdC5wcm90b3R5cGUuc2VsZWN0TGFzdCA9IGZ1bmN0aW9uKCkKewogICAgdmFyIGlkID0gdGhpcy5ncmlkLnJlY29yZHMubGVuZ3RoIC0gMTsKICAgIHRoaXMuc2VsZWN0KGlkKTsKfQpNb2R1bGVzTGlzdC5wcm90b3R5cGUu0LLRi9Cx0YDQsNGC0YzQn9C+0YHQu9C10LTQvdC40LkgPSBmdW5jdGlvbigpCnsKICAgIHRoaXMuc2VsZWN0TGFzdCgpOwp9CgovKgogKgogKiDQndC+0LzQtdGAINCy0YvQsdGA0LDQvdC90L7Qs9C+INGN0LvQtdC80LXQvdGC0LAKICogU2VsZWN0ZWQgaXRlbSBvcmRlcgogKgogKi8KT2JqZWN0LmRlZmluZVByb3BlcnR5KE1vZHVsZXNMaXN0LnByb3RvdHlwZSwgInNlbGVjdGVkT3JkZXIiLCB7CiAgICBnZXQ6IGZ1bmN0aW9uKCkKICAgIHsKICAgICAgICB2YXIgcmVjaWQgPSB0aGlzLmdyaWQuZ2V0U2VsZWN0aW9uKClbMF07CiAgICAgICAgaWYgKHJlY2lkKQogICAgICAgIHsKICAgICAgICAgICAgcmV0dXJuIHRoaXMuaWRUb09yZGVyKHJlY2lkKTsKICAgICAgICB9CiAgICAgICAgCiAgICAgICAgcmV0dXJuIG51bGw7CiAgICB9Cn0pOwpPYmplY3QuZGVmaW5lUHJvcGVydHkoTW9kdWxlc0xpc3QucHJvdG90eXBlLCAi0LLRi9Cx0YDQsNC90L3Ri9C50J3QvtC80LXRgCIsIHsKICAgIGdldDogZnVuY3Rpb24oKQogICAgewogICAgICAgIHJldHVybiB0aGlzLnNlbGVjdGVkT3JkZXI7CiAgICB9Cn0pOwogCi8qCiAqCiAqINCh0LvQtdC00LjRgtGMINC30LAg0LLRi9Cx0L7RgNC+0Lwg0Lgg0YHQvtC+0LHRidCw0YLRjCDQviDQvdGR0LwKICogVHJhY2sgc2VsZWN0aW9uIGFuZCByZXBvcnQgaXQKICoKICovCk1vZHVsZXNMaXN0LnByb3RvdHlwZS50cmFja0FuZFJlcG9ydFNlbGVjdGlvbiA9IGZ1bmN0aW9uKCkKewogICAgdGhpcy5zZWxlY3Rpb25DaGFuZ2VkID0gbmV3IFJlcG9ydGVyKCk7CiAgICBPYmplY3QuZGVmaW5lUHJvcGVydHkodGhpcywgItC40LfQvNC10L3QuNC70LjQktGL0LHQvtGAIiwgewogICAgICAgIGdldDogZnVuY3Rpb24oKQogICAgICAgIHsKICAgICAgICAgICAgcmV0dXJuIHRoaXMuc2VsZWN0aW9uQ2hhbmdlZDsKICAgICAgICB9CiAgICB9KTsKICAgIAogICAgdmFyIHNlbGYgPSB0aGlzOwogICAgZnVuY3Rpb24gcmVwb3J0KGV2ZW50KQogICAgewogICAgICAgIGV2ZW50Lm9uQ29tcGxldGUgPSBmdW5jdGlvbigpIHsKICAgICAgICAgICAgc2VsZi5zZWxlY3Rpb25DaGFuZ2VkLnJlcG9ydCgpOwogICAgICAgIH07CiAgICB9CiAgICB0aGlzLmdyaWQub24oInNlbGVjdCIsIHJlcG9ydCk7CiAgICB0aGlzLmdyaWQub24oInVuc2VsZWN0IiwgcmVwb3J0KTsKfTs=",
{"status":true}
],

[
"Среда_1.2.0",
"function Среда()
{
    this.установитьОбласти();
    this.установитьРедактор();
    this.установитьМодули();
    this.следитьЗаВыбором();
    this.настроитьСохранениеСкачивание();
}

Среда.prototype.установитьОбласти = function()
{
    var html =
`
<div id="среда-область-левая">
    <div id="редактор" hidden></div>
</div>
<div id="среда-область-левая-заглушка">Выберите модуль</div>

<div id="среда-область-центральная-верх">
</div>

<div id="среда-область-центральная-низ">
    <a id="среда-сохранить" class="uk-icon-button uk-margin-top" uk-icon="database" uk-tooltip="title: Сохранить изменения в этом браузере; delay: 500"></a>
    <a id="среда-скачать" class="uk-icon-button uk-margin-top" uk-icon="download" uk-tooltip="title: Скачать файл с сохранёнными изменениями; delay: 500""></a>
    <a id="среда-добавить" class="uk-icon-button uk-margin-large-top" uk-icon="plus" uk-tooltip="title: Добавить новый модуль; delay: 500""></a>
    <a id="среда-удалить" class="uk-icon-button uk-margin-top" uk-icon="minus" uk-tooltip="title: Удалить выбранный модуль; delay: 500""></a>
</div>

<div id="среда-область-правая-верх">
    <iframe id="встройка">
        <p>ОШИБКА Ваш веб-браузер не поддерживает iframe</p>
        <p>ERROR Your web browser does not support iframes</p>
    </iframe>
</div>

<div id="среда-область-правая-низ">
</div>
`;
    var css =
`
#среда-область-левая
{
    position: fixed;
    top: 0;
    bottom: 0;
    left: 0;
    width: calc(50% - 2em);
}

#среда-область-левая-заглушка
{
    position: fixed;
    top: 50%;
    left: 25%;
    transform: translateX(-25%) translateY(-50%);
    background-color: white;
}

#редактор
{
    height: 100%;
    top: 0;
    bottom: 0;
    left: 0;
    right: 0;
}

#среда-область-центральная-верх
{
    position: fixed;
    top: 0;
    height: 50%;
    left: 50%;
    width: 4em;
    transform: translateX(-2em);
    text-align: center;
    border-left: 1px solid #ddd;
    border-right: 1px solid #ddd;
    padding-top: 1em;
}

#среда-область-центральная-низ
{
    position: fixed;
    bottom: 0;
    height: 50%;
    left: 50%;
    width: 4em;
    transform: translateX(-2em);
    text-align: center;
    border-left: 1px solid #ddd;
    border-right: 1px solid #ddd;
    padding-top: 1em;
}

#среда-область-правая-верх
{
    position: fixed;
    top: 0;
    height: 50%;
    right: 0;
    width: calc(50% - 2em - 1px);
}

#среда-область-правая-низ
{
    position: fixed;
    bottom: 0;
    height: 50%;
    right: 0;
    width: calc(50% - 2em - 1px);
}

#встройка
{
    border: 0 none;
    width: calc(50% - 2em - 1px);
    height: 50%;
    position: fixed;
}
`;

    добавитьЭкран("среда", html, css);
};

Среда.prototype.установитьРедактор = function()
{
    муром.редактор = window.ace.edit("редактор");
    муром.редактор.session.setMode("ace/mode/javascript");

    this.редактор = document.getElementById("редактор");
    this.заглушкаРедактора = document.getElementById("среда-область-левая-заглушка");
};

Среда.prototype.сделатьРедакторВидимым = function(состояние)
{
    this.редактор.hidden = !состояние;
    this.заглушкаРедактора.hidden = !this.редактор.hidden;
};

Среда.prototype.добавитьНовыйМодуль = function()
{
    var номер = Math.floor(Math.random() * Math.floor(1000));
    var имя = "модуль-" + номер;
    МОД.добавить(имя, "");
    
    this.список.обновить();
    var позиция = МОД.модули.length - 1;
    this.список.выбрать(позиция);
};

Среда.prototype.подтвердитьУдалениеМодуля = function(отклик)
{
    var номер = this.список.выбранныйНомер;
    if (номер)
    {
        w2confirm({
            title: "Подтверждение",
            msg: "Удалить выбранный модуль?",
            yes_text: "Удалить",
            no_text: "Отмена",
            yes_callBack: отклик,
        });
    }
    else
    {
        w2alert("Выберите модуль", "Пояснение");
    }
};

Среда.prototype.удалитьМодуль = function()
{
    var номер = this.список.выбранныйНомер;
    МОД.удалить(номер);
    this.список.обновить();
    this.список.выбрать(номер - 1);
};

Среда.prototype.установитьМодули = function()
{
    var область = document.getElementById("среда-область-правая-низ");
    this.список = new СписокМодулей(область);

    var self = this;
    
    this.добавить = document.getElementById("среда-добавить");
    this.добавить.onclick = function() {
        self.добавитьНовыйМодуль();
    };
    
    this.удалить = document.getElementById("среда-удалить");
    this.удалить.onclick = function() {
        self.подтвердитьУдалениеМодуля(function() {
            self.удалитьМодуль();
        });
    };
};

Среда.prototype.отобразитьКодВыбранногоМодуля = function()
{
    var номер = this.список.выбранныйНомер;
    this.сделатьРедакторВидимым(номер != null);
    if (номер)
    {
        var код64 = МОД.модули[номер].code64;
        муром.редактор.session.setValue(муром.atob(код64));
    }
};

Среда.prototype.следитьЗаВыбором = function()
{
    var self = this;
    когда(this.список.изменилиВыбор, function() {
        self.отобразитьКодВыбранногоМодуля();
    });
};

Среда.prototype.сохранитьВыбранныйМодуль = function()
{
    var номер = this.список.выбранныйНомер;
    if (номер)
    {
        var код = муром.редактор.session.getValue();
        МОД.модули[номер].code64 = муром.btoa(код);
    }
};

Среда.prototype.сохранитьВсё = function()
{
    МОД.сохранить();
};

Среда.prototype.скачатьФайл = function()
{
    // How to create a file in memory for user to download, but not through server?
    // https://stackoverflow.com/a/18197341
    var содержимое = муром.файл.начало;
    
    // Темы.
    содержимое += муром.файл.темыНачало;
    содержимое += муром.файл.темыКонец;
    
    // Модули.
    содержимое += муром.файл.модулиНачало;
    содержимое += МОД.сериализованное;
    содержимое += муром.файл.модулиКонец;
    
    содержимое += муром.файл.конец;
    содержимое = муром.btoa(содержимое);

    var ссыль = document.createElement("a");
    ссыль.setAttribute("href", "data:text/html;charset=utf-8;base64," + содержимое);
    var имя = имяФайла();
    ссыль.setAttribute("download", имя);
    ссыль.style.display = "none";
    document.body.appendChild(ссыль);
    ссыль.click();
    document.body.removeChild(ссыль);
};

Среда.prototype.настроитьСохранениеСкачивание = function()
{
    var self = this;
    
    this.сохранить = document.getElementById("среда-сохранить");
    this.сохранить.onclick = function() {
        self.сохранитьВыбранныйМодуль();
        self.сохранитьВсё();
    };
    
    this.скачать = document.getElementById("среда-скачать");
    this.скачать.onclick = function() {
        self.скачатьФайл();
    };
};",
{"status":true}
],

[
"муром.пуск_1.0.0",
"0LrQvtCz0LTQsCjQvNGD0YDQvtC8LtC/0YPRgdC6LCDQv9GD0YHQuik7CgpmdW5jdGlvbiDQv9GD0YHQuigpCnsKICAgIHZhciDQvNC/NjQgPSDQnNCe0JQu0LzQvtC00YPQu9GMKCLQvNGD0YDQvtC8LtC/0L7RgdC70LXQtNC+0LLQsNGC0LXQu9GM0L3QvtGB0YLRjCIpLmNvZGU2NDsKICAgIHZhciDQv9C+0YHQu9C10LTQvtCy0LDRgtC10LvRjNC90L7RgdGC0YwgPSDQvNGD0YDQvtC8LmF0b2Io0LzQvzY0KTsKICAgIAogICAgdmFyINC80LjRgCA9IHsKICAgICAgICAi0L3QsNGB0YLRgNC+0LnQutC4Ijoge30sCiAgICAgICAgItGB0L7QsdGL0YLQuNGPIjoge30sCiAgICAgICAgItGB0L7RgdGC0L7Rj9C90LjQtSI6IHt9LAogICAgfTsKICAgIHZhciDRgdC+0LHRi9GC0LjRj9Cg0LXQsNC60YbQuNC4ID0gbmV3INCh0L7QsdGL0YLQuNGP0KDQtdCw0LrRhtC40LgoKTsKICAgINGB0L7QsdGL0YLQuNGP0KDQtdCw0LrRhtC40Lgu0YDQsNC30L7QsdGA0LDRgtGMKNC80LjRgCwg0L/QvtGB0LvQtdC00L7QstCw0YLQtdC70YzQvdC+0YHRgtGMKTsKICAgINC80LjRgC7RgdC+0YHRgtC+0Y/QvdC40LVbItGB0L7QsdGL0YLQuNGP0KDQtdCw0LrRhtC40LgiXSA9INGB0L7QsdGL0YLQuNGP0KDQtdCw0LrRhtC40Lg7CiAgICAvLyDQndCw0YfQsNGC0YwuCiAgICDQvNC40YAu0YHQvtCx0YvRgtC40Y9bItC90LDRh9Cw0LvQviJdLtGD0LLQtdC00L7QvNC40YLRjCgpOwp9",
{"status":true}
],

[
"муром.реакции_1.0.0",
"// // // //

function ОпределитьРежимПуска(мир)
{
    this.исполнить = function()
    {
        var запрос = window.location.search;
        
        if (запрос.length == 0)
        {
            мир.события["пуск просмотра"].уведомить();
        }
        else if (запрос == "?0")
        {
            мир.события["пуск среды"].уведомить();
        }
        else if (запрос == "?" + encodeURI("🀄"))
        {
            мир.события["пуск редактирования тем"].уведомить();
        }
    };
}

// // // //

function ЗапуститьТемы(мир)
{
    this.исполнить = function()
    {
        var пи64 = МОД.модуль("темы.последовательность").code64;
        var последовательность = муром.atob(пи64);
        var событияРеакции = мир.состояние["событияРеакции"];
        событияРеакции.разобрать(мир, последовательность);

        // Запустить темы.
        мир.события["пуск тем"].уведомить();
    };
}


// // // //

function ЗапуститьИгру(мир)
{
    this.исполнить = function()
    {
        var пи64 = МОД.модуль("игра.последовательность").code64;
        var последовательность = муром.atob(пи64);
        var событияРеакции = мир.состояние["событияРеакции"];
        событияРеакции.разобрать(мир, последовательность);

        // Запустить игру.
        мир.события["пуск игры"].уведомить();
    };
}

// // // //

function НастроитьThreeJS(мир)
{
    this.исполнить = function()
    {
        var сцена = new THREE.Scene();
        сцена.background = new THREE.Color(0x333366);
        var камера = new THREE.PerspectiveCamera(45, 1, 0.1, 1000);
        var отрисовщик = new THREE.WebGLRenderer();
        document.body.appendChild(отрисовщик.domElement);
        добавитьСловарь(мир.состояние, {
            "сцена": сцена,
            "камера": камера,
            "отрисовщик": отрисовщик,
        });
        
        // Поддержка изменения размера окна.
        var self = this;
        window.addEventListener(
            "resize",
            function() { self.изменитьРазмер(); }
        );
        this.изменитьРазмер();
        
        // Непосредственно отрисовка.
        function отрисовать()
        {   
            requestAnimationFrame(отрисовать);
            отрисовщик.render(сцена, камера);
        }
        отрисовать();
    };
    
    this.изменитьРазмер = function()
    {
        var ширина = window.innerWidth;
        var высота = window.innerHeight;
        var камера = мир.состояние["камера"];
        камера.aspect = ширина / высота;
        камера.updateProjectionMatrix();
        мир.состояние["отрисовщик"].setSize(ширина, высота);
    };
}

// // // //

function УстановитьThreeJS(мир)
{
    this.исполнить = function()
    {
        var js = MOD.module("three.min.js_r110").code64;
        загрузитьСкрипт(murom.atob(js));
    };
}

// // // //
/*
function ПодготовитьПросмотр(мир)
{
    this.исполнить = function()
    {
        var css =
`
canvas
{
    background-color: black;
    border: 0 none;
    width: 100%;
    height: 100%;
}
`;
        var вид = document.createElement("style");
        вид.innerHTML = css;
        document.head.appendChild(вид);
    };
}
*/
// // // //

function ПодготовитьСредуДляПросмотра(мир)
{
    this.исполнить = function()
    {
        var область = document.getElementById("среда-область-центральная-верх");
        область.innerHTML =
`
<a id="среда-обновить" class="uk-icon-button" uk-icon="refresh" uk-tooltip="title: Отобразить сохранённый результат; delay: 500"></a>
<a id="среда-просмотреть" class="uk-icon-button uk-margin-top" uk-icon="expand" uk-tooltip="title: Отобразить сохранённый результат во весь экран; delay: 500"></a>
`;

        function отобразитьРезультат()
        {
            var iframe = document.getElementById("встройка");
            iframe.src = имяФайла();
        }
        function отобразитьРезультатВоВесьЭкран()
        {
            window.open(имяФайла(), '_blank');
        }
        
        отобразитьРезультат();
    
        var обновить = document.getElementById("среда-обновить");
        обновить.onclick = отобразитьРезультат;
        var просмотреть = document.getElementById("среда-просмотреть");
        просмотреть.onclick = отобразитьРезультатВоВесьЭкран;
    };
}

// // // //

function УстановитьAceПодсветкуJavaScript(мир)
{
    this.исполнить = function()
    {
        var js = MOD.module("ace.mode-javascript.js_2018-11-21").code64;
        eval(murom.atob(js));
    };
}

// // // //

function УстановитьAce(мир)
{
    this.исполнить = function()
    {
        var js = MOD.module("ace.js_2019-10-17").code64;
        eval(murom.atob(js));
    };
}

// // // //

function УстановитьСреду(мир)
{
    this.исполнить = function()
    {
        мир.состояние["среда"] = new Среда();
    };
}

// // // //

function УстановитьJQueryUIKitW2UI(мир)
{
    this.исполнить = function()
    {
        var js = null;
        var css = null;
        var style = null;
        
        // JQuery.
        js = MOD.module("jquery.min.js_3.4.1").code64;
        eval(murom.atob(js));
        
        // W2UI.
        js = MOD.module("w2ui.min.js_1.5").code64;
        loadScript(murom.atob(js));
        css = MOD.module("w2ui.min.css_1.5").code64;
        style = document.createElement("style");
        style.innerHTML = murom.atob(css);
        document.head.appendChild(style);
        
        // UIKit.
        js = MOD.module("uikit.min.js_3.2.0").code64;
        loadScript(murom.atob(js));
        
        var iconsJS = MOD.module("uikit-icons.min.js_3.2.0").code64;
        loadScript(murom.atob(iconsJS));
        
        css = MOD.module("uikit.min.css_3.2.0").code64;
        style = document.createElement("style");
        style.innerHTML = murom.atob(css);
        document.head.appendChild(style);
    };
}

// // // //

function ЗадатьРазмерШрифтаРедактора22(мир)
{
    this.исполнить = function()
    {
        муром.редактор.setFontSize("22px");
    };
}",
{"status":true}
],

[
"муром.последовательность",
"0L3QsNGH0LDQu9C+CiAgICDRg9GB0YLQsNC90L7QstC40YLRjCBKUXVlcnkgVUlLaXQgVzJVSQogICAg0L7Qv9GA0LXQtNC10LvQuNGC0Ywg0YDQtdC20LjQvCDQv9GD0YHQutCwCtC/0YPRgdC6INGB0YDQtdC00YsKICAgINGD0YHRgtCw0L3QvtCy0LjRgtGMIEFjZQogICAg0YPRgdGC0LDQvdC+0LLQuNGC0YwgQWNlINC/0L7QtNGB0LLQtdGC0LrRgyBKYXZhU2NyaXB0CiAgICDRg9GB0YLQsNC90L7QstC40YLRjCDRgdGA0LXQtNGDCiAgICDQt9Cw0LTQsNGC0Ywg0YDQsNC30LzQtdGAINGI0YDQuNGE0YLQsCDRgNC10LTQsNC60YLQvtGA0LAgMjIKICAgINC/0L7QtNCz0L7RgtC+0LLQuNGC0Ywg0YHRgNC10LTRgyDQtNC70Y8g0L/RgNC+0YHQvNC+0YLRgNCwCtC/0YPRgdC6INC/0YDQvtGB0LzQvtGC0YDQsAogICAg0YPRgdGC0LDQvdC+0LLQuNGC0YwgVGhyZWVKUwogICAg0L3QsNGB0YLRgNC+0LjRgtGMIFRocmVlSlMKICAgINC30LDQv9GD0YHRgtC40YLRjCDQuNCz0YDRgwrQv9GD0YHQuiDRgNC10LTQsNC60YLQuNGA0L7QstCw0L3QuNGPINGC0LXQvAogICAg0LfQsNC/0YPRgdGC0LjRgtGMINGC0LXQvNGL",
{"status":false}
],

[
"Список_1.0.0",
"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",
{"status":true}
],

[
"Набор_1.0.0",
"ZnVuY3Rpb24g0J3QsNCx0L7RgCgpCnsKICAgIHRoaXMu0LfQsNC00LDRgtGMID0gZnVuY3Rpb24o0YHQv9C40YHQvtC6KQogICAgewogICAgICAgIHRoaXMu0YHQv9C40YHQvtC6ID0g0YHQv9C40YHQvtC6OwogICAgICAgIHRoaXMu0LjQt9C80LXQvdC40LvQuNCh0L/QuNGB0L7Qui7Rg9Cy0LXQtNC+0LzQuNGC0YwoKTsKICAgICAgICAvLyDQodCx0YDQsNGB0YvQstCw0LXQvCDQstGL0LHQvtGALCDQtdGB0LvQuCDQv9GA0LXQtNGL0LTRg9GJ0LjQuSDQvdC+0LzQtdGAINGC0LXQv9C10YDRjCDQvtGC0YHRg9GC0YHRgtCy0YPQtdGCLgogICAgICAgIGlmICgKICAgICAgICAgICAgKHRoaXMu0LLRi9Cx0L7RgCAhPSBudWxsKSAmJgogICAgICAgICAgICAodGhpcy7QstGL0LHQvtGAID4g0YHQv9C40YHQvtC6Lmxlbmd0aCAtIDEpCiAgICAgICAgKSB7CiAgICAgICAgICAgIHRoaXMu0LLRi9Cx0YDQsNGC0YwobnVsbCk7CiAgICAgICAgfQogICAgfQogICAgCiAgICB0aGlzLtC+0YfQuNGB0YLQuNGC0YwgPSBmdW5jdGlvbigpCiAgICB7CiAgICAgICAgdGhpcy7RgdC/0LjRgdC+0LogPSBbXTsKICAgICAgICB0aGlzLtC40LfQvNC10L3QuNC70LjQodC/0LjRgdC+0Lou0YPQstC10LTQvtC80LjRgtGMKCk7CiAgICAgICAgdGhpcy7QstGL0LHRgNCw0YLRjChudWxsKTsKICAgIH07CiAgICAKICAgIHRoaXMu0LTQvtCx0LDQstC40YLRjCA9IGZ1bmN0aW9uKNGB0L/QuNGB0L7QuikKICAgIHsKICAgICAgICB0aGlzLtGB0L/QuNGB0L7Qui5wdXNoKC4uLtGB0L/QuNGB0L7Quik7CiAgICAgICAgdGhpcy7QuNC30LzQtdC90LjQu9C40KHQv9C40YHQvtC6LtGD0LLQtdC00L7QvNC40YLRjCgpOwogICAgfTsKICAgIAogICAgdGhpcy7QstGL0LHRgNCw0YLRjCA9IGZ1bmN0aW9uKNC90L7QvNC10YApCiAgICB7CiAgICAgICAgdGhpcy7QstGL0LHQvtGAID0g0L3QvtC80LXRgDsKICAgICAgICB0aGlzLtC40LfQvNC10L3QuNC70LjQktGL0LHQvtGALtGD0LLQtdC00L7QvNC40YLRjCgpOwogICAgfTsKICAgIAogICAgLy8g0JrQvtC90YHRgtGA0YPQutGC0L7RgC4KICAgIHRoaXMu0YHQv9C40YHQvtC6ID0gW107CiAgICB0aGlzLtC40LfQvNC10L3QuNC70LjQodC/0LjRgdC+0LogPSBuZXcg0KPQstC10LTQvtC80LjRgtC10LvRjCgpOwogICAgdGhpcy7QstGL0LHQvtGAID0gbnVsbDsKICAgIHRoaXMu0LjQt9C80LXQvdC40LvQuNCS0YvQsdC+0YAgPSBuZXcg0KPQstC10LTQvtC80LjRgtC10LvRjCgpOwp9",
{"status":true}
],

[
"Раскладка_1.0.0",
"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",
{"status":true}
],

[
"встроенные раскладки",
"function МР() { return [

{
    "имя": "4 крыла",
    "описание": "Раскладка, похожая на крепость",
    "раскладка":
`
kmahjongg-layout-v1.0
......12..1212....1212..12......
......43..4343....4343..43......
......12121212121212121212......
......43434343434343434343......
......12..121212121212..12......
......43..434343434343..43......
....121212121212121212121212....
..1243434343434343434343434312..
..4312121212121212121212121243..
....434343434343434343434343....
......12..121212121212..12......
......43..434343434343..43......
......12121212121212121212......
......43434343434343434343......
......12..1212....1212..12......
......43..4343....4343..43......
......12..12........12..12......
......43..43........43..43......
......121212........121212......
......434343........434343......
......12..121212121212..12......
......43..434343434343..43......
......121212........121212......
....12434343..1212..43434312....
....43121212..4343..12121243....
......434343........434343......
......12..121212121212..12......
......43..434343434343..43......
......121212........121212......
......434343........434343......
......12..12........12..12......
......43..43........43..43......
................................
................................
................................
................................
................................
................................
................................
...............12...............
...............43...............
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
...............12...............
...............43...............
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
`
},

{
    "имя": "Vi",
    "описание": "V-образная раскладка с толстыми краями внизу",
    "раскладка":
`
kmahjongg-layout-v1.0
12............................12
43............................43
1212........................1212
4343........................4343
121212....................121212
434343....................434343
12121212................12121212
43434343................43434343
1212121212............1212121212
4343434343............4343434343
121212121212........121212121212
434343434343........434343434343
12121212121212....12121212121212
43434343434343....43434343434343
12121212121212121212121212121212
43434343434343434343434343434343
................................
................................
................................
................................
12............................12
43............................43
1212........................1212
4343........................4343
121212....................121212
434343....................434343
12121212................12121212
43434343................43434343
1212121212............1212121212
4343434343............4343434343
121212121212........121212121212
434343434343........434343434343
................................
................................
................................
................................
................................
................................
12............................12
43............................43
12............................12
43............................43
1212........................1212
4343........................4343
121212....................121212
434343....................434343
12121212................12121212
43434343................43434343
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
12............................12
43............................43
1212........................1212
4343........................4343
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
12............................12
43............................43
`
},    

{
    "имя": "X-образный",
    "описание": "Большая буква X из фишек Маджонг",
    "раскладка":
`
kmahjongg-layout-v1.0
..121212121212....121212121212..
..434343434343....434343434343..
........121212....121212........
........434343....434343........
..........1212....1212..........
..........4343....4343..........
............12121212............
............43434343............
..............1212..............
..............4343..............
............12121212............
............43434343............
........121212....121212........
........434343....434343........
..121212121212....121212121212..
..434343434343....434343434343..
...1212121212......1212121212...
...4343434343......4343434343...
.........1212......1212.........
.........4343......4343.........
..........1212....12............
..........4343....43............
.............121212.............
.............434343.............
..............1212..............
..............4343..............
............12121212............
............43434343............
..........1212....1212..........
..........4343....4343..........
...1212121212......1212121212...
...4343434343......4343434343...
.....12121212......12121212.....
.....43434343......43434343.....
.........12..........12.........
.........43..........43.........
............12....12............
............43....43............
..............1212..............
..............4343..............
...............12...............
...............43...............
.............12..12.............
.............43..43.............
............12....12............
............43....43............
.....12121212......12121212.....
.....43434343......43434343.....
.......1212..........1212.......
.......4343..........4343.......
................................
................................
................................
................................
...............12...............
...............43...............
...............12...............
...............43...............
................................
................................
................................
................................
.......121212......121212.......
.......434343......434343.......
........12............12........
........43............43........
................................
................................
................................
................................
................................
...............12...............
...............43...............
................................
................................
................................
................................
................................
..........12........12..........
..........43........43..........
`
},

{
    "имя": "Замок",
    "описание": "Раскладка замка",
    "раскладка":
`
kmahjongg-layout-v1.1
# Board size in quarter tiles
w32
h16
# Board depth
d4
# Level 0 -------------------------
...12121212..........12121212...
...43434343..........43434343...
...12121212...1212...12121212...
...43434343...4343...43434343...
.......121212121212121212.......
.......434343434343434343.......
..1212.....1212121212.....1212..
..4343.....4343434343.....4343..
..12......121212121212......12..
..43......434343434343......43..
......12121212121212121212......
......43434343434343434343......
..12121212..12121212..12121212..
..43434343..43434343..43434343..
..12121212...121212...12121212..
..43434343...434343...43434343..
# Level 1 -------------------------
.....121212..........121212.....
.....434343..........434343.....
.....121212...1212...121212.....
.....434343...4343...434343.....
.........12..........12.........
.........43..........43.........
..1212.......121212.......1212..
..4343.......434343.......4343..
..12........12121212........12..
..43........43434343........43..
..........121212121212..........
..........434343434343..........
....121212............121212....
....434343............434343....
....121212...121212...121212....
....434343...434343...434343....
# Level 2 -------------------------
................................
......1212............1212......
......4343.....12.....4343......
...............32...............
................................
................................
...............12...............
...............43...............
..............1212..............
..............4343..............
..............1212..............
..............4343..............
................................
.....1212..............1212.....
.....4343......12......4343.....
...............43...............
# Level 3 -------------------------
................................
......1212............1212......
......4343.....12.....4343......
...............32...............
................................
................................
................................
................................
..............1212..............
..............4343..............
..............1212..............
..............4343..............
................................
.....1212..............1212.....
.....4343......12......4343.....
...............43...............
`
},

{
    "имя": "Кот",
    "описание": "Раскладка в виде кота",
    "раскладка":
`
kmahjongg-layout-v1.1
# Board size in quarter tiles
w36
h16
# Board depth
d4
# Level 0 -------------------------
............................12......
............................4312....
..............................4312..
................................43..
................12121212121212....12
..............1243434343434343....43
..12121212....431212121212121212..12
..43434343..12124343434343434343..43
1212121212..4343121212121212121212..
4343434343..1212434343434343434343..
1212121212..4343121212121212121212..
4343434343..1212434343434343434343..
1212121212..4343121212121212121212..
434343434312..12434343434343434343..
..1212121243..431212121212121212....
..43434343......4343434343434343....
# Level 1 -------------------------
............................12......
............................4312....
..............................4312..
................................43..
....................................
....................................
..................121212121212......
..................434343434343......
....1212........1212121212121212....
....4343......124343434343434343....
..12121212....431212121212121212....
..43434343......4343434343434343....
....1212..........121212121212......
....4343..........434343434343......
....................................
....................................
# Level 2 -------------------------
....................................
....................................
....................................
....................................
....................................
....................................
....................................
....................................
..................1212121212........
....1212..........4343434343........
....4343..........1212121212........
....1212..........4343434343........
....4343............................
....................................
....................................
....................................
# Level 3 -------------------------
....................................
....................................
....................................
....................................
....................................
....................................
....................................
....................................
....................................
....................121212..........
....................434343..........
....................................
....................................
....................................
....................................
....................................
`
},

{
    "имя": "Краб",
    "описание": "Раскладка в виде краба",
    "раскладка":
`
kmahjongg-layout-v1.1
# Board size in quarter tiles
w32
h16
# Board depth
d4
# Level 0 -------------------------
...12121212..........12121212...
...43434343..........43434343...
...12121212...1212...12121212...
...43434343...4343...43434343...
.......121212121212121212.......
.......434343434343434343.......
..1212.....1212121212.....1212..
..4343.....4343434343.....4343..
..12......121212121212......12..
..43......434343434343......43..
......12121212121212121212......
......43434343434343434343......
..12121212..12121212..12121212..
..43434343..43434343..43434343..
..12121212...121212...12121212..
..43434343...434343...43434343..
# Level 1 -------------------------
.....121212..........121212.....
.....434343..........434343.....
.....121212...1212...121212.....
.....434343...4343...434343.....
.........12..........12.........
.........43..........43.........
..1212.......121212.......1212..
..4343.......434343.......4343..
..12........12121212........12..
..43........43434343........43..
..........121212121212..........
..........434343434343..........
....121212............121212....
....434343............434343....
....121212...121212...121212....
....434343...434343...434343....
# Level 2 -------------------------
................................
......1212............1212......
......4343.....12.....4343......
...............43...............
................................
................................
...............12...............
...............43...............
..............1212..............
..............4343..............
..............1212..............
..............4343..............
................................
.....1212..............1212.....
.....4343......12......4343.....
...............43...............
# Level 3 -------------------------
................................
................................
................................
................................
................................
................................
................................
................................
...............12...............
...............43...............
...............12...............
...............43...............
................................
................................
................................
................................
`
},

{
    "имя": "Крест",
    "описание": "Шестиконечный крест, похожий на букву «Ж»",
    "раскладка":
`
kmahjongg-layout-v1.0
12....12121212121212121212....12
4312..43434343434343434343..1243
124312........1212........124312
43124312......4343......12431243
..43124312....1212....12431243..
....43124312..4343..12431243....
......43124312121212431243......
........4312434343431243........
........1243121212124312........
......12431243434343124312......
....12431243..1212..43124312....
..12431243....4343....43124312..
12431243......1212......43124312
431243........4343........431243
1243..12121212121212121212..4312
43....43434343434343434343....43
12......1212121212121212......12
4312....4343434343434343....1243
124312........1212........124312
43124312......4343......12431243
..43124312....1212....12431243..
....431243....4343....431243....
......4312....1212....1243......
........43....4343....43........
........12....1212....12........
......1243....4343....4312......
....124312....1212....124312....
..12431243....4343....43124312..
12431243......1212......43124312
431243........4343........431243
1243....1212121212121212....4312
43......4343434343434343......43
12........121212121212........12
4312......434343434343......1243
124312........1212........124312
43124312......4343......12431243
..43124312....1212....12431243..
....431243....4343....431243....
......4312....1212....1243......
........43....4343....43........
........12....1212....12........
......1243....4343....4312......
....124312....1212....124312....
..12431243....4343....43124312..
12431243......1212......43124312
431243........4343........431243
1243......121212121212......4312
43........434343434343........43
...............12...............
...............43...............
...............12...............
...............43...............
...............12...............
...............43...............
...............12...............
...............43...............
...............12...............
...............43...............
...............12...............
...............43...............
...............12...............
...............43...............
...............12...............
...............43...............
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
`
},

{
    "имя": "Цветы",
    "описание": "Раскладка, содержащая шесть цветов",
    "раскладка":
`
kmahjongg-layout-v1.0
..12121212..12121212..12121212..
..43434343..43434343..43434343..
..12....12..12....12..12....12..
..43....43..43....43..43....43..
..12121212..12121212..12121212..
..43434343..43434343..43434343..
.....12........12........12.....
.....4312121212431212121243.....
.....1243434343124343434312.....
.....43........43........43.....
..12121212..12121212..12121212..
..43434343..43434343..43434343..
..12....12..12....12..12....12..
..43....43..43....43..43....43..
..12121212..12121212..12121212..
..43434343..43434343..43434343..
..12121212....1212......1212....
..43434343....4343......4343....
..12....12..12....12..12....12..
..43....43..43....43..43....43..
..12121212....1212......1212....
..43434343....4343......4343....
................................
................................
................................
................................
....1212......1212......1212....
....4343......4343......4343....
..12....12..12....12..12....12..
..43....43..43....43..43....43..
....1212......1212......1212....
....4343......4343......4343....
....1212.......12........12.....
....4343.......43........43.....
..12....12..12....12..12....12..
..43....43..43....43..43....43..
....1212.......12........12.....
....4343.......43........43.....
................................
................................
................................
................................
.....12........12........12.....
.....43........43........43.....
..12....12..12....12..12....12..
..43....43..43....43..43....43..
.....12........12........12.....
.....43........43........43.....
.....12.........................
.....43.........................
..12....12......................
..43....43......................
.....12.........................
.....43.........................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
................................
`
},

{
    "имя": "Галактика",
    "описание": "Скопления материи разного размера",
    "раскладка":
`
kmahjongg-layout-v1.0
...............12...............
..1212.........43.........1212..
..4343.......121212.......4343..
.121212......434343......121212.
.434343....1212121212....434343.
..1212.....4343434343.....1212..
..4343...12121212121212...4343..
.......124343434343434312.......
.......431212121212121243.......
..1212...43434343434343...1212..
..4343.....1212121212.....4343..
.121212....4343434343....121212.
.434343......121212......434343.
..1212.......434343.......1212..
..4343.........12.........4343..
...............43...............
................................
...12..........12..........12...
...43..........43..........43...
..1212.......121212.......1212..
..4343.......434343.......4343..
...12......1212121212......12...
...43......4343434343......43...
.........12121212121212.........
.........43434343434343.........
...12......1212121212......12...
...43......4343434343......43...
..1212.......121212.......1212..
..4343.......434343.......4343..
...12..........12..........12...
...43..........43..........43...
................................
................................
................................
................................
...12......................12...
...43........121212........43...
.............434343.............
...........1212121212...........
...........4343434343...........
...........1212121212...........
...........4343434343...........
.............121212.............
...12........434343........12...
...43..........12..........43...
...............43...............
................................
................................
................................
................................
................................
................................
................................
.............121212.............
.............434343.............
...........1212121212...........
...........4343434343...........
.............121212.............
.............434343.............
...............12...............
...............43...............
................................
................................
................................
................................
................................
................................
................................
................................
...............12...............
...............43...............
.............12..12.............
.............43..43.............
...............12...............
...............43...............
................................
................................
................................
................................
................................
`
},

{
    "имя": "Паук",
    "описание": "Раскладка в виде паука",
    "раскладка":
`
kmahjongg-layout-v1.1
# Board size in quarter tiles
w32
h16
# Board depth
d4
# Level 0 -------------------------
......1212...12..12...1212......
......4343...43..43...4343......
........12....1212....12........
..12....4312..4343..1243....12..
..4312....431212121243....1243..
....431212..43434343..121243....
......43431212121212124343......
..........434343434343..........
.........12121212121212.........
.121212124343434343434312121212.
.43434343.121212121212.43434343.
..........434343434343..........
........12..12121212..12........
......1243..43434343..4312......
..121243......1212......431212..
..4343........4343........4343..
# Level 1 -------------------------
......1212...12..12...1212......
......4343...43..43...4343......
........12............12........
..12....4312........1243....12..
..4312....43..1212..43....1243..
....431212....4343....121243....
......4343..12121212..4343......
............43434343............
...........1212121212...........
.12121212..4343434343..12121212.
.43434343...12121212...43434343.
............43434343............
........12....1212....12........
......1243....4343....4312......
..121243......1212......431212..
..4343........4343........4343..
# Level 2 -------------------------
........12............12........
........43............43........
................................
..12......12........12......12..
..43......43........43......43..
......12................12......
......43......1212......43......
..............4343..............
.............121212.............
.12..12......434343......12..12.
.43..43.......1212.......43..43.
..............4343..............
..............1212..............
......12......4343......12......
..12..43................43..12..
..43........................43..
# Level 3 -------------------------
................................
................................
................................
................................
................................
................................
................................
................................
................................
...............12...............
...............43...............
................................
................................
................................
................................
................................
`
},
    
]; }",
{"status":false}
],

[
"отладочные раскладки",
"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",
{"status":false}
],

[
"игра.реакции",
"// // // //

function ПроверитьТекстурыСферы(мир)
{
    this.исполнить = function()
    {
        var сфера = мир.состояние["сфера"];
        var загрузчик = new THREE.TextureLoader();
        var текстура = загрузчик.load("data:image/png;base64,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");
        var материал = new THREE.MeshLambertMaterial({
            color: 0x0000FF,
            map: текстура,
        });
        сфера.material = материал;
    };
}

// // // //

function ПоказатьСферу(мир)
{
    this.исполнить = function()
    {
        var форма = new THREE.SphereBufferGeometry(0.1, 32, 32);
        var сфера = new THREE.Mesh(форма);
        мир.состояние["сфера"] = сфера;
        var корень = мир.состояние["корень"];
        корень.add(сфера);
    };
}

// // // //

function ПодготовитьСцену(мир)
{
    this.исполнить = function()
    {
        мир.состояние["камера"].position.z = 10;
        // Создаём источник света.
        var свет = new THREE.DirectionalLight(0xffffff, 1);
        свет.position.set(-0.5, 0.5, 1).normalize();
        var сцена = мир.состояние["сцена"];
        сцена.add(свет);
        // Создаём корень.
        var корень = new THREE.Group();
        сцена.add(корень);
        мир.состояние["корень"] = корень;
    };
}

// // // //

function ВыбратьПервуюТему(мир)
{
    this.исполнить = function()
    {
        var темы = мир.состояние["темы"];
        темы.выбрать(0);
    };
}

// // // //

function ДобавитьТемыВстроенные(мир)
{
    this.исполнить = function()
    {
        var темы = мир.состояние["темы"];
        var т64 = МОД.модуль("темы встроенные").code64;
        eval(муром.atob(т64));
        темы.добавить(МР());
    };
}

// // // //

function СоздатьЗавТем(мир)
{
    this.исполнить = function()
    {
        мир.состояние["темы"] = new Набор();
    };
}

// // // //

function ВыбратьПервуюРаскладку(мир)
{
    this.исполнить = function()
    {
        var раскладки = мир.состояние["раскладки"];
        раскладки.выбрать(0);
    };
}

// // // //

function СинхритьСписокРаскладокСЗавом(мир)
{
    this.исполнить = function()
    {
        var раскладки = мир.состояние["раскладки"];
        var self = this;
        раскладки.изменилиСписок.подписать(function() {
            self.обновитьСписок();
        });
        раскладки.изменилиВыбор.подписать(function() {
            self.обновитьВыбор();
        });
    };
    
    this.обновитьСписок = function()
    {
        var раскладки = мир.состояние["раскладки"];
        var список = мир.состояние["список раскладок"];
        var именаОписания = this.именаОписанияРаскладок(раскладки.список);
        список.задать(именаОписания);
    };
    
    this.обновитьВыбор = function()
    {
        var раскладки = мир.состояние["раскладки"];
        var список = мир.состояние["список раскладок"];
        список.выбрать(раскладки.выбор);
    };
    
    this.именаОписанияРаскладок = function()
    {
        var раскладки = мир.состояние["раскладки"].список;
        var список = [];
        for (var номер in раскладки)
        {
            var р = раскладки[номер];
            список.push([р.имя, р.описание]);
        }
        return список;
    };
}

// // // //

function ДобавитьОтладочныеРаскладки(мир)
{
    this.исполнить = function()
    {
        var раскладки = мир.состояние["раскладки"];
        var р64 = МОД.модуль("отладочные раскладки").code64;
        eval(муром.atob(р64));
        раскладки.добавить(МР());
    };
}

// // // //

function ДобавитьВстроенныеРаскладки(мир)
{
    this.исполнить = function()
    {
        var раскладки = мир.состояние["раскладки"];
        var р64 = МОД.модуль("встроенные раскладки").code64;
        eval(муром.atob(р64));
        раскладки.добавить(МР());
    };
}

// // // //

function СоздатьСписокРаскладок(мир)
{
    this.исполнить = function()
    {
        мир.состояние["список раскладок"] = new Список("раскладки-раскладки");
    };
}

// // // //

function СоздатьЗавРаскладок(мир)
{
    this.исполнить = function()
    {
        мир.состояние["раскладки"] = new Набор();
    };
}

// // // //

function ПереключитьЭкранРаскладок(мир)
{
    this.исполнить = function()
    {
        $("#раскладки").fadeToggle("fast");
    };
}

// // // //

function ДобавитьЭкранРаскладок(мир)
{
    this.исполнить = function()
    {
        var html =
`
<div id="раскладки-раскладки" class="uk-child-width-1-1 uk-grid-small uk-grid-match" uk-grid></div>
<a id="раскладки-скрыть" class="uk-icon-button" uk-icon="close"></a>
`;
        var css =
`
#раскладки-скрыть
{
    position: absolute;
    bottom: 1em;
    left: 1em;
}
#раскладки-раскладки
{
    position: absolute;
    right: 0;
    top: 1em;
    bottom: 1em;
    padding: 1em;
    width: 20em;
    overflow-y: scroll;
}
`;
        добавитьЭкран("раскладки", html, css);
        $("#раскладки")
            .hide()
            .css("background", "linear-gradient(270deg, white, white 20em, rgba(255,255,255,0)")
            ;
        $("#раскладки-скрыть").click(function(e) {
            мир.события["переключить раскладки"].уведомить();
        });
    };
}

// // // //

function ДобавитьЭкранОсновной(мир)
{
    this.исполнить = function()
    {
        var html =
`
<a id="основной-раскладки" class="uk-icon-button" uk-icon="thumbnails" uk-tooltip="title: Раскладки; delay: 500"></a>
`;
        var css =
`
#основной-раскладки
{
    position: absolute;
    bottom: 1em;
    left: 1em;
}
`;
        добавитьЭкран("основной", html, css);
        $("#основной-раскладки").click(function(e) {
            мир.события["переключить раскладки"].уведомить();
        });
    };
}

// // // //

function ВывестиПростоТекст(мир)
{
    this.исполнить = function()
    {
        console.log("Просто текст", new Date());
    };
}

// // // //

function УлавливатьВыборСфер(мир)
{
    добавитьСловарь(мир.состояние, {
        "номер выбранной сферы": null,
        "номера выбранных сфер": [],
    });
    
    this.исполнить = function()
    {
        мир.состояние["улавливатель"] = new THREE.Raycaster();
        this.отслеживатьНастолки();
        this.отслеживатьМобилки();
    };
    this.отслеживатьНастолки = function()
    {
        var self = this;
        window.addEventListener(
            "click",
            function(событие) {
                var позиция = new THREE.Vector2();
                позиция.x = (событие.clientX / window.innerWidth) * 2 - 1;
                позиция.y = - (событие.clientY / window.innerHeight) * 2 + 1;
                self.выбрать(позиция);
            }
        );
    };
    this.отслеживатьМобилки = function()
    {
        var self = this;
        window.addEventListener(
            "touchstart",
            function(событие) {
                var позиция = new THREE.Vector2();
                позиция.x = (событие.touches[0].clientX / window.innerWidth) * 2 - 1;
                позиция.y = - (событие.touches[0].clientY / window.innerHeight) * 2 + 1;
                self.выбрать(позиция);
            }
        );
        // Исправляем улавливание нажатий на iOS.
        // https://stackoverflow.com/a/31459240/3404710
        var отрисовщик = мир.состояние["отрисовщик"];
        отрисовщик.domElement.style.cursor = "pointer";
    };
    this.выбрать = function(позиция)
    {
        var улавливатель = мир.состояние["улавливатель"];
        var камера = мир.состояние["камера"];
        var корень = мир.состояние["корень"];
        улавливатель.setFromCamera(позиция, камера);
        var пересечения = улавливатель.intersectObjects(корень.children);
        if (пересечения.length)
        {
            var сфера = пересечения[0].object;
            var номер = this.номерСферы(сфера.id);
            if (номер)
            {
                мир.состояние["номер выбранной сферы"] = номер;
                мир.состояние["номера выбранных сфер"].push(номер);
                мир.события["выбор"].уведомить();
            }
        }
    };
    this.номерСферы = function(id)
    {
        var сферы = мир.состояние["сферы"];
        for (var номер in сферы)
        {
            var сфера = сферы[номер];
            if (сфера.id == id)
            {
                return номер;
            }
        }
        
        return null;
    };
}
",
{"status":true}
],

[
"игра.последовательность",
"0L/Rg9GB0Log0LjQs9GA0YsKICAgINC00L7QsdCw0LLQuNGC0Ywg0Y3QutGA0LDQvSDQvtGB0L3QvtCy0L3QvtC5CiAgICDQtNC+0LHQsNCy0LjRgtGMINGN0LrRgNCw0L0g0YDQsNGB0LrQu9Cw0LTQvtC6CiAgICDRgdC+0LfQtNCw0YLRjCDQt9Cw0LIg0YDQsNGB0LrQu9Cw0LTQvtC6CiAgICDRgdC+0LfQtNCw0YLRjCDRgdC/0LjRgdC+0Log0YDQsNGB0LrQu9Cw0LTQvtC6CiAgICDRgdC40L3RhdGA0LjRgtGMINGB0L/QuNGB0L7QuiDRgNCw0YHQutC70LDQtNC+0Log0YEg0LfQsNCy0L7QvAogICAg0LTQvtCx0LDQstC40YLRjCDQvtGC0LvQsNC00L7Rh9C90YvQtSDRgNCw0YHQutC70LDQtNC60LgKICAgINC00L7QsdCw0LLQuNGC0Ywg0LLRgdGC0YDQvtC10L3QvdGL0LUg0YDQsNGB0LrQu9Cw0LTQutC4CiAgICDQstGL0LHRgNCw0YLRjCDQv9C10YDQstGD0Y4g0YDQsNGB0LrQu9Cw0LTQutGDCiAgICDRgdC+0LfQtNCw0YLRjCDQt9Cw0LIg0YLQtdC8CiAgICDQtNC+0LHQsNCy0LjRgtGMINGC0LXQvNGLINCy0YHRgtGA0L7QtdC90L3Ri9C1CiAgICDQstGL0LHRgNCw0YLRjCDQv9C10YDQstGD0Y4g0YLQtdC80YMKICAgINC/0L7QtNCz0L7RgtC+0LLQuNGC0Ywg0YHRhtC10L3RgwogICAg0L/QvtC60LDQt9Cw0YLRjCDRgdGE0LXRgNGDCiAgICDQv9GA0L7QstC10YDQuNGC0Ywg0YLQtdC60YHRgtGD0YDRiyDRgdGE0LXRgNGLCtC/0LXRgNC10LrQu9GO0YfQuNGC0Ywg0YDQsNGB0LrQu9Cw0LTQutC4CiAgICDQv9C10YDQtdC60LvRjtGH0LjRgtGMINGN0LrRgNCw0L0g0YDQsNGB0LrQu9Cw0LTQvtC6",
{"status":false}
],

[
"темы встроенные",
"function МР() { return [

{
    "имя": "Заглушка",
    "описание": "Простейшая тема в цвет фона",
    "изображения": [

['0/1', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAANlBMVEVERHdDQ3VBQXEgIDgAAAAoKEZDQ3YICA4iIjtERHc+PmwwMFQVFSQICA4EBAdDQ3UzM1k0NFtRX3oPAAAAAWJLR0QEj2jZUQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfKotbtz4AAABZSURBVHja7c6HDYAwEACxBELv+y9L2QG9EPYCdykBAAAAAAAAAN+Qqxw7UJcmtN92wQN9CRwYxmkukQNLecQNrNED22WPHLgdBgwYMGDAwO8HAAAAAAB40Qkd8QLJJbvoCwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/2', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA8FBMVEVERHc/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHAyMlcGBgoAAAAICA42Nl43N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2cVFSRERHdDQ3UdHTIVFSQ8PGkAAAASEh8BAQE+Pm0wMFQqKkkgIDgyMlgoKEY0NFsnJ0QxMVYxMVVBQXEZGSs8PGk5OWMBAQIODhg4OGIHBw0xMVZBQXIiIjwmJkNDQ3YqKkoHBwwDAwY6OmUPDxsWFiY8PGklJUECAgMSEh82Nl4iIjsvL1IpKUdAQHBCQnQNDRcrK0syMlcYGCobGy89PWoODhkFBQk0W/oTAAAAAWJLR0QMgbNRYwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfKotbtz4AAADtSURBVHja7dTHUsIAFEbhiGLjKDZEQMVesHewd+y+/9vIKKPuXJm7Od8md3f+zGSSJJIkSZIkSZIkSZIkSX/qyHR2Zbt7evuC+v05vgwMhvTzQzA8MjpWgPFixIAJyJRaz3IFJgP6U9NUS59XucDMbPoD5mC+fS7AYvoDlmC5fa7AavoDirXaWvtch430B/zY3GK7FNjf2YW9uPz+QRYOw/JH9QYc18P6J6etH/HZeVS+dHEJV9dhr5/cQOM28PO/g+p9XD5p5nhoBvaTR3iK7CfP8FL59pr+gDd+y6c/4D16gCRJkiRJkiTp330A7NUSrqAE5JwAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/3', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABDlBMVEVERHdBQXI3N2A1NV0/P29CQnMjIz0ICA4AAAAGBgokJD9CQnMPDxoJCQ88PGkcHDENDRcvL1MyMlgPDxsQEBxERHc/P24CAgMNDRdDQ3UNDRY5OWMyMlgtLU4rK0wsLE0nJ0U7O2c2Nl4hITouLlAbGzAtLU4nJ0QYGCo5OWRBQXI+Pm0yMlcYGCodHTIqKkoDAwYkJD9DQ3YCAgQcHDE9PWs+Pmw0NFswMFQnJ0URER47O2gmJkMXFygBAQFCQnQ5OWMbGy87O2cEBAcSEh8bGy8ODhkFBQgODhkjIz0lJUEvL1IUFCM9PWsEBAdBQXEAAAAuLlAHBw0ICA4oKEY1NVwzM1k5OWQlJUA9PWq3GBqNAAAAAWJLR0QIht6VegAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAEaSURBVHja7dbXUgJBFIThQQltjkhQEVEMuCpiVgSzmDHr+7+ISy3oG+wpy/+7mOq77rmZGucAAAAAAAAAAAAAAMBfEOnqjtq1x+IJ+Xp6+4xu36+2gUGTAUPS8Eg0OjomjScN+idSSsdaIZOVJg0GTEnTQcpJMwYD8tJskArSnMGA+WIxEqQFadFgwK8ladmqO1la8ValNbPLr7eegfJGxXbA5ta22YCd3b39AylxaLagpSodmQ5IZlWrh95a8bzjTj6RTsO/9pnOO/ni51EM06WuMu3YUMrgS3At3QTpVroLv9/dPygVf3SuVC2rWTAY4J5q/iP0/OIfzVeLfufe0sGPrPFu0+/7yH3mvS+L/xgAAAAAAAAA/AvfYR0VwUeDoTEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/4', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAe1BMVEVERHdCQnRBQXFCQnRBQXEKChEAAAAlJUEZGSwsLE07O2cDAwYODhkICA4fHzcFBQgwMFQyMlcuLlE3N2E+Pm0GBgsbGzBDQ3YTEyILCxNBQXImJkICAgM3N2E2Nl8BAQInJ0QUFCNERHcbGy8tLU4kJD8YGCo2Nl45OWSgdb6uAAAAAWJLR0QGYWa4fQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAACYSURBVHja7dRZEsEAFETRR2gRM0nMYohh/yvEjyoLoEu5ZwN9vzoCAAAAAAAAAAAAAAD8ikYzse632upYA1J5A7ryBmQ9b0DS18AaMNRo7AyYSNOZMSAvVIYxYL7QcuUMWGuzDWPArtI+jAGPCz4cnQGpijyMAZl0qp/O0qWur18PuOlN+X8BL84nJIAAAAAAAAAAAMBn3QE4rwfEfl01RQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/5', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA/1BMVEVERHcPDxoAAAAxMVUFBQlAQHARER0dHTI5OWM2Nl8vL1MtLU46OmUjIz0BAQFCQnQZGSwKChEPDxsUFCM2Nl8XFygKChICAgMGBgoTEyEqKkpDQ3UEBAcMDBU7O2hAQHADAwYeHjUrK0wpKUccHDEFBQgJCRA/P283N2AJCQ85OWM9PWsQEBweHjQ/P28zM1k/P248PGkCAgQDAwVCQnQaGi00NFsmJkIsLE0rK0wvL1IyMlgiIjszM1oSEiACAgRERHdCQnMuLlAaGi1BQXEHBw0dHTM/P24BAQIEBAcHBw0DAwY7O2cWFiYBAQETEyI5OWQ+Pm0tLU4kJD88PGlafa99AAAAAWJLR0QCZgt8ZAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAEESURBVHja7dXXUsJgFEXh3y2gELGiYkWxgFgQLFGxoYIV+/s/i0EwXjqjMzkzzvquzlX2ukniHAAAAAAAAAAAAAAAwE96FOo1CYgZB8SlRF9Xv0VAUkpZ7IY8acA0IK3BIdOAYY2Y7rtRjWXGJyazU9MzNgFZzXZfwrl5i/1csLywmF9aXpFWCwYBRWmt1D7WN6RNg4Ctcnm7c1Wq2tk1KPi2J+2bBvjSgWnAoeRFv3rk1b7OY+kk+oBTncU713lC1Xr0AX748l1Il9Hvu6uG1Lx2rpC+0W3FIMAl21/iuyBD97W/P+03HlqPn7+Cp2eb/cDLq/+WfzebBwAAAAAAAID/7gMcMhEcDcty5QAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/6', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABJlBMVEVERHdERHc7O2cyMlg2Nl5BQXEpKUgLCxMAAAATEyE6OmVCQnQVFSUCAgM1NVwaGi4TEyI1NVxBQXI7O2chITkBAQEICA4/P281NV0WFidDQ3YlJUAnJ0UVFSUBAQE9PWtCQnQEBAcTEyECAgQ5OWM1NV02Nl8xMVYrK0smJkM5OWQzM1k9PWodHTItLU4JCRAODhkyMlcZGSseHjUmJkMWFiYBAQIhITo3N2A3N2EhIToBAQI4OGIVFSQ0NFsvL1IPDxsXFykSEh8bGy8vL1MjIz0vL1IkJD8sLE0rK0swMFQuLlEkJD8wMFRBQXECAgMbGzA+PmwYGCoSEh86OmYDAwYrK0xCQnMnJ0UJCQ8wMFQICA4MDBUyMlg0NFsoKEYjIz4pKUeufNjNAAAAAWJLR0QIht6VegAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAEtSURBVHja7dXHUgJRFIThi4o2BkQURdQxYFbMIog555yz7/8SDjBVvsGc0vq/Ve+6FzPnOgcAAAAAAAAAAAAAAP6CSE1tXdSwvr5BvlijUX9Ts6pa4jYDWqVEW7K9I6XOLov+tNSdKYceqddiQJ+8/koYGNSQQX8yq0QQh0dGDQaMSeMGtb8mpLiLTI5NTRsNyEntM7Plv3Bu3mTAgrQY3AEtWQxY9ovzK4VocTWl0prBgHXJ26ikTWnLYMC2lAvijv85hD9gV9oL4r50EP6AQ6kYxCPpOPwBJ9JpEM+k8/AHXFzqKogx6Tr8Ae5GXvUJOJduDfrdXV73D48u+ZRVKm0xwI37p6j07Pn3oN6k37mX18ohfns36ncu8/H59V2ImPUDAAAAAAAAwD/3A0XFGGmV49uoAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/7', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAk1BMVEVERHcZGSwAAAAbGzArK0wdHTIVFSQrK0tDQ3YSEh8VFSVERHcoKEYGBgo+Pm07O2gDAwUvL1IRER4aGi0pKUcDAwY+Pm1BQXEGBgoiIjwiIjtBQXE9PWsDAwUnJ0UbGzAHBw1CQnQCAgMlJUEKChEzM1ksLE0aGi0BAQEHBwwODhk4OGIeHjUlJUEvL1ITEyE/P27Ua/aQAAAAAWJLR0QCZgt8ZAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAClSURBVHja7dNHEoIAEERRbBOIihERc87h/qdzp67caS/87wK/a6omCAAAAAAAAAAAAAAAAD4r6F3xDweUyk8Vqfr7AS9hpFrsHFBXo+nsJy21nf2wo66zH/TUT539Qaah9QC5spGzP55oaj3ATPOFs58ulVsPsJISZz9eK7IeYCNtrQN22lt/MD7oaD3ASTpbB1ykq3XATbpbBwAAAAAAAAAAvusBvTcFx6EDucIAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/8', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABNVBMVEVERHdCQnM3N2EyMlg9PWpERHc1NV0PDxsAAAAAAAAEBAchITlBQXEkJD8HBw08PGkzM1kFBQkpKUc7O2hAQHAVFSUQEBxDQ3URER0BAQI2Nl8yMldDQ3YDAwYSEh8zM1o9PWoaGi4bGy9CQnMBAQEPDxoxMVYiIjwWFicuLlFCQnQODhgBAQI7O2c+PmwKChEbGzAzM1koKEYKChEtLU4/P28TEyIDAwU2Nl4pKUgFBQgMDBU3N2AiIjsLCxMtLU8dHTMBAQE4OGI1NVwQEBxDQ3UwMFQXFyk5OWQWFic5OWMFBQknJ0QuLlAKChIHBwwpKUcTEyE9PWs2Nl8oKEYICA5DQ3YJCRAqKkksLE05OWQGBgsJCQ8gIDg+PmwZGSsuLlBAQHA1NV0qKkklJUEwMFQ7O2eHuTm/AAAAAWJLR0QJ8dml7AAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAE4SURBVHja7dbnUsJAHATwEw2yKiKCvRNU0GAvGGzYsAL23sv7P4IJF17h/uO4vy+333ZnMrlEKSIiIiIiIiIiIiIiIiIiIvoLGkKNTZZcfbg5AqCltU2oP4pAe0ykvyOCeGciGe4CunskBvSir98/LW/BgED/4BCGdRoBogIDRoExnWJASmCAnca4ThPApMAAlQGy/jk1DScnMWBmFum57PzCIpwliX6lllf0NbCal+m31tzgIiqsiwzYADa3Esn8dhHujkD/LrC3X0sHXhIYUAIOg3gEHJsfUMBJ/UN8CpyZH1BGpR6rgMCLeA5cBDEFXJofcAWUdAo5uL4xP8C+BTI5S9l3ceDefL9SD4/eHeQ++X9lzxL9Sr28FmsXYflNpt/z/vH59f0j8PyJiIiIiIiIiIiI/odfTLkb84DaT3AAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/9', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABJlBMVEVERHc9PWs1NVw0NFs7O2hERHctLU8NDRYAAAAKChEnJ0VDQ3ZDQ3UZGSsVFSRDQ3UfHzYHBwwsLE08PGk+PmwvL1ILCxM6OmUBAQEJCQ8/P29BQXIQEBwBAQI7O2ghITk5OWQBAQEiIjwRER1CQnMMDBULCxQHBw0XFygTEyEPDxs7O2c0NFs+Pm0DAwU2Nl8vL1MPDxpCQnRDQ3YWFiczM1oPDxoxMVU+PmwODhk9PWoKChEICA4ZGSs/P28dHTMDAwUBAQIYGCobGy9CQnQ1NV0vL1MzM1k/P24VFSRCQnMMDBUJCRBBQXE6OmUaGi41NVwmJkIhITowMFQFBQkKChI9PWoTEyI9PWsxMVUAAAAGBgsmJkJAQHAcHDE8PGklJUApKUeAQLWHAAAAAWJLR0QIht6VegAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAE3SURBVHja7dbnUsJQFATgY8GsgoJKJIjEjr1gVLBiw94FC/b3fwlvTBzfIGd09vu1/3ZJ5t4gQkRERERERERERERERERERH9BU3NLa0ytPdZmwWjviOv0JzoR6kqqDEgB3T29absPSGn0Zxxk+/2QG0DeVRgwCNhBGhrGiMKAUThjYRyHpTCggImfOIl8IvoBU7+t08BM9APMIZgN0tw8sBD9gEWguOQHb9lcBSvRD4ivAlapXC6tQWeArG+EF+HmlsorENmu7Jj63b30PpDRGCByUD08OhY5gXOqMyB0hnOF1gvXDW/CS+BKYcA1cBOkW+BOYYBXQz3nh/saCp7CAP9z+PBonoQ5jU8a/ZIsAo3sszmJLyr9Iq9vDf8equv8/m/v9sdnVe9fMREREREREREREdF/9wWX8RqiquUsowAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/10', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABMlBMVEVERHdDQ3VBQXE/P281NVwxMVU5OWNDQ3YgIDgAAAAoKEY7O2gWFiYBAQIHBw0oKEZDQ3YICA42Nl8EBAcZGSsiIjtBQXIhITk8PGkyMlcLCxQnJ0VERHc+PmwwMFQVFSQkJD8/P24GBgsFBQhBQXEICA4KChIFBQglJUEtLU4EBAc5OWQYGCo6OmUXFyhDQ3UzM1ksLE0KChEKChI0NFshITk2Nl8UFCMBAQFCQnQbGy89PWsXFylAQHAeHjQ6OmYVFSU3N2EaGi1BQXIeHjUgIDgaGi08PGknJ0Q3N2EtLU4wMFQODhg3N2A/P24AAAAUFCMpKUcfHzYQEBwDAwU+Pm0+PmwDAwYHBwxCQnMdHTMvL1IPDxsTEyEGBgoQEBwxMVYbGzAyMlgnJ0UkJD8rK0yynQnYAAAAAWJLR0QJ8dml7AAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAFUSURBVHja7dXXUsJgFEXhiHVZwY4Vsffeu9gb9t7L+7+CwSSA184cRmd/N8C+IGsymT+OIyIiIiIiIiIiIiIiIiIiIn9DXigv8yO/oLCo2DighNLga1l5BVBZZZoQjqQDqmvw1IYNA+oIAuoj0NAYijZBs9HFW1rb2kkHxCCW+uyI09llE9Dt3XEvoKWHXu9x7IN+m4CB7IBBGPLmYRixCRh1jQUB4zDu7xNM2gSkTAUB0zDjb7PMzdsHLECZv9XCon3AEiz72wqs2gesQXACumfDun3ABiT8bROK7AO2oNHftmHHPmAX9vzNPR5D9gH7cOBvh0TMrp8JOIIVbzpOcpKDgOI4E97knomnOQhwziD6XXLOxWUuAq6uuXEfw9s72LK7flaAcw/Jh8cneLZ7E/wIcF4iqbfz3GviN3/4K+G3949Pu/eQiIiIiIiIiIiIyL/3Bba4IHlwe+ZPAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/11', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAANlBMVEVERHdDQ3VBQXEgIDgAAAAoKEZDQ3YICA4iIjtERHc+PmwwMFQVFSQICA4EBAdDQ3UzM1k0NFtRX3oPAAAAAWJLR0QEj2jZUQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAABySURBVHja7c5LDoJAFERRkEZ+irL/zWJMSLpDGPoM4ZxZjepWFQAAAAAAAABwDvWtPhhBmtQejBj3LvssRpA+ZZ/FCDCM0yNtn8UI8kxf7X4EmfPP+Q8Br4/39lmMQEv+uQgQIECAAAFXDAAAAAAA4IdW1ysFkQuE1vEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/12', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABAlBMVEVERHdDQ3VBQXEgIDgAAAAoKEY/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHBDQ3YICA4yMlcGBgo2Nl4iIjs3N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2dERHc+PmwwMFQVFSQVFSQdHTIICA48PGkAAAASEh8BAQE+Pm0EBAcqKkkyMlhDQ3UzM1koKEY0NFsnJ0QxMVYxMVUZGSs8PGk5OWMBAQIODhg4OGIHBw0xMVZBQXIiIjwmJkMqKkoHBwwDAwY6OmUPDxsWFiY8PGklJUECAgMSEh82Nl4vL1IpKUdAQHBCQnQNDRcrK0syMlcYGCobGy89PWoODhkFBQlABiouAAAAAWJLR0QEj2jZUQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAEqSURBVHja7dXXUsJgFEVhA1tRLCCKDYkgKnZR7A3sFbvv/ypGIRDk2pNxZn03yfw3e00mmXR1AQAAAAAAAAAAAACA/8GJOOEGRNXt3/bEevvi/QODQ5b7iWQzYDiluuSIYcCo/ID0mDQ+MTmVkaazNuPuTC6vZsCsFHO9q1OQ8jYBc/UnXg+YX1DR/blzMlpcMglYDgbkpJXGeVRaNQlY86z7ARtSqXG+KW2ZBHwr+QHZcjnSONuWduwDWnb3tO+GGHBwKB2Z7XcEHJ/EpVO7/V8BiUpVOqsY7rcHnF94X+XlleV+MMC9vpFu70zn2wK830L13u717wh4kIqP1vOBgFpKTzX7/VbAs/QSwn4r4FV6KzS92wd8KChtH/AZUgAAAAAAAAAA4A99AZ8hF9ZE0zJEAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/13', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABLFBMVEVERHdDQ3VBQXFBQXI3N2A1NV0/P28gIDgAAAAoKEZCQnMjIz0ICA4GBgokJD9CQnNDQ3YICA4PDxoJCQ88PGkiIjscHDENDRcvL1MyMlgPDxsQEBxERHc+PmwwMFQVFSQ/P24CAgMNDRcNDRY5OWMICA4yMlgtLU4rK0wsLE0EBAcnJ0U7O2c2Nl4hITpDQ3UzM1kuLlAbGzAtLU4nJ0Q0NFsYGCo5OWRBQXI+Pm0yMlcYGCodHTIqKkoDAwYkJD9DQ3YCAgQcHDE9PWs+PmwnJ0URER47O2gmJkMXFygBAQFCQnQ5OWMbGy87O2cEBAcSEh8bGy8ODhkFBQgODhkjIz0lJUEvL1IUFCM9PWsEBAcAAAAuLlAHBw0oKEY1NVwzM1k5OWQlJUA9PWoV8HB9AAAAAWJLR0QIht6VegAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAFUSURBVHja7dbXUsJQFIXhQBSXgL1rRAELilhQFKMCdsSuWLH7/u8g8XAC+gA747i+q7Bv9j9MyjEMIiIiIiIiIiIiIiIiIiIi+ht8fl/9h9nUHJAOaEFr7SoYCqOqrb1Dcn9nlw4wu1HT0ysY0Acd0A8MDAYCQ8PAiCWz3BqNjEEHjEcRCzoXvjgwIRMwqf5xFTAFTKtxApiRCZhtDEgCc2qcAuZlAhaqFnXAUjptqvEysCIT4Mi4N6FrFVjzKsDKrtsbwKbc/l8BW849kcsXvA3Y3tn1LGAvE9k/AMKHXgV8KwJHngZYcZSOxQMKtn2iZ6fAmXiAdY4LPbt0X4qCAcYVrvXJpIyo3JHADbgBbtXoDrgX218PeHhENOQ3jGwxh0rKgwDjqVR9CT07n+jKi9z+xsfwNaY+z+U3wf0/vSc+kvan0HmMiIiIiIiIiIiI6B/4AoJNIJOlhX7GAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/14', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAolBMVEVERHdDQ3VBQXFCQnRCQnQgIDgAAAAoKEZBQXEKChElJUFDQ3YICA4ZGSwiIjssLE1ERHc+PmwwMFQVFSQ7O2cDAwYICA4ODhkEBAcfHzcFBQgwMFRDQ3UzM1kyMlcuLlE3N2E0NFs+Pm0GBgsbGzBDQ3YTEyILCxNBQXImJkICAgM3N2E2Nl8BAQInJ0QUFCMbGy8tLU4kJD8YGCo2Nl45OWQQSK6fAAAAAWJLR0QGYWa4fQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAADNSURBVHja7dTLUsJAEEbhCYZfkUQRoiKKaBK5ewno+7+a0YWV0bU9ReV8u+nNnEVXOwcAAAAAAAAAAAAAAA5D1In8wVEnNg3o6th7n/R0avl/P/kVkMo24Ex+wLkMAwYXw5H8gOzSMuBK3xoB8bUSw4Dxn4AbTW4NA+5q02bAvTR7MF7Cx0ZAXqh0AQOe5losQwastN64gAHbZ724gAH1CX4dhAxIVeQuYEAmvVVfdtK+qt7NAz7kKdsX8CPkJSSgnQEAAAAAAAAAgH/0CWCAD2ZnfTWLAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/15', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABHVBMVEVERHdDQ3VBQXEgIDgAAAAoKEYPDxoxMVVDQ3YICA4FBQkiIjtAQHARER0dHTI5OWNERHc+PmwwMFQVFSQ2Nl8vL1MICA4tLU46OmUEBAcjIz0BAQFCQnRDQ3UzM1kZGSwKChE0NFsPDxsUFCM2Nl8XFygKChICAgMGBgoTEyEqKkoMDBU7O2hAQHADAwYeHjUrK0wpKUccHDEFBQgJCRA/P283N2AJCQ85OWM9PWsQEBweHjQ/P28/P248PGkCAgQDAwVCQnQaGi00NFsmJkIsLE0rK0wvL1IyMlgzM1oSEiACAgRCQnMuLlAaGi0HBw0dHTM/P24BAQIEBAcHBw0DAwY7O2cWFiYBAQETEyI5OWQ+Pm0tLU4kJD88PGlFra8wAAAAAWJLR0QEj2jZUQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAE1SURBVHja7dXXUsJAGIbhgJ8dFBVFUbErdizYBVRU7L2X+78MA4QgpzqzOzrvc7SzB/nfJJON4wAAAAAAAAAAAAAAgL8hEAzYDahTvbdqkK/R3PymZj+gxUpAqyoBISnc5mk3MzzS0dklPyAqdZu78ZKe8vP2AmJSr+GAvpqAuPoHDAcMuhJ+wJCGDc8vGfEDRjU2PjE5lZyeMXowVAOS8l6JZudsBMy7kxcWU0vLK9Jq2kLAmrS+UVxsbknbFgJ2Eond8lYmq9ye+YBv9qUDqwF56dBqwJEUMx9wHCtU9twf1In5gFOdhcpbkbCy5+YD8v7HdyFdGptfDQheSdc3jpOO3+ouYyHAiRZP4ns3Qw+F313zhwHO49Nz6Vfw8mpwfq239/xH6tPaeAAAAAAAAAD4d74Ah/0ZlcEP+TsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/16', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABPlBMVEVERHdDQ3VBQXFERHc7O2cyMlg2Nl5BQXEgIDgAAAAoKEYpKUgLCxMTEyE6OmVDQ3YICA5CQnQVFSUCAgM1NVwiIjsaGi4TEyI1NVxBQXI7O2chITkBAQEICA4/P28+PmwwMFQVFSQ1NV0WFidDQ3YlJUAnJ0UVFSUBAQE9PWtCQnQEBAcTEyEEBAcCAgQ5OWM1NV02Nl9DQ3UzM1kxMVYrK0s0NFsmJkM5OWQ9PWodHTItLU4JCRAODhkyMlcZGSseHjUmJkMWFiYBAQIhITo3N2A3N2EhIToBAQI4OGI0NFsvL1IPDxsXFykSEh8bGy8vL1MjIz0vL1IkJD8sLE0rK0swMFQuLlEkJD8wMFQCAgMbGzA+PmwYGCoSEh86OmYDAwYrK0xCQnMnJ0UJCQ8ICA4MDBUyMlgjIz4pKUeai68IAAAAAWJLR0QJ8dml7AAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAFgSURBVHja7dXXUsJQFIXhQFRcIFYUQVBE1NiwUFTsIoi9F+y9vP8LGOAQ4QV2Rmd9Vyf7Zv+TMAdNIyIiIiIiIiIiIiIiIiIior/B4XT8PugNjU0u4YBmuK31nhaYvK2S+9varYCOTlR0+QQDumEF9AD+3kCwL4Rwv8xyfSAyCCsgCgzFSodhYEQmIFx54ypgFMZY+TA+gUmZgKnagEAcfjWfnpmVCZgzJaoBSSAls7ZeuhowD/g0fSGZWLQpIAMEl5ZLn2Rl1ZaANWBd3QPYsCNg01yc3cq58tshFHZsCDBvBGO3fNoD9m0IOAAyanZo/hzkA46AYzU7AU7lA86AvJqdAxfyAZfAlZpdA0X5AOcNbtXMC9zJB2j3MCp/AUXgQWx/TcBjFk/PL1rgNY5Q1I4ALWVeRYU3w7wPPHL7awO0yHv5Iv74FNxfL5Z2f33ndNv2ExEREREREREREf03P3ptI5Tj4u/lAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/17', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAt1BMVEVERHdDQ3VBQXEgIDgAAAAoKEYZGSwbGzBDQ3YICA4iIjsrK0wdHTIVFSQrK0tERHc+PmwwMFRDQ3YSEh8VFSUICA4oKEYGBgo+Pm0EBAc7O2gDAwUvL1JDQ3UzM1kRER4aGi00NFspKUcDAwY+Pm1BQXEGBgoiIjw9PWsDAwUnJ0UbGzAHBw1CQnQCAgMlJUEKChEzM1ksLE0aGi0BAQEHBwwODhk4OGIeHjUlJUEvL1ITEyE/P25QVv7UAAAAAWJLR0QEj2jZUQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAADkSURBVHja7dPZTgJREEXRBo8CjdgITuDMJIgzo+D/f5dIJ0Lf8GpVTPZ6uY9np5IbRQAAAAAAAAAAAAAA4H/I5XO+AXva/3kOtK1gt18sOQfESgPKh78q0pHNeFI9Xo2lARu1uk4Sm4DT9N5BwJnOL2z2o8augOalroz2o+uVmyCgdqs7q/21+yCgpXbHM6Db04PpfhgQq5f3DOgP9Gi7HwQM9fTsGdB5UWy8nw14lZqeAcmb6tb7mYB36cM1YKSx8R/MBiQTTc33twNm0tw14FNauAYspS/7AAAAAAAAAADAH/oGulsMcMSWHQoAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/18', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABRFBMVEVERHdDQ3VBQXFCQnM3N2EyMlg9PWpERHcgIDgAAAAoKEY1NV0PDxsAAAAEBAchITlDQ3YICA4kJD8HBw08PGkiIjszM1kFBQkpKUc7O2hAQHAVFSUQEBxDQ3U+PmwwMFQVFSQRER0BAQI2Nl8yMlcICA4DAwYSEh8zM1oEBAc9PWoaGi4bGy9CQnMBAQEPDxoxMVYiIjw0NFsWFicuLlFCQnQODhgBAQI7O2c+PmwKChEbGzAzM1koKEYKChEtLU4/P28TEyIDAwU2Nl4pKUgFBQgMDBU3N2ALCxMtLU8dHTMBAQE4OGI1NVwQEBwXFyk5OWQWFic5OWMFBQknJ0QuLlAKChIHBwwpKUcTEyE9PWs2Nl9DQ3YJCRAqKkksLE05OWQGBgsJCQ8gIDgZGSsuLlBAQHA1NV0qKkklJUEwMFQ7O2fqqKD4AAAAAWJLR0QJ8dml7AAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAFsSURBVHja7dZpWwFxFMZhpKaHlCSi0KYVLRTti2hRadW+7/X93zfM0vQFjquu535jnDfndzH+w2YjIiIiIiIiIiIiIiIiIiKiv8HusP+8aXA2NinCAc1wGZfuFg+A1jaH5H5vuxngg67DLxjQCSMg4EGwKxR2dwM9EZnlSjTWCzOgD/0DtalaMCgTENc+cS3AO4RhbTwC+GQCRq0BY8C4NvYDCZmAiCpgBCRTmNDGk8CUTEDVtHkPpIFM9XVmFtlcPQLm5pFayCwuLSO7IrffEmBbXdPuifW84H5LgLJR0A+i4mZdAtQjaWs7FM7vlFDYrUPAHrCvPZZi6lUdAsrAgT47BI7kA4o4Nh7EJ8CpfEAFZ8bsHJD7IZoBF8ClPksAV/IBLqCsjZxZxK/lA5I3QDqn2JK3QeBObL/lHLh/UM+gwmP1X9mT3H7rURx9LtUOwsqL4P7fXt/ePz6/5L5/IiIiIiIiIiIiov/uG+89JSzpe2SwAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/19', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABPlBMVEVERHdDQ3VBQXE9PWs1NVw0NFs7O2hERHcgIDgAAAAoKEYtLU8NDRYKChEnJ0VDQ3ZDQ3YICA5DQ3UZGSsVFSQiIjsfHzYHBwwsLE08PGk+PmwvL1ILCxMwMFQ6OmUBAQEJCQ8/P29BQXIQEBwBAQI7O2gICA4hITk5OWQBAQEiIjwEBAcRER1CQnMMDBUzM1kLCxQHBw0XFyg0NFsTEyEPDxs7O2c0NFs+Pm0DAwU2Nl8vL1MPDxpCQnQWFiczM1oPDxoxMVU+PmwODhk9PWoKChEZGSs/P28dHTMDAwUBAQIYGCobGy9CQnQ1NV0vL1MzM1k/P24VFSRCQnMMDBUJCRBBQXE6OmUaGi41NVwmJkIhIToFBQkKChI9PWoTEyI9PWsxMVUAAAAGBgsmJkJAQHAcHDE8PGklJUApKUeLE6cNAAAAAWJLR0QJ8dml7AAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAFtSURBVHja7dZXU8JAGIXhjQ2PogREVJAigr1gb1jA3rB3sGD//3/AzSQZGO8cZ3ZH5zxXy17wvQlsQAgiIiIiIiIiIiIiIiIiIiL6G4wao/Kitq6+waM4oBFNzsrT7IXU0upTOd/0uwGBNjiCxu/e80fa4QaEgI7OrnCkGwgpGu4JR4NwA2JxJHqsRbIXqbSagD77jtsB/UDE3h4YxJCagOHqgBHER539MXjVBASkcTcggwl3fxKpgJoCacoNmK5MnQFm1QfIQzBnb80vAIvqA5aA7LK1MFfk92JVfYBvDfDm8vncOvQEiI1N50Ho39LyEQixvbMrx+/thw+AmI4AIQ4LR8cnQpwifqYnwHGOC2XzKwGX6bTzJLwCrjUE3AC39tYdENUQYBZRSlqL+yIypoYA6+fw4VHeCXkan9TNrwowskA58SxP4ovC+dWn4PWtbD2HSiqv/5v3yMdnQfW/YiIiIiIiIiIiIqJ/7AvQyySkRgGQGgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/20', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABrVBMVEVERHc/P281NVwxMVU5OWNDQ3Y/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHA7O2gWFiYBAQIAAAAHBw0oKEYyMlcGBgoICA42Nl42Nl8EBAcZGStDQ3Y3N2EDAwURER0uLlAjIz4MDBUFBQg7O2dBQXIhITk8PGlBQXEyMlcLCxQnJ0UVFSRERHdDQ3UdHTIVFSQkJD8/P24GBgsFBQhBQXE8PGkAAAASEh8BAQE+Pm0KChItLU4wMFQqKkkgIDgyMlg5OWQYGCo6OmUXFygoKEY0NFsnJ0QxMVYsLE0KChEKChI8PGkhITk2Nl8UFCMBAQFCQnQODhgbGy89PWs4OGIxMVYXFylAQHAeHjQ6OmZBQXIiIjwmJkMVFSUiIjsqKkoHBwwDAwYaGi0eHjU6OmUPDxsgIDgaGi0lJUECAgMSEh82Nl43N2EvL1ItLU4wMFQODhgpKUdAQHA3N2A/P25CQnQNDRcpKUcrK0sfHzYQEBwYGCobGy89PWo+PmwHBwxCQnMdHTMODhkvL1IPDxsTEyEGBgoQEBwFBQkbGzAyMlgnJ0UkJD8rK0wlVIm2AAAAAWJLR0QSe7xsAAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAHfSURBVHja7dXnUxNRFMbhq0lEEQR+IFEJKEUJ6gYQJYhdQQUbNhRjASzYu9h7L/g3u5u9iXH8JM7eGZ33+XLPeT/sOTPZ3DVGRERERERERERERERERERE/klz5sbiCWfT5pXNX1C+sKJyUSGoqq4BauscrbC4nlBySRgsXWaDhpSL+Y1NsLxuRXMLtLYFwcokrGpPd6yGNS4WWAtlnn9mOqErCLqhOzjX9bB+Q/Tze7P0efkq08LGfmO8TbRm8kElbI5+gS2w1ZbbYLsxO2Bn2O+CgegXGITdttwDe40ZgiEbDLMv+gXaYrG0LRtgvzEH4KANDjFyOPoNiuI1HPHfhqNQ9XOjY+7mH6+FUf88ASdtNAanXI3PnS6HM0F1Fgo34DlodDM+NT4Bk+P5+jzkbHwB4k7mX7zk37vV7WEzBbYyl6HXwXjvylW4dr3Q+n/GG7bsgvQsH/on/F964qZXbG/BbVveIelg/l3ou1fS34exsHqQpSL6+dP1PJwuDRI9DIeVfyc+in6Bx9Dxa/LEJomnNPVHv8AzeN5Z9MJPXk7yyn8NX7+Bqejnm7eUyt877yD7/sNH+OTiS/D59wXMaDKoR77k/vLZs5f6+m3mu8PvkIiIiIiIiIiIiMj/7QevXkB2tw5czAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/21', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABAlBMVEVERHdDQ3VBQXE/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHAgIDgAAAAoKEYyMlcGBgoICA42Nl5DQ3Y3N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2ciIjsVFSRERHcdHTIVFSQ+PmwwMFQ8PGkAAAASEh8BAQE+Pm0ICA4qKkkyMlgEBAcoKEY0NFsnJ0QxMVZDQ3UzM1kxMVUZGSs8PGk5OWMBAQIODhg4OGIHBw0xMVZBQXIiIjwmJkMqKkoHBwwDAwY6OmUPDxsWFiY8PGklJUECAgMSEh82Nl4vL1IpKUdAQHBCQnQNDRcrK0syMlcYGCobGy89PWoODhkFBQkmJmOZAAAAAWJLR0QN9rRh9QAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAEkSURBVHja7dTXUsJQGEVhgigWtoJgQzQgih0L9gb2it33fxWjhBjk2p9xZn0352TfZM1QIhEAAAAAAAAAAAAAAPA/OVHH7mVdse6eeG9f/0BoS2jQ7P1DSTWkhoMtnbILyIxIo2PjE1lpMtccp2QXMC3FXO908lLha3BnigXZBczOqeR+35ys5he8c7HxgVgFFKUl/5qQlr1jxTZgVSr71zVp3Ts2PJt2AblKJepft6Rt/1o2/BIGdna153YwYP9AOmw+2AccHcelk+DROiBdrUmn1Z/BOODs3PvZXVyGFtMA9+paurlt2UwDvP/92p3bulkG3Eulh9+jYUA9qcd622oY8CQ9t6+GAS/Saz7wZh/wrrCMfcBHpwMAAAAAAAAAAH/uE//QHLgMGzi0AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/22', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA8FBMVEVERHc/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHAyMlcGBgoAAAAICA42Nl43N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2cVFSRERHdDQ3UdHTIVFSQ8PGkAAAASEh8BAQE+Pm0wMFQqKkkgIDgyMlgoKEY0NFsnJ0QxMVYxMVVBQXEZGSs8PGk5OWMBAQIODhg4OGIHBw0xMVZBQXIiIjwmJkNDQ3YqKkoHBwwDAwY6OmUPDxsWFiY8PGklJUECAgMSEh82Nl4iIjsvL1IpKUdAQHBCQnQNDRcrK0syMlcYGCobGy89PWoODhkFBQk0W/oTAAAAAWJLR0QMgbNRYwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAD8SURBVHja7dTHUkJBFEVRRBGVo5gQG1TMAXMGE2bM/P/fSOkry7Ka6+gy2mvSp/ake9SpFAAAAAAAAAAAAAAAwL960r19mf7swGDH4Gsop2/DIx2Cr/yoNDY+MVmQporR4GxaSof2WSpLM9Hga3ZOlfC1SgXNL0SCs0VpKZnL0kokOFuV1pK5Lm1EgrNitbqZzC1pOxK6ZmdXe8EMvvYPpEMzuDo6zkgnVnB1WqtLZzUj+Dq/aP+7l1dGcBUa19LNrRGc3Un1+2AFXw9S5dEMvpo5PTXN4OxZerGDs1fprfzjPRKcfei3fCQ4a/29r9XlBwAAAAAAAAAA3H0CW60lWy0ianAAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/23', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABmFBMVEVERHdBQXI3N2A1NV0/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHBCQnMjIz0ICA4AAAAGBgokJD9CQnMyMlcICA42Nl4PDxoJCQ88PGk3N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2ccHDENDRcvL1MyMlgPDxtERHcVFSRDQ3UdHTIVFSQ/P24NDRcNDRY5OWMAAAASEh8BAQE+Pm0yMlgtLU4rK0wsLE0wMFQqKkkgIDgnJ0U2Nl4hITooKEY0NFsnJ0QxMVYuLlAbGzAtLU4xMVVBQXEZGSs8PGkYGCo5OWQBAQIODhhBQXI+Pm0yMlcYGCodHTI4OGIHBw0xMVYqKkoDAwYkJD9DQ3YiIjwmJkMCAgQcHDE9PWtDQ3YqKkoHBww+PmwnJ0URER47O2g6OmUWFiY8PGkXFyglJUECAgMSEh9CQnQiIjsvL1I5OWMbGy87O2cpKUdAQHAEBAcbGy8ODhkFBQgODhkrK0sjIz0UFCMYGCo9PWo9PWsEBAcHBw0ICA4FBQk1NVwzM1k5OWQlJUClbwp4AAAAAWJLR0QQlbINLAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAHYSURBVHja7dZZUxNBFIbhjgYcReCNO6iIETEGBZKoiBJZxR3HFTEu4L4hriAuuOvfduJMQlCqvLC6qyy/5yJzTvfFdzo11TXGiIiIiIiIiIiIiIiIiIiIyD8ptmRp3F1avKp6mbd8Rc3KqK+tqyeQWLXaTf6aBKG168LTr496NjS4yG/cCJs2N21phq3J4sI2aNkej7fugOqUgwF2QlUxJ90Gu4Lnbo/22uJGugM67ec3ZMiG50w3k9tjzF7YF251wX77A3TDgag8CK3G9EAy7PNwyP4AvdAXlf0wYMzg0FAs7A9Dv/0BksPDR6LyKByr3DoOJ+wPMK/zJKdKb31q5LR/Bs66zD93Hi6UmovFa2D00pi7+NhlDwrl9ucAV65ecxV/fXwiOPD4/MKNvu6bt6D+tpv8O8Glx917vy4X4L6L+NSDh/Aov8hGB7lJBwM8homp8qU/5vtPSvVTeGY//zlkX1Qc+yXZUj1dvhQtmkzQsuB/nuFVOipn8ex/ErwGf8HCG6gJqyl4az3fvIPptrI5Y95/wKsLbueRwiiZ/N8H/MkMlRqDlaZcUHz8FPxkeu3nm8+/DWC+tIfN7FcH+Yv71vW9x59z8T0mIiIiIiIiIiIi8j/4AamkPnYNY3t6AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/24', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABO1BMVEVERHdCQnRBQXFCQnQ/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHBBQXEAAAAlJUEyMlcGBgoICA42Nl4ZGSw3N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2csLE0VFSRERHdDQ3UdHTIVFSQDAwY8PGkAAAASEh8BAQE+Pm0ODhkwMFQqKkkgIDgyMlgfHzcFBQgwMFQoKEY0NFsnJ0QxMVYuLlExMVUZGSs8PGk+Pm0GBgsbGzA5OWMBAQIODhhDQ3YTEyILCxNBQXI4OGIHBw0xMVYmJkI3N2FBQXIiIjwmJkM2Nl8BAQJDQ3YqKkoHBwwUFCM6OmUPDxsWFiY8PGkCAgMSEh82Nl4bGy8tLU4kJD8YGCoiIjsvL1I5OWQpKUdAQHANDRcrK0syMlcYGCo9PWoODhkFBQnFNdk4AAAAAWJLR0QOb70wTwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAFaSURBVHja7dRXTwJBFAXgBUTBcug2XF0QxV5RFLD3CnZde/f//wJ32RUh4cHEeInJ+V7mzH3YOclORlGIiIiIiIiIiIiIiIiIiIjov3I4XVJH1bnrGzzexqbm8mGLFz6h8/0BWIKhsmkYUgUirUBbe0dnFOhSS9NuiBXoAdyascbiQO/XUE2IFejrR1IrplgUA4PW0DWEoFSBYWDEjqPAmJXGMTEpVWAKmLZjCpgpBj8wG5EqoKbTTjvOAfPmmskip4gV+LawiCXNWJdXsLpWgwLrG8CmGbbg2VbEC+zseoA9M+0fIKVIFzjMF4BE3ozGE3ykSRc4PjGendOzYg4jm1FkC2i+c+Di0tqowJVuugZudD30u0//zC1QuNPszT0q5ATOfwCSj6WdfAFHAE+OKnOxO/AMvFSbixV4NW5dvORNvsB7xT+PyBf4qHUBIiIiIiIiIiIiIvpzn+PSKAvQ80WxAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/25', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABklBMVEVERHc/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHAPDxoAAAAxMVUyMlcGBgoICA42Nl4FBQk3N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2dAQHAdHTI5OWMVFSRERHdDQ3UVFSQ2Nl8vL1M8PGkAAAASEh8BAQE+Pm0tLU46OmUwMFQqKkkgIDgyMlgjIz0BAQFCQnQoKEY0NFsnJ0QxMVYZGSwKChFBQXEZGSs8PGkPDxsUFCM2Nl8XFygKChICAgMTEyEqKko5OWMBAQIODhgEBAcMDBU7O2g4OGIHBw0xMVYDAwYeHjUrK0wpKUccHDEJCRA/P29BQXIiIjwmJkM3N2AJCQ89PWsQEBweHjRDQ3YHBwwzM1k/P24CAgRCQnQWFiY8PGkaGi00NFslJUESEh82Nl4mJkIsLE0iIjsvL1IrK0wvL1IyMlgzM1oNDRcSEiACAgRCQnMrK0syMlcaGi0YGCobGy89PWoHBw0dHTM/P24BAQIEBAcODhkDAwY7O2cTEyI5OWQtLU4kJD9Dye6+AAAAAWJLR0QLH9fEwAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAG/SURBVHja7dTpT1NBGMXhAQGFX62yiCyVW7ECRRZxRVDB4gYqKC4gshQVrRvuCm6o4P/t3HJtamjCB3OHxJzny7zz3qTntGlrjIiIiIiIiIiIiIiIiIiIiMimioq3lZSWbd9RHtwryIm4yN8ZDdJ27V5fVLotUFUNNXtq99ZBfYO/aLT3WGCfgwJNUOzZMx6D/f6iGQ44yP0jcZAWLzvF62hts2cS2h0WOAQdwdgJXfbo5nCPwwJH4GgwHoPj9jjBSYf5piES6Q3GU9Bnj35Onzk7MBg9l4q7LGLM0Hku+N+GKBeDH+Glyy7zh0fgij3LbfLVa6Nj1+vhxriz+Ju3SuG2P92BiSF/mLwLU47i76Wm7dtOZeeimZnZ9W1ijuq0k/z2fvuxz9/fsH8ADx3EewuD8OhxgScZeOKgwFOYfuYVevIckuHnj0FLY979RXIxr9rL0PPTUV6l8xeveRP08WqYext6gXfw/q9FJvfjq4UPoeebj7AUy1k2pvcTfP5izHj3V74lwi+wQr4qu2n2/4lHbA2+L/7zy2+uckMB82O+NXv5ueogv7C2tcyv0b4tixcRERERERERERH5z/wGSQM3I9tTQOkAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/26', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABvFBMVEVERHdERHc7O2cyMlg2Nl5BQXE/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHApKUgLCxMAAAATEyE6OmUyMlcGBgoICA42Nl5CQnQVFSU1NVw3N2EDAwURER0oKEYuLlAjIz4MDBUFBQgaGi4TEyI1NVxBQXI7O2chITkBAQEICA4/P28VFSRDQ3UdHTIVFSQ1NV0WFidDQ3YlJUAnJ0U8PGkAAAASEh8BAQE+Pm0VFSU9PWtCQnQEBAcTEyEwMFQqKkkgIDgyMlgCAgQ5OWM1NV02Nl8oKEY0NFsnJ0QxMVYrK0sxMVVBQXEZGSs8PGkmJkM5OWQzM1k9PWo5OWMBAQIODhgtLU4JCRAODhk4OGIHBw0xMVYeHjUmJkMiIjwWFiYBAQIhITo3N2A3N2EhITpDQ3YqKkoHBwwDAwY0NFsvL1IPDxs6OmUPDxsWFiY8PGkXFyklJUECAgMSEh8bGy8vL1MjIz0vL1IiIjskJD8sLE0rK0spKUdAQHAwMFQuLlEkJD8wMFQNDRcbGzA+PmwyMlcYGCo9PWo6OmYrK0xCQnMnJ0UJCQ8FBQkICA4MDBUoKEYjIz4pKUe95vmCAAAAAWJLR0QR4rU9ugAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAHnSURBVHja7dXXU5NBGMXh/SKIxoI/BAvYUAxGJSCWRI2iYMEA9qhgRVBA7IgVFbH39g+7SdYYR++cb2ecOc/Nd/a9yHmT2STGiIiIiIiIiIiIiIiIiIiIyH8piEwrK/fWNr1ixszorNlz5hbrK+dhVc33019dQ8GChYXBosVuEK310V+3BJYuW76iHlZG8pNV0LA61rgmztp1HhZYDxWBfTYloDk3aIENrbmwETaF3795C8kgn5rqSW21z22ktucH6R3sDH+BNtjl4m5oNybWQYMb7Nm7L/wF9kOniwcgY0wGusKv/SXS3d3j4kE4ZMxhqDXBkczRYz7XyDme5YS9DfYuNp48lfsW9lZ77e87DWcKn8NZ9zvAOX/1sfNR13fBFvdfHCgfvBQn2+ep/vLQMIwM5XMzpK7k0yhc9dN/7bp91zduFg63IOHmSXsdPNQHt8fgTtnP4zjcdfEe3PewwAMYHg2Kx4cw6OIjmAi//zEkn5Scn8Kki89gKvT+dA3P06WDnjFeuFgFL0NfYAJe/T55TarwFzBlr0bo/baO8UTRGzt528/Iu/cm9qGDeEv4C/RSqi436rIh+zFlfw8qw+83n/5cwLR9zh++tHvo/7vWzq/fvg8E//5CIiIiIiIiIiIiImL9ALI2Rl/L/z9XAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/27', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABQVBMVEVERHc/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHAZGSwAAAAbGzAyMlcGBgoICA42Nl43N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2crK0wdHTIVFSQrK0sVFSRERHdDQ3VDQ3YSEh8VFSU8PGkAAAASEh8BAQE+Pm0oKEYGBgo+Pm0wMFQqKkkgIDgyMlg7O2gDAwUvL1I0NFsnJ0QxMVYRER4aGi0xMVVBQXEZGSs8PGkpKUcDAwY5OWMBAQIODhhBQXEiIjw4OGIHBw0xMVYiIjtBQXImJkM9PWsnJ0VDQ3YqKkoHBwwDAwYbGzBCQnQ6OmUPDxsWFiY8PGklJUECAgM2Nl5AQHAzM1ksLE1CQnQNDRcaGi0BAQEyMlcODhkYGCobGy89PWo4OGIeHjUODhkvL1IFBQkTEyE/P27Ei9PvAAAAAWJLR0QLH9fEwAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAFqSURBVHja7dZXU8JQFATgiILoKgoWRMAAKmJHbKDYELGBHRv2rv//BwhjJgn44IjD8WW/F+7dO5M9YSATRSEiIiIiIiIiIiIiIiIiIiL6UZ2lvsFqa7Q3lTbNMGuR6G91aG1t7f8ygNMFdHR2dbuBHo+i9Hp1PsAvMEAfYFGLnwEv4DMfBEPoV2vfPzCI8FdNwI2hiOlkGCOjAl/AGDCuLSeASeMgOoWYQH/xPjGtLWeAWT0PzmFeol/xxOMJbbkALOp5EkuR6q5YteUVrOo/ujUHUsL962lgQ99l4Ej84WK/t5myAlv6dtuFHcn63WwO2MsawT7SB4L9h0fFp+7xiRFErMjI1av5UyB0Zo7yQFRugAyQi5U9c1UbQnL9SSB8Xh5dAJdi/QUHrgoV2TVu5P6DfuC2IlJzuBPrV+6BB+MV4LEUPQHPcgO8lL0BOUuRHXiVG+Dt+wDvwIfcAERERERERERERERUc5/RBiR8xx2fLgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/28', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABtlBMVEVERHdCQnM3N2EyMlg9PWpERHc/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHA1NV0PDxsAAAAAAAAEBAchITlBQXEyMlcGBgoICA42Nl4kJD8HBw08PGkDAwURER0oKEYuLlAjIz4MDBUFBQg7O2czM1kFBQkpKUc7O2gVFSUQEBxDQ3UVFSRDQ3UdHTIVFSQRER0BAQI2Nl8yMlc8PGkSEh8BAQE+Pm1DQ3YDAwYzM1owMFQqKkkgIDgyMlg9PWoaGi4bGy8oKEY0NFsnJ0QxMVZCQnMPDxoxMVYiIjwxMVUZGSs8PGkWFicuLlFCQnQODhgBAQI5OWMODhg+PmwKChEbGzAzM1ktLU44OGIHBw0TEyJBQXImJkMpKUgMDBU3N2AqKkoHBwwDAwYiIjsLCxMtLU8dHTMBAQE6OmUWFiY1NVwlJUECAgMSEh82Nl4XFyk5OWQWFic5OWMvL1IFBQknJ0QpKUdAQHAKChINDRcTEyE9PWs2Nl8rK0soKEYICA5DQ3YYGCobGy8JCRAsLE0ODhk5OWQGBgsJCQ8gIDg+PmwuLlBAQHA1NV0qKkkwMFQ7O2dNxYHWAAAAAWJLR0QSe7xsAAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAHuSURBVHja7dbnV9NQGMfxayVQQQv9OrAIgrRWHEVRW1Fx4ECGUOvGhdSFiopb3HvP/9ikSaVHfXtzjsff502e5+bF72mTm8QYERERERERERERERERERER+SfNisyuckJLq66JzqmtmzsvVl6ob4gD8xcsDCd/USO+xQl/oSnoWdIcRn6kBZa2ti1rh2TKW1geJ72iI1a/ElatDmGANVDjXe5MJ6z1FtbRtd47Ou4EG+znb4yT9W+3TDu5TcZ0bybrn9oCTfYH2Ao9QbkNthuzA3b6fTP02h9gF+wOyj2w15i+HPv8vh8G7A+QGhws77Yh2O8ehmHEa/MHKKTsDzDjYBeHvLvh8BFyR0eOtdZROB5m/ugJ6C9V1Sf9x0BLIsT4UwO1cLpUOmeSwYNo7GxY8d3jRTg37jfn4cLFjlji0gTJ0XDyLze4P/dK8Ny9CtFMqXJ3aDSMeGfyGly/UW6n4GZQ3oLbIQzg/uXFOzPv3jHulpt70GY//z5kH1T00xQrTtnfiPlGHuYrFx7B46DshSfWB3j6+yvvGUz5VaTA8xfWB3gJrzp/qXLfBa9hOOWYvp40vLGeb95SKeKuvHvvFskP3lfZR/v5Jv3HAObT0ESpmf4cQv7fffn6bfL7D/vXX0REREREREREROT/8BMRdEUIoav4NwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/29', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABqlBMVEVERHc9PWs1NVw0NFs7O2hERHc/P28lJUAQEBwGBgsCAgMKChEUFCMlJUFAQHAtLU8NDRYAAAAKChEnJ0VDQ3YyMlcGBgoICA42Nl5DQ3UZGSsVFSRDQ3U3N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2cfHzYHBwwsLE08PGk+PmwvL1ILCxMVFSQdHTI6OmUBAQEJCQ9BQXIQEBwBAQI7O2g8PGkAAAASEh8+Pm0hITk5OWQBAQEiIjwwMFQqKkkgIDgyMlhCQnMMDBUoKEY0NFsnJ0QxMVYLCxQHBw0XFygxMVVBQXEZGSsTEyEPDxs5OWMBAQIODhg0NFs2Nl84OGIxMVYvL1MPDxpCQnRDQ3YWFiczM1pBQXIiIjwmJkMPDxoxMVU+PmwODhkqKkoDAwY9PWo6OmUWFiY8PGk/P28dHTMDAwUYGCobGy8lJUECAgMSEh82Nl5CQnQ1NV0vL1MzM1k/P25CQnMiIjsvL1IJCRApKUdAQHBBQXEaGi4NDRc1NVwmJkIhITorK0syMlcFBQkKChI9PWoTEyI9PWsmJkIFBQkcHDGHElAWAAAAAWJLR0QR4rU9ugAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAHsSURBVHja7dbXVxNBFMfxsYQIWPJVRNEgagwIUQhIKBawC0ZUrBgrRbCBJdjBLlj/Z2ezG4xHfdw5R8/v87L33nm4d9vsGiMiIiIiIiIiIiIiIiIiIiL/pEWLlyyNOOtWFl1WXlG5fMXKII+simGtXlPlpv/aanzr1hfymg1Bzsa4i/61m6Bu85atCdiW9Ar10LC9sSm1A+pdDLATot7tjjfbU7bHljStZd5C2y7aM+H37+iky3/c4gnS3cbshpS/tGcv+8IfoAd6g3A/HDCmjvTBoHCIWPgDHIYjQXgUjhnTR39x7TjtNaEPkMxmTwThADQac/Jn11OQDP8SLDg9yJlI4SU46xe67ftxzl3/8/1wwR4vwtAlr5C7bLeCK67aX71WAde9qOoGxIZHRoZHcTdAbqwBbo75yXhlcWcccHULJuzTxq3bxfTO3Xs2H5xsmoIWB+0j9x/Aw0elpfz04ydPvU0y/czBAM/t3v/ij9/eBC8d9J+BrtmS/FUmE+yEE/A6/P75at7kSwtv4Z0fvYee8Af4AB9/KeTmmG/zgk9z9OXCH2ASppoXjJvC5/DzF3sl7NuYDb+/GaVUra3Eh6CztdxmXx30N99+G8DMfu/04nkX5/8XHanozLS7v2IRERERERERERGR/9wPZSNGNegRa+AAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/30', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABtlBMVEVERHdBQXI3N2A1NV0/P28/P281NVwxMVU5OWNDQ3ZCQnMjIz0ICA4AAAAGBgokJD9CQnM7O2gWFiYBAQIHBw0oKEYPDxoJCQ88PGk2Nl8EBAcZGStDQ3YcHDENDRcvL1MyMlgPDxsQEBxERHdBQXIICA4hITk8PGlBQXEyMlcLCxQnJ0U/P24CAgMNDRdDQ3UNDRY/P24GBgsFBQhBQXEyMlgtLU4rK0wsLE0KChIFBQglJUEtLU4nJ0U7O2c2Nl4hITo5OWQYGCo6OmUXFyguLlAbGzAnJ0QKChEKChIhITk2Nl8UFCMBAQFCQnQ+Pm0YGCodHTIbGy89PWsqKkoDAwYkJD8XFylAQHAeHjQ6OmYCAgQcHDEVFSUiIjs3N2E+Pmw0NFswMFQRER4aGi0eHjUmJkMgIDgaGi0BAQFCQnQ3N2EVFSQ5OWM7O2cwMFQODhgEBAcSEh8bGy83N2AAAAAUFCMODhkODhkpKUcjIz0vL1IfHzYQEBwDAwU+Pm09PWsHBwwdHTMuLlAHBw0ICA4oKEYvL1IPDxsTEyEGBgoQEBwzM1kxMVYbGzA5OWQlJUA9PWr5uE8tAAAAAWJLR0QN9rRh9QAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAIHSURBVHja7dbnUxNRFMbhjUYkgZ8BKwLWJMIKIQhCUIgIKqCCPShWbCD2FsWOvbf/2Huzm2H86Di7Mzrv8yHn7Psh9+zO3Zs4joiIiIiIiIiIiIiIiIiIiPwLIgsWRn8LFlUsroyFtXq8qhpjSaKmnNQuXWaC5SvCGSGyEt+qOi9ZXe8HDY1hDLAG1q6LRtdvgI1JG6TSsKmp2d0MLSGs35qhLW6bbDtU2iYBCVu3dNC5NfgBuqDb63LQY0pyG9uzpaAX+oIfIA87vK4fdpoyAINesAt2Bz/AnqGhiNf1wbApPd6DsEbYG/wA8wZhwJR9sN9PRhk7EM7aydRB9xActv0RqPXjBjgazgDH7FtfGC8dPMfhhB9PwMkQBzh1unS7Z6B8Ap6Fc+EMMHn+QstFqLbP/hL4u9K57J8MIZny3rppaPKTK1AX4gDJdmauOs4wXPOT69Ac9Kox171R7s3+v+k43XDLD26TDv6273C33N8rHYr3YcK7bi3yIPABnId0Zv12lkyNeSYdjHjX5kx8FPwAj6HX657AqK1PwbU19oznL4IfYK6eTJXZaqmpAsV+m0wWeGm2YfwVTAe/vuO8njGH0Ju35qP4zkvem/bDx0/wOZxfgoo27w/Y7Jdy8jVtr8e+Rf7ma//E99yPvPszOR80duXHcyH9DomIiIiIiIiIiIj8/34BPF5CU38XALgAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/31', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABLFBMVEVERHdBQXI3N2A1NV0/P29DQ3VBQXFCQnMjIz0ICA4AAAAGBgokJD9CQnMgIDgoKEYPDxoJCQ88PGlDQ3YICA4cHDENDRcvL1MyMlgPDxsQEBxERHciIjs/P24CAgMNDRcNDRY5OWM+PmwwMFQVFSQyMlgtLU4rK0wsLE0ICA4nJ0U7O2c2Nl4hIToEBAcuLlAbGzAtLU4nJ0RDQ3UzM1kYGCo5OWQ0NFtBQXI+Pm0yMlcYGCodHTIqKkoDAwYkJD9DQ3YCAgQcHDE9PWs+PmwnJ0URER47O2gmJkMXFygBAQFCQnQ5OWMbGy87O2cEBAcSEh8bGy8ODhkFBQgODhkjIz0lJUEvL1IUFCM9PWsEBAcAAAAuLlAHBw0oKEY1NVwzM1k5OWQlJUA9PWpQ2ZorAAAAAWJLR0QKaND0VgAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAFSSURBVHja7dZZT8JAFAXgoqzHfV+qBUVFERVXsCrgjrgrrrj7//+DHesUTXwzuY3J+V7m5D60p5l0WsMgIiIiIiIiIiIiIiIiIiKi/yDQ0Bj8OQmFQ2J3j0RjcDQ1t3wbtqJN7Onb8aWj0xt2dcsV6AF6+4LB/gFg0NTDIYgVGLYQj6gQSgAjKpijyTHIFRgHJtyUAibVOuVuiFSBNDDtpgwwo9ZZ2QJz2WzATfPAgloXHUtyBeqWgRWdc8IFzPyqvQasewPpAhtq0wvFkr8FNre2fSuwk0vu7gGxfb8KfCoDB74WMBOoHIoXKNn2kc7HwIl4AfMUZzqfe4ei5BZc4FL/elRh6V8CwQJXwLWbboBbPRUscHcPKxo2jHy5gFrGhwLGQ8U5hB7VN7j25A1FX8PnuPv9rb7UZ8LnwGvqLW2/m3+/EBERERERERERERH95gPThSIQjq9NagAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/32', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABmFBMVEVERHdBQXI3N2A1NV0/P29CQnMjIz0ICA4AAAAGBgokJD9CQnMlJUAQEBwGBgsCAgMKChEUFCMlJUFAQHAPDxoJCQ88PGkyMlcICA42Nl4cHDENDRcvL1MyMlgPDxtERHc3N2EDAwURER0oKEYuLlAjIz4MDBUFBQg7O2c/P24NDRdDQ3UNDRY5OWMVFSQdHTIVFSQyMlgtLU4rK0wsLE0AAAASEh8BAQE+Pm0nJ0U2Nl4hITowMFQqKkkgIDguLlAbGzAtLU4nJ0QoKEY0NFsxMVYYGCo5OWQxMVVBQXEZGSs8PGlBQXI+Pm0yMlcYGCodHTIBAQIODhgqKkoDAwYkJD9DQ3Y4OGIHBw0xMVYCAgQcHDE9PWsiIjwmJkM+PmwnJ0URER47O2hDQ3YqKkoHBwwXFyg6OmUWFiY8PGlCQnQlJUECAgMSEh85OWMbGy87O2ciIjsvL1IEBAcbGy8pKUdAQHAODhkFBQgODhkjIz0UFCMrK0s9PWsEBAcYGCo9PWoHBw0ICA41NVwzM1kFBQk5OWQlJUCnPogtAAAAAWJLR0QIht6VegAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAHYSURBVHja7dZpV9NAFMbxqRb4V8EoKi6IQUFECqJiW0FUBBRUjBviXjdwqTuiiCsu4Nd20qQKHyDj8fj8XnRubl48N3MyOTVGRERERERERERERERERERE/gWpFSvTfy+9qroGK7NqdaWTrq1b461dV7/ezdNvILaxIepsysSNzVtcDLAVGrel003boc4PG807YGdL66422N2efP4ej46qsMh2QldY7IXacJJsN+xLfoD9cCCqeuCgXRpy5Ms7YbJtFA4lPkAvxPvcB4ft0g9H4ntHoSnxAY4NDKSi6jgM2mUIhuN7g3Ai8QH+OAkjdmkfHT0Vd07DGTfZ/tjZ4BycX97tusBF380Al8JTP355YlnzylW45iY/GuD6jZtLWqlbHhQd5Zvbw/137kLNvUrj/uSU3ZJJV/mRIjyIy4f2s8ijx27zjd9JoVQunjyFZ31uUieC4HmlfgEvw/UVTE07ev2N/5p8pZ6JPopvIP/WUbw1y7tsXM7h2b8EpQyNJXf55j3UR9U0fLDLRwgc5ptPn/Gq7bd3rDhOLnzxvsBM92/zyU/QWrBH7us3+5MbCq9nWarZwR5874iy5n6ULxecD2DMYs/P3mDe1cETERERERERERER+e/8AjRTOd+BhDKtAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/33', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABDlBMVEVERHdBQXI3N2A1NV0/P29CQnMjIz0ICA4AAAAGBgokJD9CQnMPDxoJCQ88PGkcHDENDRcvL1MyMlgPDxsQEBxERHc/P24CAgMNDRdDQ3UNDRY5OWMyMlgtLU4rK0wsLE0nJ0U7O2c2Nl4hITouLlAbGzAtLU4nJ0QYGCo5OWRBQXI+Pm0yMlcYGCodHTIqKkoDAwYkJD9DQ3YCAgQcHDE9PWs+Pmw0NFswMFQnJ0URER47O2gmJkMXFygBAQFCQnQ5OWMbGy87O2cEBAcSEh8bGy8ODhkFBQgODhkjIz0lJUEvL1IUFCM9PWsEBAdBQXEAAAAuLlAHBw0ICA4oKEY1NVwzM1k5OWQlJUA9PWq3GBqNAAAAAWJLR0QIht6VegAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfK/xch6gAAAEsSURBVHja7dZHTwJRGIXhQUGPYteRomLFgqiIXbH3jl3//x8RMrLyzmzMR2LyPovJybuau5ib8TwAAAAAAAAAAAAAAPAfxFpa49HBUqKtXTUdncmwYHz6Lv3o7nEHY71SX388PjAoDfnOYGs4pXSiPjJZacQVjI1KY8HKSeOuYGxCmgzWlDTtCsZm8vlYsGalOVdomnlpITrY8QuLxSVpOTwYW6l/9aXVcnhoxgusrW+EB2ObW9s7u1L7Xmhohoq0Hx2M+VkdHEYGC+Vi8aixj6WT38H62Kc6a+zz+h34K1i70GXmZ14plXQEY9fSTbBupTtXMHb/oFTbo+cVKiVVp1zB2tNB7c55fqk9qq/uYO0tHfyAXb2HBXMfuc+J4pcfEQAAAAAAAAAAf/AND+srgRIBeFQAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDDwvfJMAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAwgeBK8AAAAABJRU5ErkJggg=='],

['0/34', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABSlBMVEVERHdBQXI3N2A1NV0/P29CQnRBQXFCQnRCQnMjIz0ICA4AAAAGBgokJD9CQnNBQXEKChElJUEPDxoJCQ88PGkZGSwcHDENDRcvL1MyMlgPDxsQEBxERHcsLE0/P24CAgMNDRdDQ3UNDRY5OWM7O2cDAwYyMlgtLU4rK0wsLE0ODhkICA4nJ0U2Nl4hITofHzcFBQgwMFQuLlAbGzAtLU4nJ0QyMlcuLlE3N2EYGCo5OWQ+Pm0GBgtBQXIyMlcYGCodHTJDQ3YTEyILCxMqKkokJD8mJkI3N2ECAgQcHDE9PWs2Nl8BAQI+Pmw0NFswMFQnJ0URER47O2gUFCMmJkMXFygBAQEbGy82Nl45OWMbGy87O2c5OWQEBAcSEh8ODhkjIz0lJUEvL1I9PWsEBAcAAAAuLlAHBw0ICA4oKEY1NVwzM1klJUA9PWo63CbyAAAAAWJLR0QLH9fEwAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAGHSURBVHja7dZXTwJBFAXgQUHQY+9lFUVQRFAULIigqNg7KPaO3f//KssCQvTNeInJ+R42dw4JezY7TFCKiIiIiIiIiIiIiIiIiIiI/gNTRaX5W2ipssrc3VZdg4zauvqSuKERTTJP34ycltbivA1CBdqBjk6zuasb6NG+4l4IFeizo9+mDwMOYLAQO11SBYaAYWNyAyP51OrBqFABL+A0Jh8wlk/H4Z8QKjAZCJiMKQhM5cJpYGZWahMWhIA5YwrPI6BEC2iRcHQBWDRWsSUsR2QLrOjHgCseM1arsK+pMhRY39jMLra2s3tBtMDO7t7+AVBzqLJHcEKTLpCVBI6UfgTPh1VZCmgOHFuUE0gFdXEgFAye/PVdY9HoaX4+A87VBUoE/vyxL3GVn1P6oShdQF3DP5AbPbAX/SWQ2gM3wK0x3QGJog+kCtw/wF5dpVQk6ULaV4YC6vE486qfnjOX9EtxLvczfO039pvnrSSWPAcu3O/e6If2+y8iIiIiIiIiIiIiop98AkvhLOQUzTUNAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/35', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA/FBMVEVERHdERHcJCRAAAAABAQE+Pmw1NVwnJ0QdHTIPDxpDQ3UGBgoHBwwPDxs7O2cxMVUfHzYnJ0QjIz4YGCo3N2E9PWsAAAALCxRBQXIDAwUMDBURER04OGIsLE0lJUAoKEYgIDgUFCM8PGkJCQ8/P24BAQIRER41NVwoKEYqKkkoKEYdHTIQEBwCAgNAQHA+Pm0GBgpDQ3U7O2gXFygSEh8xMVYaGi0EBAdCQnMPDxovL1IuLlEfHzcqKkkWFidDQ3YHBw0BAQI/P28/P29AQHAzM1oVFSQTEyIrK0sbGy8qKkoTEyFCQnQEBAcCAgRBQXEBAQEvL1IXFyknJ0XNN48kAAAAAWJLR0QDEQxM8gAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAEMSURBVHja7dXHUgJREEbhO57BHAHBhIoKigqYsyIYMYf3fxeZUmrmBbhdVv3fpm+v+tRsxjkRERERERERERERERERERH5F4I+CFOGAf10DBgGDEYBQ3b3h0cYHYNxs4AJmJyCtFlABrLTOfJW92dmmQvcPCwYBRRg0bklWDYKKJJbcS4VshqY3F8rUY5mGdZNAjagEs1N2DIJ2KZai2Y9ZGfX4P4e7P++DuDQICBNwpH/+0E+GXB84j0gC6dnfzr/g3PvARdw2X1X4Mr3/cY1zVZ3uSlRvfUccAf38fYAj54D2lCItyd49nv/5ZW393htNfmoew34hK/kXoRvv59ARERERERERERERHruB3pLEkHV5j/PAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/36', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAflBMVEVERHcZGSwAAABBQXEgIDgmJkNCQnQ5OWQCAgQLCxMYGCo2Nl4WFidCQnMhITknJ0UnJ0QiIjsVFSUbGzAzM1kBAQI6OmYeHjQlJUEyMlgbGzA7O2cXFyksLE0zM1k+Pm0mJkIVFSQhIToaGi1DQ3UDAwUNDRcYGCowMFRERHdXi2OvAAAAAWJLR0QCZgt8ZAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAACkSURBVHja7dZXDsIwEEVRM7TQTCih19D3v0EcgUDwj18k7tnAXFmjkZ0DAAAAAAAAAAAAAABlV7EP1b8MqNXfGoqAZvShBBBQtoCnpNXuSAMK3Z4iwPcL6WAYCkaKgNcOjDOziTLATc1m0oC52UIasDRbqV/ASwPCDqyVAZvMkq0g4PEh2fl9uAN57Plfl/BwFAaczpfrLfp8AAAAAAAAAMDP3QFdXwWyIbyxnQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/37', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAwFBMVEVERHcZGSwAAAACAgQMDBUVFSUvL1JERHcSEh8/P28gIDgmJkMlJUEWFiYBAQEXFyg5OWQ5OWMEBAcxMVYpKUghITo5OWQVFSUpKUcpKUcHBw1BQXEhITknJ0UmJkMWFicBAQEGBgs3N2EDAwY2Nl8eHjRDQ3Y+Pm0yMlgODhgZGStCQnQLCxM1NV0tLU4hITkYGCo1NV0eHjUhIToqKkozM1kCAgM9PWsmJkIVFSQaGi1DQ3UDAwUNDRcYGCowMFTPYvx2AAAAAWJLR0QCZgt8ZAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAADdSURBVHja7dZJUgJBFEXR4iGCNFpiA0rRI/bS2IKC+9+VKcGkFkA9BveMcvZvZGT8yCgCAAAAAAAAAAAAAAD7Lqet/EHhsOgM+Fc6sgSUK0G1XDuWTrK/gxAQb4+ndenMGRCdSxfWgEup4Q7IWQOa0pUzIDzC65YjIGkHnaTbU3+Q+fzUIhqOsp+f3oS9m7EjIN4cird399KDLyB4fJKenQHRizSxBsTS1Bowk+bWgFfpzRnw/qHhpyFg8yGpfCWLsAk6Wc9PLyItv40BP6v1r+NXCgAAAAAAAADYsT+HYQtt041EpQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/38', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACABAMAAAAxEHz4AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAGFBMVEVERHcZGSwAAABBQXEgIDgmJkNCQnQ5OWTALKZNAAAAAWJLR0QCZgt8ZAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAA9SURBVGje7dDBDQARAABBNSgBiYpc/6VcKIEHYaaAfWwIAAAAwGtiGvLGQGndNx+oqw8EBAQEjgkAAMAdfqIwCHP0hi5HAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/39', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAq1BMVEVERHcbGzACAgM6OmU9PWoCAgQRER1ERHcfHzYAAAApKUg/P24CAgMFBQhBQXIWFicpKUcvL1MLCxMUFCMnJ0VCQnQFBQkyMlcWFicdHTIlJUELCxNAQHBCQnM0NFstLU8DAwYmJkIJCQ8ODhgZGSsODhkYGCoEBAdCQnMtLU4/P28+PmxBQXI1NVw9PWoXFygdHTJDQ3UGBgoxMVYvL1NDQ3YpKUc/P24fHzeo2j3PAAAAAWJLR0QJ8dml7AAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAADWSURBVHja7dfbTsJAGEXhguWwqSAIQmmtyPlQlYMivP+ToSTwBmSHZH03nbt/JZ1MZoIAAAAAAAAAAAAAAADciULxwRsQlsoVb0FVNW9A9FhveAue1PQGtPTs2QVtqfP/femqZw0IYvW9AYlSS8BrFGXnxZsUWgouMmlgDQjeNfQGjFT1Bow18QZMNfMG2H/BXIl1/kJaOuau8vzjvPiUvhwB16N4aDqKrwFrbawB252+LQEXP0r31oBYv9b5B/el9Gi+lv89TLw7wP40AwAAAAAAAG7mBC13Cew97xkyAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/40', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAApVBMVEVERHczM1oAAAAkJD9CQnMKChEHBwxBQXIgIDgpKUc8PGkBAQIHBwxDQ3UfHzcgIDhBQXIFBQg5OWMUFCMnJ0UpKUcNDRcUFCNCQnQDAwUvL1JAQHA/P240NFs+PmwkJD8cHDENDRYWFiYSEh8PDxsXFygQEBwXFygWFicSEh8dHTIGBgs/P289PWsuLlENDRYEBAc4OGIBAQEgIDgoKEYKChEzM1lTd/p4AAAAAWJLR0QCZgt8ZAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAADXSURBVHja7dfbTsJAGEXhYVtBQEpBQY7lfFAU5Pj+jwYaGp6A7JCs72Yu/9VMM+2EAAAAAAAAAAAAAAAAHklOT9b50XO+YA14UdE6v1R+rVgDYlWt85Oa6pbBb9L739pQ0/PkWcCHaweuAa22Op6Abq8XXZa+lHoCrgbKW+eHoUbegLEm3oCpZt6AuRbegKU+vQFf7pdwoJVp8neaJuH/IPrxBNyO4rU14PIxir0BDW08AZnkV1tvQezag0xpZ/4pDXsdvAHR0XwxCSfz1QwAAAAAAAC4izNo5wiHu1PlLgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['0/41', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACABAMAAAAxEHz4AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAIVBMVEVERHcAAAAODhgUFCMnJ0VAQHA/P25CQnM/P28+PmxBQXJcCh8rAAAAAWJLR0QB/wIt3gAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAABMSURBVGje7dOxDYAgFEVRjCGhdQNHYRpq1qFzVOMMFPDjOQPc5uWlBAAAAPzRcQusDZxXjR7IrUdfQWCHQBlP9C9MBz4COwQAAJjzApyFB7HvXxH1AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI4OjU3KzAzOjAw8L3yTAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMIHgSvAAAAAASUVORK5CYII='],

['0/42', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABQVBMVEVERHc2Nl8hITkPDxoHBw0CAgMFBQkLCxQZGSstLU5BQXI5OWQUFCMAAAAHBwwqKklERHcwMFQDAwYAAAAQEBweHjQkJD8gIDgXFygEBAdCQnQzM1kBAQEWFic7O2gmJkMXFyk+Pm0GBgskJD84OGIGBgspKUgfHzYaGi00NFtCQnMnJ0VAQHADAwZAQHApKUcuLlEdHTM3N2EdHTIxMVUHBwxDQ3U/P25CQnMTEyEVFSQ8PGkNDRdDQ3YbGy83N2ALCxMCAgQeHjUzM1oQEBxCQnQZGSw6OmUWFic5OWMRER1AQHAlJUEoKEYCAgMKChE3N2EPDxorK0sfHzcODhkKChIvL1M9PWoZGSs/P28+PmxBQXIaGi0JCQ8RER0aGi4yMlg5OWQlJUA2Nl4JCRBBQXEpKUgjIz4mJkIsLE07O2cRJs1aAAAAAWJLR0QN9rRh9QAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAFqSURBVHja7dbpNkJRHAXwE0rSzlXGRCQkZYzMc6ZIZgoh8/s/gOuGOh7g32Lt34e67S97r7vqdJUiIiIiIiIiIiIiIiIiIiKiP8VWU1tnd9Q7G1xVqW9045unyZDvb/YCvpbWtvaOTnOC0y/d3xUAunusS3/QnNArfA/6QkD/T2d4ABiUHTAERCo+DvsQiso0m9+8EaViXsRHK+MIMCY5YByY0OJJwC05YApIaLExjfiMyIBYMjmr1ByQ1PN5YEHmFlgWEVjSk2VgRXDAKtZ+JevAhuCATSClJ1vAtuCAHWBXT/aAtOCAfeBAC6IZHBqCA7LAkRYcAyeC/co41Q+C2TMgKzlAnQPTF+U95o/wUqj5KpfLf75fAzfhryxv/hM4pI6h0lGslOsWCBTu0ob//sEDeG1C/T8DVKpgPY1lrNfDolR/eYBSRbe99Ej4GKzOU6lST4nnl9e3d6NK9URERERERERERET/0gfhsyP0op0mowAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyODo1NyswMzowMPC98kwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6Mjg6NTcrMDM6MDCB4ErwAAAAAElFTkSuQmCC'],

['1/1', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAOVBMVEUiIjwhITsgIDkQEBwAAAAUFCQiIjsEBAcRER4iIjwfHzYYGCoKChIEBAcCAgQhITsZGS0aGi7////lSpHVAAAAAWJLR0QSe7xsAAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAABZSURBVHja7c6HDYAwEACxBELv+y9L2QG9EPYCdykBAAAAAAAAAN+Qqxw7UJcmtN92wQN9CRwYxmkukQNLecQNrNED22WPHLgdBgwYMGDAwO8HAAAAAAB40Qkd8QLJJbvoCwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/2', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA81BMVEUiIjwgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkZGSwDAwUAAAAEBAcbGzAcHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQKChIiIjwhITsODhkKChIeHjUAAAAJCRAAAAAfHzcYGCoVFSUQEBwZGSwUFCMaGi4TEyIZGSwYGCsgIDkMDBYeHjUcHDIBAQEHBwwcHDEEBAcZGSshITkRER4TEyIiIjsVFSUDAwYCAgMdHTMICA4LCxMeHjUTEyEBAQIJCRAbGy8RER4XFykUFCQgIDghIToHBwwVFSYZGSwMDBUNDRgeHjUHBw0DAwX////Dz3kIAAAAAWJLR0RQ425MvAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAADtSURBVHja7dTHUsIAFEbhiGLjKDZEQMVesHewd+y+/9vIKKPuXJm7Od8md3f+zGSSJJIkSZIkSZIkSZIkSX/qyHR2Zbt7evuC+v05vgwMhvTzQzA8MjpWgPFixIAJyJRaz3IFJgP6U9NUS59XucDMbPoD5mC+fS7AYvoDlmC5fa7AavoDirXaWvtch430B/zY3GK7FNjf2YW9uPz+QRYOw/JH9QYc18P6J6etH/HZeVS+dHEJV9dhr5/cQOM28PO/g+p9XD5p5nhoBvaTR3iK7CfP8FL59pr+gDd+y6c/4D16gCRJkiRJkiTp330A7NUSrqAE5JwAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/3', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABEVBMVEUiIjwhITkbGzAbGy8gIDghIToRER8EBAcAAAADAwUSEiAhIToHBw0EBAgeHjUODhkHBwwYGCoZGSwICA4ICA4iIjwfHzgBAQEHBwwhITsGBgscHDIZGSwWFigWFiYWFicUFCMdHTQbGy8RER0XFygODhgWFicTEyIMDBUdHTIhITofHzcZGSwMDBUODhkVFSUCAgMSEiAiIjwBAQIODhkfHzYfHzcaGi4YGCoUFCMJCQ8eHjQTEyILCxQAAAAhITocHDINDRgdHTQCAgQJCRANDRgHBw0CAgQHBwwRER8TEyEXFykKChEfHzYCAgMgIDkAAAAXFygEBAYEBAcUFCMaGi4ZGS0dHTMSEiAeHjX///8EZwZlAAAAAWJLR0RaA7ulogAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAEaSURBVHja7dbXUgJBFIThQQltjkhQEVEMuCpiVgSzmDHr+7+ISy3oG+wpy/+7mOq77rmZGucAAAAAAAAAAAAAAMBfEOnqjtq1x+IJ+Xp6+4xu36+2gUGTAUPS8Eg0OjomjScN+idSSsdaIZOVJg0GTEnTQcpJMwYD8tJskArSnMGA+WIxEqQFadFgwK8ladmqO1la8ValNbPLr7eegfJGxXbA5ta22YCd3b39AylxaLagpSodmQ5IZlWrh95a8bzjTj6RTsO/9pnOO/ni51EM06WuMu3YUMrgS3At3QTpVroLv9/dPygVf3SuVC2rWTAY4J5q/iP0/OIfzVeLfufe0sGPrPFu0+/7yH3mvS+L/xgAAAAAAAAA/AvfYR0VwUeDoTEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/4', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAflBMVEUiIjwhITogIDkhITsgIDkFBQkAAAATEyENDRYWFicdHTQCAgMHBwwEBAcQEBwCAgQYGCoZGSwXFykcHDEfHzcDAwUODhgiIjwKChEFBQohIToTEyEBAQEcHDEbGzABAQETEyIKChEiIjwNDRgWFicSEiAMDBUbGzAdHTP///8J7xpwAAAAAWJLR0QpyreFJAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAACYSURBVHja7dRZEsEAFETRR2gRM0nMYohh/yvEjyoLoEu5ZwN9vzoCAAAAAAAAAAAAAAD8ikYzse632upYA1J5A7ryBmQ9b0DS18AaMNRo7AyYSNOZMSAvVIYxYL7QcuUMWGuzDWPArtI+jAGPCz4cnQGpijyMAZl0qp/O0qWur18PuOlN+X8BL84nJIAAAAAAAAAAAMBn3QE4rwfEfl01RQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/5', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABAlBMVEUiIjwHBw0AAAAYGCsDAwUgIDgICA8ODhkcHDIbGzAYGCoWFicdHTMRER8AAAEhITsNDRYFBQgICA4KChEbGzALCxQFBQkBAQIDAwUJCREVFSUhITsCAgQGBgseHjQgIDkCAgMPDxsWFiYUFCQODhkCAgQFBQggIDgbGzAEBAgcHDIfHzYICA4PDxogIDgZGS0fHzgeHjUBAQIBAQIhIToNDRcaGi4TEyEWFicWFiYXFykZGSwRER4aGi0JCRABAQIiIjwhIToXFygNDRcgIDkEBAYPDxofHzcBAQECAgQEBAcCAgMdHTQLCxMAAAAKChEdHTIfHzcWFigSEiAeHjX////4Ilx3AAAAAWJLR0RVkwS4MwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAEESURBVHja7dXXUsJgFEXh3y2gELGiYkWxgFgQLFGxoYIV+/s/i0EwXjqjMzkzzvquzlX2ukniHAAAAAAAAAAAAAAAwE96FOo1CYgZB8SlRF9Xv0VAUkpZ7IY8acA0IK3BIdOAYY2Y7rtRjWXGJyazU9MzNgFZzXZfwrl5i/1csLywmF9aXpFWCwYBRWmt1D7WN6RNg4Ctcnm7c1Wq2tk1KPi2J+2bBvjSgWnAoeRFv3rk1b7OY+kk+oBTncU713lC1Xr0AX748l1Il9Hvu6uG1Lx2rpC+0W3FIMAl21/iuyBD97W/P+03HlqPn7+Cp2eb/cDLq/+WfzebBwAAAAAAAID/7gMcMhEcDcty5QAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/6', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABKVBMVEUiIjwiIjwdHTQZGSwbGy8gIDkVFSQFBQoAAAAJCREdHTMhITsLCxMBAQEaGi4NDRcKChEaGi8hITkdHTQQEB0AAAEEBAcgIDgbGy8LCxQiIjwSEiAUFCMLCxMAAAAfHzYhIToCAgQJCRABAQIcHDIbGy8bGzAZGSwVFSYTEyIdHTMZGS0eHjYODhkWFicFBQgHBw0ZGSwMDBYPDxsTEyILCxMBAQERER0bGzAcHDERER0BAQEcHDEKChIaGi4XFykICA0MDBUJCRANDRgYGCoRER8XFykSEiAWFicVFSYYGCoXFykSEiAYGCsgIDkBAQIODhgfHzcMDBUJCRAdHTQCAgMWFiYhIToUFCMEBAgYGCoEBAcGBgsZGSwaGi4UFCQSEh8UFCT////HLZceAAAAAWJLR0RiK7kdPAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAEtSURBVHja7dXHUgJRFIThi4o2BkQURdQxYFbMIog555yz7/8SDjBVvsGc0vq/Ve+6FzPnOgcAAAAAAAAAAAAAAP6CSE1tXdSwvr5BvlijUX9Ts6pa4jYDWqVEW7K9I6XOLov+tNSdKYceqddiQJ+8/koYGNSQQX8yq0QQh0dGDQaMSeMGtb8mpLiLTI5NTRsNyEntM7Plv3Bu3mTAgrQY3AEtWQxY9ovzK4VocTWl0prBgHXJ26ikTWnLYMC2lAvijv85hD9gV9oL4r50EP6AQ6kYxCPpOPwBJ9JpEM+k8/AHXFzqKogx6Tr8Ae5GXvUJOJduDfrdXV73D48u+ZRVKm0xwI37p6j07Pn3oN6k37mX18ohfns36ncu8/H59V2ImPUDAAAAAAAAwD/3A0XFGGmV49uoAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/7', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAllBMVEUiIjwNDRYAAAAODhgWFiYODhkKChIVFSYiIjwJCRALCxMiIjwUFCMDAwUfHzceHjQBAQMXFykJCQ8NDRcUFCQCAgMfHzcgIDkDAwURER4RER4gIDkfHzYBAQIUFCMODhgEBAchITsBAQETEyEFBQkZGS0WFicNDRcAAAEDAwYHBwwcHDIPDxsTEyEXFykJCRAfHzf////OYyuYAAAAAWJLR0Qx2dsdcgAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAClSURBVHja7dNHEoIAEERRbBOIihERc87h/qdzp67caS/87wK/a6omCAAAAAAAAAAAAAAAAD4r6F3xDweUyk8Vqfr7AS9hpFrsHFBXo+nsJy21nf2wo66zH/TUT539Qaah9QC5spGzP55oaj3ATPOFs58ulVsPsJISZz9eK7IeYCNtrQN22lt/MD7oaD3ASTpbB1ykq3XATbpbBwAAAAAAAAAAvusBvTcFx6EDucIAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/8', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABOFBMVEUiIjwhITocHDEZGSweHjUiIjwbGy8ICA4AAAAAAAACAgMQEB0gIDkSEiAEBAYeHjUZGS0DAwUUFCQeHjQgIDkLCxMICA4hITsICA8BAQEbGzAZGSwiIjsCAgMJCRAaGi0eHjYNDRcNDRghIToAAAAHBw0ZGSsRER4LCxQXFykhIToHBwwBAQEdHTQfHzcFBQgODhgZGS0UFCMFBQkWFiggIDgKChEBAQIbGzAVFSQCAgQGBgsbGzARER4FBQoXFygPDxoAAAEcHDEaGi4ICA4hITsYGCoMDBUdHTMLCxQcHDIDAwQTEyIXFygFBQkDAwYUFCQJCREfHzYbGzAUFCQEBAciIjwFBQgVFSUWFicdHTIDAwUEBAgQEBwfHzYMDBYXFyggIDgbGy8VFSUTEyEYGCodHTT///8vC06sAAAAAWJLR0RnW9PpswAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAE4SURBVHja7dbnUsJAHATwEw2yKiKCvRNU0GAvGGzYsAL23sv7P4IJF17h/uO4vy+333ZnMrlEKSIiIiIiIiIiIiIiIiIiIvoLGkKNTZZcfbg5AqCltU2oP4pAe0ykvyOCeGciGe4CunskBvSir98/LW/BgED/4BCGdRoBogIDRoExnWJASmCAnca4ThPApMAAlQGy/jk1DScnMWBmFum57PzCIpwliX6lllf0NbCal+m31tzgIiqsiwzYADa3Esn8dhHujkD/LrC3X0sHXhIYUAIOg3gEHJsfUMBJ/UN8CpyZH1BGpR6rgMCLeA5cBDEFXJofcAWUdAo5uL4xP8C+BTI5S9l3ceDefL9SD4/eHeQ++X9lzxL9Sr28FmsXYflNpt/z/vH59f0j8PyJiIiIiIiIiIiI/odfTLkb84DaT3AAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/9', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABKVBMVEUiIjwfHzYaGi8aGi4eHjQiIjwXFygGBgsAAAAFBQgUFCMiIjwhITsMDBYKChIhITsPDxsDAwYWFiceHjUfHzYXFykFBQodHTMAAAAEBAggIDghIToICA4BAQEeHjQQEB0dHTIAAAERER4ICA8hIToGBgsGBgoEBAcLCxQJCRAICA4dHTQaGi4fHzcBAQIbGzAYGCoHBw0hITsiIjsLCxQaGi0HBw0YGCsfHzcHBw0eHjUFBQkEBAcMDBYgIDgPDxoBAQMBAQEMDBUNDRghITobGy8YGCoZGS0fHzgKChIhIToGBgoFBQggIDkdHTMNDRcaGi4TEyERER0YGCoDAwQFBQkeHjYKChEfHzYYGCsAAAADAwYTEyEgIDgODhkeHjUSEiAUFCT///8o9kUOAAAAAWJLR0RiK7kdPAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAE3SURBVHja7dbnUsJQFATgY8GsgoJKJIjEjr1gVLBiw94FC/b3fwlvTBzfIGd09vu1/3ZJ5t4gQkRERERERERERERERERERH9BU3NLa0ytPdZmwWjviOv0JzoR6kqqDEgB3T29absPSGn0Zxxk+/2QG0DeVRgwCNhBGhrGiMKAUThjYRyHpTCggImfOIl8IvoBU7+t08BM9APMIZgN0tw8sBD9gEWguOQHb9lcBSvRD4ivAlapXC6tQWeArG+EF+HmlsorENmu7Jj63b30PpDRGCByUD08OhY5gXOqMyB0hnOF1gvXDW/CS+BKYcA1cBOkW+BOYYBXQz3nh/saCp7CAP9z+PBonoQ5jU8a/ZIsAo3sszmJLyr9Iq9vDf8equv8/m/v9sdnVe9fMREREREREREREdF/9wWX8RqiquUsowAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/10', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABNVBMVEUiIjwhITsgIDkgIDgaGi4YGCscHDIiIjwQEBwAAAAUFCQeHjQLCxMBAQEEBAcUFCMiIjsEBAcbGzACAgMMDBYRER4hIToQEB0eHjUZGSwGBgoUFCMiIjwfHzYYGCoKChISEiAfHzcDAwUCAgQgIDkEBAcFBQkCAgQTEyEWFicCAgQdHTIMDBUdHTMLCxQhITsZGS0WFicFBQgFBQkaGi4QEB0bGzAKChEAAAEhITsNDRgfHzYMDBUgIDgPDxodHTMLCxMcHDENDRchITkPDxsQEBwNDRceHjUTEyIcHDEWFigYGCsHBwwbGzAfHzgAAAAKChIUFCQPDxsICA4BAQIfHzcfHzcCAgMDAwYhIToPDxoXFykICA0JCREDAwUICA4ZGSsODhgZGSwUFCMSEiAWFib///+oa69PAAAAAWJLR0RmLNTZJQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAFUSURBVHja7dXXUsJgFEXhiHVZwY4Vsffeu9gb9t7L+7+CwSSA184cRmd/N8C+IGsymT+OIyIiIiIiIiIiIiIiIiIiIn9DXigv8yO/oLCo2DighNLga1l5BVBZZZoQjqQDqmvw1IYNA+oIAuoj0NAYijZBs9HFW1rb2kkHxCCW+uyI09llE9Dt3XEvoKWHXu9x7IN+m4CB7IBBGPLmYRixCRh1jQUB4zDu7xNM2gSkTAUB0zDjb7PMzdsHLECZv9XCon3AEiz72wqs2gesQXACumfDun3ABiT8bROK7AO2oNHftmHHPmAX9vzNPR5D9gH7cOBvh0TMrp8JOIIVbzpOcpKDgOI4E97knomnOQhwziD6XXLOxWUuAq6uuXEfw9s72LK7flaAcw/Jh8cneLZ7E/wIcF4iqbfz3GviN3/4K+G3949Pu/eQiIiIiIiIiIiIyL/3Bba4IHlwe+ZPAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/11', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAOVBMVEUiIjwhITsgIDkQEBwAAAAUFCQiIjsEBAcRER4iIjwfHzYYGCoKChIEBAcCAgQhITsZGS0aGi7////lSpHVAAAAAWJLR0QSe7xsAAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAABySURBVHja7c5LDoJAFERRkEZ+irL/zWJMSLpDGPoM4ZxZjepWFQAAAAAAAABwDvWtPhhBmtQejBj3LvssRpA+ZZ/FCDCM0yNtn8UI8kxf7X4EmfPP+Q8Br4/39lmMQEv+uQgQIECAAAFXDAAAAAAA4IdW1ysFkQuE1vEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/12', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABBVBMVEUiIjwhITsgIDkQEBwAAAAUFCQgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkiIjsEBAcZGSwDAwUbGzARER4cHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQiIjwfHzYYGCoKChIKChIODhkEBAceHjUAAAAJCRAAAAAfHzcCAgQVFSUZGSwhITsZGS0UFCMaGi4TEyIZGSwYGCsMDBYeHjUcHDIBAQEHBwwcHDEEBAcZGSshITkRER4TEyIVFSUDAwYCAgMdHTMICA4LCxMeHjUTEyEBAQIJCRAbGy8XFykUFCQgIDghIToHBwwVFSYZGSwMDBUNDRgeHjUHBw0DAwX///8N8KiwAAAAAWJLR0RWCg3piQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAEqSURBVHja7dXXUsJgFEVhA1tRLCCKDYkgKnZR7A3sFbvv/ypGIRDk2pNxZn03yfw3e00mmXR1AQAAAAAAAAAAAACA/8GJOOEGRNXt3/bEevvi/QODQ5b7iWQzYDiluuSIYcCo/ID0mDQ+MTmVkaazNuPuTC6vZsCsFHO9q1OQ8jYBc/UnXg+YX1DR/blzMlpcMglYDgbkpJXGeVRaNQlY86z7ARtSqXG+KW2ZBHwr+QHZcjnSONuWduwDWnb3tO+GGHBwKB2Z7XcEHJ/EpVO7/V8BiUpVOqsY7rcHnF94X+XlleV+MMC9vpFu70zn2wK830L13u717wh4kIqP1vOBgFpKTzX7/VbAs/QSwn4r4FV6KzS92wd8KChtH/AZUgAAAAAAAAAA4A99AZ8hF9ZE0zJEAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/13', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABL1BMVEUiIjwhITsgIDkhITkbGzAbGy8gIDgQEBwAAAAUFCQhIToRER8EBAcDAwUSEiAhIToiIjsEBAcHBw0EBAgeHjURER4ODhkHBwwYGCoZGSwICA4ICA4iIjwfHzYYGCoKChIfHzgBAQEHBwwGBgscHDIEBAcZGSwWFigWFiYWFicCAgQUFCMdHTQbGy8RER0hITsZGS0XFygODhgWFicTEyIaGi4MDBUdHTIhITofHzcZGSwMDBUODhkVFSUCAgMSEiAiIjwBAQIODhkfHzYfHzcUFCMJCQ8eHjQTEyILCxQAAAAhITocHDINDRgdHTQCAgQJCRANDRgHBw0CAgQHBwwRER8TEyEXFykKChEfHzYCAgMAAAAXFygEBAYUFCMaGi4ZGS0dHTMSEiAeHjX///+AGMPEAAAAAWJLR0Rkwtq4CQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAFUSURBVHja7dbXUsJQFIXhQBSXgL1rRAELilhQFKMCdsSuWLH7/u8g8XAC+gA747i+q7Bv9j9MyjEMIiIiIiIiIiIiIiIiIiIi+ht8fl/9h9nUHJAOaEFr7SoYCqOqrb1Dcn9nlw4wu1HT0ysY0Acd0A8MDAYCQ8PAiCWz3BqNjEEHjEcRCzoXvjgwIRMwqf5xFTAFTKtxApiRCZhtDEgCc2qcAuZlAhaqFnXAUjptqvEysCIT4Mi4N6FrFVjzKsDKrtsbwKbc/l8BW849kcsXvA3Y3tn1LGAvE9k/AMKHXgV8KwJHngZYcZSOxQMKtn2iZ6fAmXiAdY4LPbt0X4qCAcYVrvXJpIyo3JHADbgBbtXoDrgX218PeHhENOQ3jGwxh0rKgwDjqVR9CT07n+jKi9z+xsfwNaY+z+U3wf0/vSc+kvan0HmMiIiIiIiIiIiI6B/4AoJNIJOlhX7GAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/14', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAApVBMVEUiIjwhITsgIDkhITohITsQEBwAAAAUFCQgIDkFBQkTEyEiIjsEBAcNDRYRER4WFiciIjwfHzYYGCoKChIdHTQCAgMEBAcHBwwCAgQQEBwCAgQYGCohITsZGS0ZGSwXFykcHDEaGi4fHzcDAwUODhgiIjwKChEFBQohIToTEyEBAQEcHDEbGzABAQETEyIKChENDRgWFicSEiAMDBUbGzAdHTP////Yxs/3AAAAAWJLR0Q2R7+I0QAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAADNSURBVHja7dTLUsJAEEbhCYZfkUQRoiKKaBK5ewno+7+a0YWV0bU9ReV8u+nNnEVXOwcAAAAAAAAAAAAAAA5D1In8wVEnNg3o6th7n/R0avl/P/kVkMo24Ex+wLkMAwYXw5H8gOzSMuBK3xoB8bUSw4Dxn4AbTW4NA+5q02bAvTR7MF7Cx0ZAXqh0AQOe5losQwastN64gAHbZ724gAH1CX4dhAxIVeQuYEAmvVVfdtK+qt7NAz7kKdsX8CPkJSSgnQEAAAAAAAAAgH/0CWCAD2ZnfTWLAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/15', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABIFBMVEUiIjwhITsgIDkQEBwAAAAUFCQHBw0YGCsiIjsEBAcDAwURER4gIDgICA8ODhkcHDIiIjwfHzYYGCoKChIbGzAYGCoEBAcWFicdHTMCAgQRER8AAAEhITshITsZGS0NDRYFBQgaGi4ICA4KChEbGzALCxQFBQkBAQIDAwUJCREVFSUGBgseHjQgIDkCAgMPDxsWFiYUFCQODhkCAgQFBQggIDgbGzAEBAgcHDIfHzYICA4PDxogIDgfHzgeHjUBAQIBAQIhIToNDRcaGi4TEyEWFicWFiYXFykZGSwaGi0JCRABAQIhIToXFygNDRcEBAYPDxofHzcBAQECAgQEBAcCAgMdHTQLCxMAAAAKChEdHTIfHzcWFigSEiAeHjX////lGbOUAAAAAWJLR0Rfc9FRLQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAE1SURBVHja7dXXUsJAGIbhgJ8dFBVFUbErdizYBVRU7L2X+78MA4QgpzqzOzrvc7SzB/nfJJON4wAAAAAAAAAAAAAAgL8hEAzYDahTvbdqkK/R3PymZj+gxUpAqyoBISnc5mk3MzzS0dklPyAqdZu78ZKe8vP2AmJSr+GAvpqAuPoHDAcMuhJ+wJCGDc8vGfEDRjU2PjE5lZyeMXowVAOS8l6JZudsBMy7kxcWU0vLK9Jq2kLAmrS+UVxsbknbFgJ2Eond8lYmq9ye+YBv9qUDqwF56dBqwJEUMx9wHCtU9twf1In5gFOdhcpbkbCy5+YD8v7HdyFdGptfDQheSdc3jpOO3+ouYyHAiRZP4ns3Qw+F313zhwHO49Nz6Vfw8mpwfq239/xH6tPaeAAAAAAAAAD4d74Ah/0ZlcEP+TsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/16', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABQVBMVEUiIjwhITsgIDkiIjwdHTQZGSwbGy8gIDkQEBwAAAAUFCQVFSQFBQoJCREdHTMiIjsEBAchITsLCxMBAQEaGi4RER4NDRcKChEaGi8hITkdHTQQEB0AAAEEBAcgIDgfHzYYGCoKChIbGy8LCxQiIjwSEiAUFCMLCxMAAAAfHzYhIToCAgQJCRACAgQBAQIcHDIbGy8bGzAhITsZGS0ZGSwVFSYaGi4TEyIdHTMeHjYODhkWFicFBQgHBw0ZGSwMDBYPDxsTEyILCxMBAQERER0bGzAcHDERER0BAQEcHDEaGi4XFykICA0MDBUJCRANDRgYGCoRER8XFykSEiAWFicVFSYYGCoXFykSEiAYGCsBAQIODhgfHzcMDBUJCRAdHTQCAgMWFiYhIToUFCMEBAgEBAcGBgsZGSwSEh8UFCT////PgPssAAAAAWJLR0RqJWKVDgAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAFgSURBVHja7dXXUsJQFIXhQFRcIFYUQVBE1NiwUFTsIoi9F+y9vP8LGOAQ4QV2Rmd9Vyf7Zv+TMAdNIyIiIiIiIiIiIiIiIiIior/B4XT8PugNjU0u4YBmuK31nhaYvK2S+9varYCOTlR0+QQDumEF9AD+3kCwL4Rwv8xyfSAyCCsgCgzFSodhYEQmIFx54ypgFMZY+TA+gUmZgKnagEAcfjWfnpmVCZgzJaoBSSAls7ZeuhowD/g0fSGZWLQpIAMEl5ZLn2Rl1ZaANWBd3QPYsCNg01yc3cq58tshFHZsCDBvBGO3fNoD9m0IOAAyanZo/hzkA46AYzU7AU7lA86AvJqdAxfyAZfAlZpdA0X5AOcNbtXMC9zJB2j3MCp/AUXgQWx/TcBjFk/PL1rgNY5Q1I4ALWVeRYU3w7wPPHL7awO0yHv5Iv74FNxfL5Z2f33ndNv2ExEREREREREREf03P3ptI5Tj4u/lAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/17', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAulBMVEUiIjwhITsgIDkQEBwAAAAUFCQNDRYODhgiIjsEBAcRER4WFiYODhkKChIVFSYiIjwfHzYYGCoiIjwJCRALCxMEBAcUFCMDAwUfHzcCAgQeHjQBAQMXFykhITsZGS0JCQ8NDRcaGi4UFCQCAgMfHzcgIDkDAwURER4fHzYBAQIUFCMODhgEBAchITsBAQETEyEFBQkZGS0WFicNDRcAAAEDAwYHBwwcHDIPDxsTEyEXFykJCRAfHzf///8x7KWEAAAAAWJLR0Q90G1RWQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAADkSURBVHja7dPZTgJREEXRBo8CjdgITuDMJIgzo+D/f5dIJ0Lf8GpVTPZ6uY9np5IbRQAAAAAAAAAAAAAA4H/I5XO+AXva/3kOtK1gt18sOQfESgPKh78q0pHNeFI9Xo2lARu1uk4Sm4DT9N5BwJnOL2z2o8augOalroz2o+uVmyCgdqs7q/21+yCgpXbHM6Db04PpfhgQq5f3DOgP9Gi7HwQM9fTsGdB5UWy8nw14lZqeAcmb6tb7mYB36cM1YKSx8R/MBiQTTc33twNm0tw14FNauAYspS/7AAAAAAAAAADAH/oGulsMcMSWHQoAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/18', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABR1BMVEUiIjwhITsgIDkhITocHDEZGSweHjUiIjwQEBwAAAAUFCQbGy8ICA4AAAACAgMQEB0iIjsEBAcSEiAEBAYeHjURER4ZGS0DAwUUFCQeHjQgIDkLCxMICA4hITsfHzYYGCoKChIICA8BAQEbGzAZGSwEBAcCAgMJCRAaGi0CAgQeHjYNDRcNDRghIToAAAAHBw0ZGSsRER4aGi4LCxQXFykhIToHBwwBAQEdHTQfHzcFBQgODhgZGS0UFCMFBQkWFiggIDgKChEBAQIbGzAVFSQCAgQGBgsbGzAFBQoXFygPDxoAAAEcHDEaGi4ICA4MDBUdHTMLCxQcHDIDAwQTEyIXFygFBQkDAwYUFCQJCREfHzYbGzAiIjwFBQgVFSUWFicdHTIDAwUEBAgQEBwMDBYXFyggIDgbGy8VFSUTEyEYGCodHTT////QJYPMAAAAAWJLR0RszAEwOwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAFsSURBVHja7dZpWwFxFMZhpKaHlCSi0KYVLRTti2hRadW+7/X93zfM0vQFjquu535jnDfndzH+w2YjIiIiIiIiIiIiIiIiIiKiv8HusP+8aXA2NinCAc1wGZfuFg+A1jaH5H5vuxngg67DLxjQCSMg4EGwKxR2dwM9EZnlSjTWCzOgD/0DtalaMCgTENc+cS3AO4RhbTwC+GQCRq0BY8C4NvYDCZmAiCpgBCRTmNDGk8CUTEDVtHkPpIFM9XVmFtlcPQLm5pFayCwuLSO7IrffEmBbXdPuifW84H5LgLJR0A+i4mZdAtQjaWs7FM7vlFDYrUPAHrCvPZZi6lUdAsrAgT47BI7kA4o4Nh7EJ8CpfEAFZ8bsHJD7IZoBF8ClPksAV/IBLqCsjZxZxK/lA5I3QDqn2JK3QeBObL/lHLh/UM+gwmP1X9mT3H7rURx9LtUOwsqL4P7fXt/ePz6/5L5/IiIiIiIiIiIiov/uG+89JSzpe2SwAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/19', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABQVBMVEUiIjwhITsgIDkfHzYaGi8aGi4eHjQiIjwQEBwAAAAUFCQXFygGBgsFBQgUFCMiIjwiIjsEBAchITsMDBYKChIRER4PDxsDAwYWFiceHjUfHzYXFykFBQoYGCodHTMAAAAEBAggIDghIToICA4BAQEeHjQEBAcQEB0dHTIAAAERER4CAgQICA8hIToGBgsZGS0GBgoEBAcLCxQaGi4JCRAICA4dHTQaGi4fHzcBAQIbGzAYGCoHBw0hITsLCxQaGi0HBw0YGCsfHzcHBw0eHjUFBQkMDBYgIDgPDxoBAQMBAQEMDBUNDRghITobGy8YGCoZGS0fHzgKChIhIToGBgoFBQggIDkdHTMNDRcaGi4TEyERER0DAwQFBQkeHjYKChEfHzYYGCsAAAADAwYTEyEgIDgODhkeHjUSEiAUFCT///9jMOEfAAAAAWJLR0RqJWKVDgAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAFtSURBVHja7dZXU8JAGIXhjQ2PogREVJAigr1gb1jA3rB3sGD//3/AzSQZGO8cZ3ZH5zxXy17wvQlsQAgiIiIiIiIiIiIiIiIiIiL6G4wao/Kitq6+waM4oBFNzsrT7IXU0upTOd/0uwGBNjiCxu/e80fa4QaEgI7OrnCkGwgpGu4JR4NwA2JxJHqsRbIXqbSagD77jtsB/UDE3h4YxJCagOHqgBHER539MXjVBASkcTcggwl3fxKpgJoCacoNmK5MnQFm1QfIQzBnb80vAIvqA5aA7LK1MFfk92JVfYBvDfDm8vncOvQEiI1N50Ho39LyEQixvbMrx+/thw+AmI4AIQ4LR8cnQpwifqYnwHGOC2XzKwGX6bTzJLwCrjUE3AC39tYdENUQYBZRSlqL+yIypoYA6+fw4VHeCXkan9TNrwowskA58SxP4ovC+dWn4PWtbD2HSiqv/5v3yMdnQfW/YiIiIiIiIiIiIqJ/7AvQyySkRgGQGgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/20', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABsFBMVEUiIjwgIDgaGi4YGCscHDIiIjwgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkeHjQLCxMBAQEAAAAEBAcUFCMZGSwDAwUEBAcbGzAbGzACAgMMDBYiIjscHDEBAQIICA8XFygSEh8GBgoCAgQdHTQhIToQEB0eHjUgIDkZGSwGBgoUFCMKChIiIjwhITsODhkKChISEiAfHzcDAwUCAgQgIDkeHjUAAAAJCRAAAAAfHzcFBQkWFicYGCoVFSUQEBwZGSwdHTIMDBUdHTMLCxQUFCMaGi4TEyIZGSwWFicFBQgFBQkeHjUQEB0bGzAKChEAAAEhITsHBwwNDRgfHzYcHDEZGSsMDBUgIDgPDxodHTMhITkRER4TEyILCxMRER4VFSUDAwYCAgMNDRcPDxsdHTMICA4QEBwNDRcTEyEBAQIJCRAbGy8cHDEXFykWFigYGCsHBwwUFCQgIDgbGzAfHzghIToHBwwUFCQVFSYPDxsICA4MDBUNDRgeHjUfHzcDAwYhIToPDxoHBw0XFykICA0JCREDAwUICA4DAwUODhgZGSwUFCMSEiAWFib///+Njs/sAAAAAWJLR0SP9QKD+QAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAHfSURBVHja7dXnUxNRFMbhq0lEEQR+IFEJKEUJ6gYQJYhdQQUbNhRjASzYu9h7L/g3u5u9iXH8JM7eGZ33+XLPeT/sOTPZ3DVGRERERERERERERERERERE/klz5sbiCWfT5pXNX1C+sKJyUSGoqq4BauscrbC4nlBySRgsXWaDhpSL+Y1NsLxuRXMLtLYFwcokrGpPd6yGNS4WWAtlnn9mOqErCLqhOzjX9bB+Q/Tze7P0efkq08LGfmO8TbRm8kElbI5+gS2w1ZbbYLsxO2Bn2O+CgegXGITdttwDe40ZgiEbDLMv+gXaYrG0LRtgvzEH4KANDjFyOPoNiuI1HPHfhqNQ9XOjY+7mH6+FUf88ASdtNAanXI3PnS6HM0F1Fgo34DlodDM+NT4Bk+P5+jzkbHwB4k7mX7zk37vV7WEzBbYyl6HXwXjvylW4dr3Q+n/GG7bsgvQsH/on/F964qZXbG/BbVveIelg/l3ou1fS34exsHqQpSL6+dP1PJwuDRI9DIeVfyc+in6Bx9Dxa/LEJomnNPVHv8AzeN5Z9MJPXk7yyn8NX7+Bqejnm7eUyt877yD7/sNH+OTiS/D59wXMaDKoR77k/vLZs5f6+m3mu8PvkIiIiIiIiIiIiMj/7QevXkB2tw5czAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/21', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABBVBMVEUiIjwhITsgIDkgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkQEBwAAAAUFCQZGSwDAwUEBAcbGzAiIjscHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQRER4KChIiIjwODhkKChIfHzYYGCoeHjUAAAAJCRAAAAAfHzcEBAcVFSUZGSwCAgQUFCMaGi4TEyIZGSwhITsZGS0YGCsMDBYeHjUcHDIBAQEHBwwcHDEEBAcZGSshITkRER4TEyIVFSUDAwYCAgMdHTMICA4LCxMeHjUTEyEBAQIJCRAbGy8XFykUFCQgIDghIToHBwwVFSYZGSwMDBUNDRgeHjUHBw0DAwX///+fgwkTAAAAAWJLR0RWCg3piQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLGI4EgsAAAEkSURBVHja7dTXUsJQGEVhgigWtoJgQzQgih0L9gb2it33fxWjhBjk2p9xZn0352TfZM1QIhEAAAAAAAAAAAAAAPA/OVHH7mVdse6eeG9f/0BoS2jQ7P1DSTWkhoMtnbILyIxIo2PjE1lpMtccp2QXMC3FXO908lLha3BnigXZBczOqeR+35ys5he8c7HxgVgFFKUl/5qQlr1jxTZgVSr71zVp3Ts2PJt2AblKJepft6Rt/1o2/BIGdna153YwYP9AOmw+2AccHcelk+DROiBdrUmn1Z/BOODs3PvZXVyGFtMA9+paurlt2UwDvP/92p3bulkG3Eulh9+jYUA9qcd622oY8CQ9t6+GAS/Saz7wZh/wrrCMfcBHpwMAAAAAAAAAAH/uE//QHLgMGzi0AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/22', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA81BMVEUiIjwgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkZGSwDAwUAAAAEBAcbGzAcHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQKChIiIjwhITsODhkKChIeHjUAAAAJCRAAAAAfHzcYGCoVFSUQEBwZGSwUFCMaGi4TEyIZGSwYGCsgIDkMDBYeHjUcHDIBAQEHBwwcHDEEBAcZGSshITkRER4TEyIiIjsVFSUDAwYCAgMdHTMICA4LCxMeHjUTEyEBAQIJCRAbGy8RER4XFykUFCQgIDghIToHBwwVFSYZGSwMDBUNDRgeHjUHBw0DAwX////Dz3kIAAAAAWJLR0RQ425MvAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAD8SURBVHja7dTHUkJBFEVRRBGVo5gQG1TMAXMGE2bM/P/fSOkry7Ka6+gy2mvSp/ake9SpFAAAAAAAAAAAAAAAwL960r19mf7swGDH4Gsop2/DIx2Cr/yoNDY+MVmQporR4GxaSof2WSpLM9Hga3ZOlfC1SgXNL0SCs0VpKZnL0kokOFuV1pK5Lm1EgrNitbqZzC1pOxK6ZmdXe8EMvvYPpEMzuDo6zkgnVnB1WqtLZzUj+Dq/aP+7l1dGcBUa19LNrRGc3Un1+2AFXw9S5dEMvpo5PTXN4OxZerGDs1fprfzjPRKcfei3fCQ4a/29r9XlBwAAAAAAAAAA3H0CW60lWy0ianAAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/23', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABm1BMVEUiIjwhITkbGzAbGy8gIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkhIToRER8EBAcAAAADAwUSEiAhIToZGSwEBAcbGzAHBw0EBAgeHjUcHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQODhkHBwwYGCoZGSwICA4iIjwKChIhITsODhkKChIfHzgHBwwGBgscHDIAAAAJCRAAAAAfHzcZGSwWFigWFiYWFicYGCoVFSUQEBwUFCMbGy8RER0UFCMaGi4TEyIZGSwXFygODhgWFicYGCsgIDkMDBYeHjUMDBUdHTIBAQEHBwwhITofHzcZGSwMDBUODhkcHDEEBAcZGSsVFSUCAgMSEiAiIjwRER4TEyIBAQIODhkfHzYiIjsVFSUDAwYfHzcUFCMJCQ8eHjQdHTMLCxMeHjULCxQTEyEBAQIJCRAhIToRER4XFykcHDINDRgdHTQUFCQgIDgCAgQNDRgHBw0CAgQHBwwVFSYRER8KChEMDBUeHjUfHzYCAgMEBAYEBAcDAwUaGi4ZGS0dHTMSEiD////BMW4mAAAAAWJLR0SIa2YWWgAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAHYSURBVHja7dZZUxNBFIbhjgYcReCNO6iIETEGBZKoiBJZxR3HFTEu4L4hriAuuOvfduJMQlCqvLC6qyy/5yJzTvfFdzo11TXGiIiIiIiIiIiIiIiIiIiIyD8ptmRp3F1avKp6mbd8Rc3KqK+tqyeQWLXaTf6aBKG168LTr496NjS4yG/cCJs2N21phq3J4sI2aNkej7fugOqUgwF2QlUxJ90Gu4Lnbo/22uJGugM67ec3ZMiG50w3k9tjzF7YF251wX77A3TDgag8CK3G9EAy7PNwyP4AvdAXlf0wYMzg0FAs7A9Dv/0BksPDR6LyKByr3DoOJ+wPMK/zJKdKb31q5LR/Bs66zD93Hi6UmovFa2D00pi7+NhlDwrl9ucAV65ecxV/fXwiOPD4/MKNvu6bt6D+tpv8O8Glx917vy4X4L6L+NSDh/Aov8hGB7lJBwM8homp8qU/5vtPSvVTeGY//zlkX1Qc+yXZUj1dvhQtmkzQsuB/nuFVOipn8ex/ErwGf8HCG6gJqyl4az3fvIPptrI5Y95/wKsLbueRwiiZ/N8H/MkMlRqDlaZcUHz8FPxkeu3nm8+/DWC+tIfN7FcH+Yv71vW9x59z8T0mIiIiIiIiIiIi8j/4AamkPnYNY3t6AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/24', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABPlBMVEUiIjwhITogIDkhITsgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkgIDkAAAATEyEZGSwDAwUEBAcbGzANDRYcHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQWFicKChIiIjwhITsODhkKChICAgMeHjUAAAAJCRAAAAAfHzcHBwwYGCoVFSUQEBwZGSwQEBwCAgQYGCoUFCMaGi4TEyIZGSwXFykYGCsMDBYeHjUfHzcDAwUODhgcHDIBAQEHBwwiIjwKChEFBQohITocHDEEBAcZGSsTEyEcHDEhITkRER4TEyIbGzABAQEiIjsVFSUDAwYKChEdHTMICA4LCxMeHjUBAQIJCRAbGy8NDRgWFicSEiAMDBURER4XFykdHTMUFCQgIDgHBwwVFSYZGSwMDBUeHjUHBw0DAwX///+DB/VTAAAAAWJLR0RpvGvEtAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAFaSURBVHja7dRXTwJBFAXgBUTBcug2XF0QxV5RFLD3CnZde/f//wJ32RUh4cHEeInJ+V7mzH3YOclORlGIiIiIiIiIiIiIiIiIiIjov3I4XVJH1bnrGzzexqbm8mGLFz6h8/0BWIKhsmkYUgUirUBbe0dnFOhSS9NuiBXoAdyascbiQO/XUE2IFejrR1IrplgUA4PW0DWEoFSBYWDEjqPAmJXGMTEpVWAKmLZjCpgpBj8wG5EqoKbTTjvOAfPmmskip4gV+LawiCXNWJdXsLpWgwLrG8CmGbbg2VbEC+zseoA9M+0fIKVIFzjMF4BE3ozGE3ykSRc4PjGendOzYg4jm1FkC2i+c+Di0tqowJVuugZudD30u0//zC1QuNPszT0q5ATOfwCSj6WdfAFHAE+OKnOxO/AMvFSbixV4NW5dvORNvsB7xT+PyBf4qHUBIiIiIiIiIiIiIvpzn+PSKAvQ80WxAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/25', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABlVBMVEUiIjwgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkHBw0AAAAYGCsZGSwDAwUEBAcbGzADAwUcHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQgIDgODhkcHDIKChIiIjwhITsKChIbGzAYGCoeHjUAAAAJCRAAAAAfHzcWFicdHTMYGCoVFSUQEBwZGSwRER8AAAEhITsUFCMaGi4TEyIZGSwNDRYFBQggIDkMDBYeHjUICA4KChEbGzALCxQFBQkBAQIJCREVFSUcHDIBAQEHBwwCAgQGBgseHjQcHDEEBAcZGSsCAgMPDxsWFiYUFCQODhkFBQggIDghITkRER4TEyIbGzAEBAgfHzYICA4PDxoiIjsDAwYZGS0fHzgBAQIhIToLCxMeHjUNDRcaGi4TEyEJCRAbGy8TEyEWFicRER4XFykWFiYXFykZGSwaGi0HBwwJCRABAQIhIToVFSYZGSwNDRcMDBUNDRgeHjUEBAYPDxofHzcBAQECAgQHBw0CAgMdHTQKChEdHTIWFigSEiD////4iXd5AAAAAWJLR0SGjN47XQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAG/SURBVHja7dTpT1NBGMXhAQGFX62yiCyVW7ECRRZxRVDB4gYqKC4gshQVrRvuCm6o4P/t3HJtamjCB3OHxJzny7zz3qTntGlrjIiIiIiIiIiIiIiIiIiIiMimioq3lZSWbd9RHtwryIm4yN8ZDdJ27V5fVLotUFUNNXtq99ZBfYO/aLT3WGCfgwJNUOzZMx6D/f6iGQ44yP0jcZAWLzvF62hts2cS2h0WOAQdwdgJXfbo5nCPwwJH4GgwHoPj9jjBSYf5piES6Q3GU9Bnj35Onzk7MBg9l4q7LGLM0Hku+N+GKBeDH+Glyy7zh0fgij3LbfLVa6Nj1+vhxriz+Ju3SuG2P92BiSF/mLwLU47i76Wm7dtOZeeimZnZ9W1ijuq0k/z2fvuxz9/fsH8ADx3EewuD8OhxgScZeOKgwFOYfuYVevIckuHnj0FLY979RXIxr9rL0PPTUV6l8xeveRP08WqYext6gXfw/q9FJvfjq4UPoeebj7AUy1k2pvcTfP5izHj3V74lwi+wQr4qu2n2/4lHbA2+L/7zy2+uckMB82O+NXv5ueogv7C2tcyv0b4tixcRERERERERERH5z/wGSQM3I9tTQOkAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/26', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABv1BMVEUiIjwiIjwdHTQZGSwbGy8gIDkgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkVFSQFBQoAAAAJCREdHTMZGSwDAwUEBAcbGzAhITsLCxMaGi4cHDEBAQIICA8UFCMXFygSEh8GBgoCAgQNDRcKChEaGi8hITkdHTQQEB0AAAEEBAcgIDgKChIhITsODhkKChIbGy8LCxQiIjwSEiAUFCMeHjUAAAAJCRAAAAAfHzcLCxMfHzYhIToCAgQJCRAYGCoVFSUQEBwZGSwBAQIcHDIbGy8bGzAUFCMaGi4TEyIZGSwVFSYYGCsgIDkMDBYeHjUTEyIdHTMZGS0eHjYcHDIBAQEHBwwWFicFBQgHBw0cHDEEBAcZGSsPDxsTEyIRER4LCxMBAQERER0bGzAcHDERER0iIjsVFSUDAwYCAgMaGi4XFykICA0dHTMICA4LCxMeHjUMDBUTEyEBAQIJCRANDRgYGCoRER8XFykRER4SEiAWFicVFSYUFCQgIDgYGCoXFykSEiAYGCsHBwwODhgfHzcZGSwMDBUeHjUdHTQWFiYhIToUFCMEBAgDAwUEBAcGBgsUFCQSEh8UFCT////Zdy9SAAAAAWJLR0SUf2dKFQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAHnSURBVHja7dXXU5NBGMXh/SKIxoI/BAvYUAxGJSCWRI2iYMEA9qhgRVBA7IgVFbH39g+7SdYYR++cb2ecOc/Nd/a9yHmT2STGiIiIiIiIiIiIiIiIiIiIyH8piEwrK/fWNr1ixszorNlz5hbrK+dhVc33019dQ8GChYXBosVuEK310V+3BJYuW76iHlZG8pNV0LA61rgmztp1HhZYDxWBfTYloDk3aIENrbmwETaF3795C8kgn5rqSW21z22ktucH6R3sDH+BNtjl4m5oNybWQYMb7Nm7L/wF9kOniwcgY0wGusKv/SXS3d3j4kE4ZMxhqDXBkczRYz7XyDme5YS9DfYuNp48lfsW9lZ77e87DWcKn8NZ9zvAOX/1sfNR13fBFvdfHCgfvBQn2+ep/vLQMIwM5XMzpK7k0yhc9dN/7bp91zduFg63IOHmSXsdPNQHt8fgTtnP4zjcdfEe3PewwAMYHg2Kx4cw6OIjmAi//zEkn5Scn8Kki89gKvT+dA3P06WDnjFeuFgFL0NfYAJe/T55TarwFzBlr0bo/baO8UTRGzt528/Iu/cm9qGDeEv4C/RSqi436rIh+zFlfw8qw+83n/5cwLR9zh++tHvo/7vWzq/fvg8E//5CIiIiIiIiIiIiImL9ALI2Rl/L/z9XAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/27', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABRFBMVEUiIjwgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkNDRYAAAAODhgZGSwDAwUEBAcbGzAcHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQWFiYODhkKChIVFSYKChIiIjwhITsiIjwJCRALCxMeHjUAAAAJCRAAAAAfHzcUFCMDAwUfHzcYGCoVFSUQEBwZGSweHjQBAQMXFykaGi4TEyIZGSwJCQ8NDRcYGCsgIDkMDBYeHjUUFCQCAgMcHDIBAQEHBwwgIDkRER4cHDEEBAcZGSsRER4hITkTEyIfHzYUFCMiIjsVFSUDAwYCAgMODhghITsdHTMICA4LCxMeHjUTEyEBAQIbGy8gIDgZGS0WFichIToHBwwNDRcAAAEZGSwHBwwMDBUNDRgeHjUcHDIPDxsHBw0XFykDAwUJCRAfHzf///8jhAbEAAAAAWJLR0RrUmWlmAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAFqSURBVHja7dZXU8JQFATgiILoKgoWRMAAKmJHbKDYELGBHRv2rv//BwhjJgn44IjD8WW/F+7dO5M9YSATRSEiIiIiIiIiIiIiIiIiIiL6UZ2lvsFqa7Q3lTbNMGuR6G91aG1t7f8ygNMFdHR2dbuBHo+i9Hp1PsAvMEAfYFGLnwEv4DMfBEPoV2vfPzCI8FdNwI2hiOlkGCOjAl/AGDCuLSeASeMgOoWYQH/xPjGtLWeAWT0PzmFeol/xxOMJbbkALOp5EkuR6q5YteUVrOo/ujUHUsL962lgQ99l4Ej84WK/t5myAlv6dtuFHcn63WwO2MsawT7SB4L9h0fFp+7xiRFErMjI1av5UyB0Zo7yQFRugAyQi5U9c1UbQnL9SSB8Xh5dAJdi/QUHrgoV2TVu5P6DfuC2IlJzuBPrV+6BB+MV4LEUPQHPcgO8lL0BOUuRHXiVG+Dt+wDvwIfcAERERERERERERERUc5/RBiR8xx2fLgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/28', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABuVBMVEUiIjwhITocHDEZGSweHjUiIjwgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkbGy8ICA4AAAAAAAACAgMQEB0gIDkZGSwDAwUEBAcbGzASEiAEBAYeHjUBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQZGS0DAwUUFCQeHjQLCxMICA4hITsKChIhITsODhkKChIICA8BAQEbGzAZGSweHjUJCRAAAAAfHzciIjsCAgMaGi0YGCoVFSUQEBwZGSweHjYNDRcNDRgUFCMaGi4TEyIZGSwhIToHBw0ZGSsRER4YGCsMDBYeHjULCxQXFykhIToHBwwBAQEcHDIHBwwfHzcFBQgODhgZGS0WFigcHDEEBAcKChEhITkTEyIVFSQGBgsbGzAVFSUDAwYCAgMRER4FBQoXFygPDxoAAAEdHTMLCxMaGi4TEyEBAQIJCRAbGy8MDBUdHTMLCxQcHDIXFykDAwQTEyIUFCQgIDgFBQkHBwwJCREfHzYbGzAVFSYUFCQEBAciIjwMDBUNDRgFBQgWFicHBw0dHTIDAwUEBAgQEBwfHzYXFyggIDgbGy8VFSUYGCodHTT///9UiR4MAAAAAWJLR0SSlgTvIAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAHuSURBVHja7dbnV9NQGMfxayVQQQv9OrAIgrRWHEVRW1Fx4ECGUOvGhdSFiopb3HvP/9ikSaVHfXtzjsff502e5+bF72mTm8QYERERERERERERERERERER+SfNisyuckJLq66JzqmtmzsvVl6ob4gD8xcsDCd/USO+xQl/oSnoWdIcRn6kBZa2ti1rh2TKW1geJ72iI1a/ElatDmGANVDjXe5MJ6z1FtbRtd47Ou4EG+znb4yT9W+3TDu5TcZ0bybrn9oCTfYH2Ao9QbkNthuzA3b6fTP02h9gF+wOyj2w15i+HPv8vh8G7A+QGhws77Yh2O8ehmHEa/MHKKTsDzDjYBeHvLvh8BFyR0eOtdZROB5m/ugJ6C9V1Sf9x0BLIsT4UwO1cLpUOmeSwYNo7GxY8d3jRTg37jfn4cLFjlji0gTJ0XDyLze4P/dK8Ny9CtFMqXJ3aDSMeGfyGly/UW6n4GZQ3oLbIQzg/uXFOzPv3jHulpt70GY//z5kH1T00xQrTtnfiPlGHuYrFx7B46DshSfWB3j6+yvvGUz5VaTA8xfWB3gJrzp/qXLfBa9hOOWYvp40vLGeb95SKeKuvHvvFskP3lfZR/v5Jv3HAObT0ESpmf4cQv7fffn6bfL7D/vXX0REREREREREROT/8BMRdEUIoav4NwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/29', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABrVBMVEUiIjwfHzYaGi8aGi4eHjQiIjwgIDgSEiAICA4DAwYBAQEFBQkKChITEyEgIDkXFygGBgsAAAAFBQgUFCMiIjwZGSwDAwUEBAcbGzAhITsMDBYKChIhITscHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQPDxsDAwYWFiceHjUfHzYXFykFBQoKChIODhkdHTMAAAAEBAghIToICA4BAQEeHjQeHjUAAAAJCRAfHzcQEB0dHTIAAAERER4YGCoVFSUQEBwZGSwhIToGBgsUFCMaGi4TEyIZGSwGBgoEBAcLCxQYGCsgIDkMDBYJCRAICA4cHDIBAQEHBwwaGi4bGzAcHDEZGSsYGCoHBw0hITsiIjsLCxQaGi0hITkRER4TEyIHBw0YGCsfHzcHBw0VFSUCAgMeHjUdHTMLCxMeHjUgIDgPDxoBAQMMDBUNDRgTEyEBAQIJCRAbGy8hITobGy8YGCoZGS0fHzghIToRER4XFykFBQgUFCQgIDggIDkNDRcHBwwaGi4TEyERER0VFSYZGSwDAwQFBQkeHjYKChEfHzYTEyEDAwUODhn///8Kc4xiAAAAAWJLR0SOggWzbwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAHsSURBVHja7dbXVxNBFMfxsYQIWPJVRNEgagwIUQhIKBawC0ZUrBgrRbCBJdjBLlj/Z2ezG4xHfdw5R8/v87L33nm4d9vsGiMiIiIiIiIiIiIiIiIiIiL/pEWLlyyNOOtWFl1WXlG5fMXKII+simGtXlPlpv/aanzr1hfymg1Bzsa4i/61m6Bu85atCdiW9Ar10LC9sSm1A+pdDLATot7tjjfbU7bHljStZd5C2y7aM+H37+iky3/c4gnS3cbshpS/tGcv+8IfoAd6g3A/HDCmjvTBoHCIWPgDHIYjQXgUjhnTR39x7TjtNaEPkMxmTwThADQac/Jn11OQDP8SLDg9yJlI4SU46xe67ftxzl3/8/1wwR4vwtAlr5C7bLeCK67aX71WAde9qOoGxIZHRoZHcTdAbqwBbo75yXhlcWcccHULJuzTxq3bxfTO3Xs2H5xsmoIWB+0j9x/Aw0elpfz04ydPvU0y/czBAM/t3v/ij9/eBC8d9J+BrtmS/FUmE+yEE/A6/P75at7kSwtv4Z0fvYee8Af4AB9/KeTmmG/zgk9z9OXCH2ASppoXjJvC5/DzF3sl7NuYDb+/GaVUra3Eh6CztdxmXx30N99+G8DMfu/04nkX5/8XHanozLS7v2IRERERERERERGR/9wPZSNGNegRa+AAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/30', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABuVBMVEUiIjwhITkbGzAbGy8gIDggIDgaGi4YGCscHDIiIjwhIToRER8EBAcAAAADAwUSEiAhIToeHjQLCxMBAQEEBAcUFCMHBw0EBAgeHjUbGzACAgMMDBYiIjsODhkHBwwYGCoZGSwICA4ICA4iIjwhIToEBAcQEB0eHjUgIDkZGSwGBgoUFCMfHzgBAQEHBwwhITsGBgsfHzcDAwUCAgQgIDkZGSwWFigWFiYWFicFBQkCAgQTEyEWFicUFCMdHTQbGy8RER0dHTIMDBUdHTMLCxQXFygODhgTEyIFBQgFBQkQEB0bGzAKChEAAAEhITsfHzcMDBUODhkNDRgfHzYVFSUCAgMSEiAMDBUgIDgPDxodHTMBAQIODhkLCxMRER4cHDEfHzcaGi4YGCoJCQ8NDRcPDxsTEyIQEBwNDRcAAAAhITocHDEKChIcHDIdHTQYGCsHBwwCAgQJCRANDRgbGzAAAAAKChIHBw0HBwwUFCQRER8XFykPDxsICA4BAQIfHzcfHzYDAwYPDxoXFygEBAYEBAcUFCMXFykICA0JCREDAwUICA4ZGS0ZGSsODhgdHTMSEiAeHjX///80PDLRAAAAAWJLR0SSlgTvIAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAIHSURBVHja7dbnUxNRFMbhjUYkgZ8BKwLWJMIKIQhCUIgIKqCCPShWbCD2FsWOvbf/2Huzm2H86Di7Mzrv8yHn7Psh9+zO3Zs4joiIiIiIiIiIiIiIiIiIiPwLIgsWRn8LFlUsroyFtXq8qhpjSaKmnNQuXWaC5SvCGSGyEt+qOi9ZXe8HDY1hDLAG1q6LRtdvgI1JG6TSsKmp2d0MLSGs35qhLW6bbDtU2iYBCVu3dNC5NfgBuqDb63LQY0pyG9uzpaAX+oIfIA87vK4fdpoyAINesAt2Bz/AnqGhiNf1wbApPd6DsEbYG/wA8wZhwJR9sN9PRhk7EM7aydRB9xActv0RqPXjBjgazgDH7FtfGC8dPMfhhB9PwMkQBzh1unS7Z6B8Ap6Fc+EMMHn+QstFqLbP/hL4u9K57J8MIZny3rppaPKTK1AX4gDJdmauOs4wXPOT69Ac9Kox171R7s3+v+k43XDLD26TDv6273C33N8rHYr3YcK7bi3yIPABnId0Zv12lkyNeSYdjHjX5kx8FPwAj6HX657AqK1PwbU19oznL4IfYK6eTJXZaqmpAsV+m0wWeGm2YfwVTAe/vuO8njGH0Ju35qP4zkvem/bDx0/wOZxfgoo27w/Y7Jdy8jVtr8e+Rf7ma//E99yPvPszOR80duXHcyH9DomIiIiIiIiIiIj8/34BPF5CU38XALgAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/31', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABL1BMVEUiIjwhITkbGzAbGy8gIDghITsgIDkhIToRER8EBAcAAAADAwUSEiAhIToQEBwUFCQHBw0EBAgeHjUiIjsEBAcODhkHBwwYGCoZGSwICA4ICA4iIjwRER4fHzgBAQEHBwwGBgscHDIfHzYYGCoKChIZGSwWFigWFiYWFicEBAcUFCMdHTQbGy8RER0CAgQXFygODhgWFicTEyIhITsZGS0MDBUdHTIaGi4hITofHzcZGSwMDBUODhkVFSUCAgMSEiAiIjwBAQIODhkfHzYfHzcUFCMJCQ8eHjQTEyILCxQAAAAhITocHDINDRgdHTQCAgQJCRANDRgHBw0CAgQHBwwRER8TEyEXFykKChEfHzYCAgMAAAAXFygEBAYUFCMaGi4ZGS0dHTMSEiAeHjX///8jtdVmAAAAAWJLR0Rkwtq4CQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAFSSURBVHja7dZZT8JAFAXgoqzHfV+qBUVFERVXsCrgjrgrrrj7//+DHesUTXwzuY3J+V7m5D60p5l0WsMgIiIiIiIiIiIiIiIiIiKi/yDQ0Bj8OQmFQ2J3j0RjcDQ1t3wbtqJN7Onb8aWj0xt2dcsV6AF6+4LB/gFg0NTDIYgVGLYQj6gQSgAjKpijyTHIFRgHJtyUAibVOuVuiFSBNDDtpgwwo9ZZ2QJz2WzATfPAgloXHUtyBeqWgRWdc8IFzPyqvQasewPpAhtq0wvFkr8FNre2fSuwk0vu7gGxfb8KfCoDB74WMBOoHIoXKNn2kc7HwIl4AfMUZzqfe4ei5BZc4FL/elRh6V8CwQJXwLWbboBbPRUscHcPKxo2jHy5gFrGhwLGQ8U5hB7VN7j25A1FX8PnuPv9rb7UZ8LnwGvqLW2/m3+/EBERERERERERERH95gPThSIQjq9NagAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/32', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABm1BMVEUiIjwhITkbGzAbGy8gIDghIToRER8EBAcAAAADAwUSEiAhIToSEiAICA4DAwYBAQEFBQkKChITEyEgIDkHBw0EBAgeHjUZGSwEBAcbGzAODhkHBwwYGCoZGSwICA4iIjwcHDEBAQIICA8UFCMXFygSEh8GBgoCAgQdHTQfHzgHBwwhITsGBgscHDIKChIODhkKChIZGSwWFigWFiYWFicAAAAJCRAAAAAfHzcUFCMbGy8RER0YGCoVFSUQEBwXFygODhgWFicTEyIUFCMaGi4ZGSwMDBUdHTIYGCsgIDkMDBYeHjUhITofHzcZGSwMDBUODhkBAQEHBwwVFSUCAgMSEiAiIjwcHDEEBAcZGSsBAQIODhkfHzYRER4TEyIfHzcUFCMJCQ8eHjQiIjsVFSUDAwYLCxQdHTMLCxMeHjUhIToTEyEBAQIJCRAcHDINDRgdHTQRER4XFykCAgQNDRgUFCQgIDgHBw0CAgQHBwwRER8KChEVFSYfHzYCAgMMDBUeHjUEBAYEBAcaGi4ZGS0DAwUdHTMSEiD///9qqsshAAAAAWJLR0SIa2YWWgAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAHYSURBVHja7dZpV9NAFMbxqRb4V8EoKi6IQUFECqJiW0FUBBRUjBviXjdwqTuiiCsu4Nd20qQKHyDj8fj8XnRubl48N3MyOTVGRERERERERERERERERERE/gWpFSvTfy+9qroGK7NqdaWTrq1b461dV7/ezdNvILaxIepsysSNzVtcDLAVGrel003boc4PG807YGdL66422N2efP4ej46qsMh2QldY7IXacJJsN+xLfoD9cCCqeuCgXRpy5Ms7YbJtFA4lPkAvxPvcB4ft0g9H4ntHoSnxAY4NDKSi6jgM2mUIhuN7g3Ai8QH+OAkjdmkfHT0Vd07DGTfZ/tjZ4BycX97tusBF380Al8JTP355YlnzylW45iY/GuD6jZtLWqlbHhQd5Zvbw/137kLNvUrj/uSU3ZJJV/mRIjyIy4f2s8ijx27zjd9JoVQunjyFZ31uUieC4HmlfgEvw/UVTE07ev2N/5p8pZ6JPopvIP/WUbw1y7tsXM7h2b8EpQyNJXf55j3UR9U0fLDLRwgc5ptPn/Gq7bd3rDhOLnzxvsBM92/zyU/QWrBH7us3+5MbCq9nWarZwR5874iy5n6ULxecD2DMYs/P3mDe1cETERERERERERER+e/8AjRTOd+BhDKtAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/33', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABEVBMVEUiIjwhITkbGzAbGy8gIDghIToRER8EBAcAAAADAwUSEiAhIToHBw0EBAgeHjUODhkHBwwYGCoZGSwICA4ICA4iIjwfHzgBAQEHBwwhITsGBgscHDIZGSwWFigWFiYWFicUFCMdHTQbGy8RER0XFygODhgWFicTEyIMDBUdHTIhITofHzcZGSwMDBUODhkVFSUCAgMSEiAiIjwBAQIODhkfHzYfHzcaGi4YGCoUFCMJCQ8eHjQTEyILCxQAAAAhITocHDINDRgdHTQCAgQJCRANDRgHBw0CAgQHBwwRER8TEyEXFykKChEfHzYCAgMgIDkAAAAXFygEBAYEBAcUFCMaGi4ZGS0dHTMSEiAeHjX///8EZwZlAAAAAWJLR0RaA7ulogAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAEsSURBVHja7dZHTwJRGIXhQUGPYteRomLFgqiIXbH3jl3//x8RMrLyzmzMR2LyPovJybuau5ib8TwAAAAAAAAAAAAAAPAfxFpa49HBUqKtXTUdncmwYHz6Lv3o7nEHY71SX388PjAoDfnOYGs4pXSiPjJZacQVjI1KY8HKSeOuYGxCmgzWlDTtCsZm8vlYsGalOVdomnlpITrY8QuLxSVpOTwYW6l/9aXVcnhoxgusrW+EB2ObW9s7u1L7Xmhohoq0Hx2M+VkdHEYGC+Vi8aixj6WT38H62Kc6a+zz+h34K1i70GXmZ14plXQEY9fSTbBupTtXMHb/oFTbo+cVKiVVp1zB2tNB7c55fqk9qq/uYO0tHfyAXb2HBXMfuc+J4pcfEQAAAAAAAAAAf/AND+srgRIBeFQAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDAmKxJcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwV3aq4AAAAABJRU5ErkJggg=='],

['1/34', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABTVBMVEUiIjwhITkbGzAbGy8gIDghITogIDkhITshIToRER8EBAcAAAADAwUSEiAhITogIDkFBQkTEyEHBw0EBAgeHjUNDRYODhkHBwwYGCoZGSwICA4ICA4iIjwWFicfHzgBAQEHBwwhITsGBgscHDIdHTQCAgMZGSwWFigWFiYWFicHBwwEBAcUFCMbGy8RER0QEBwCAgQYGCoXFygODhgWFicTEyIZGSwXFykcHDEMDBUdHTIfHzcDAwUhIToZGSwMDBUODhkiIjwKChEFBQoVFSUSEiATEyEcHDEBAQIODhkfHzYbGzABAQEfHzcaGi4YGCoUFCMJCQ8eHjQKChETEyILCxQAAAANDRgbGzAcHDINDRgdHTQdHTMCAgQJCRAHBw0RER8TEyEXFykfHzYCAgMAAAAXFygEBAYEBAcUFCMaGi4ZGS0SEiAeHjX///9qSyGfAAAAAWJLR0RuIg9RFwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAGHSURBVHja7dZXTwJBFAXgQUHQY+9lFUVQRFAULIigqNg7KPaO3f//KssCQvTNeInJ+R42dw4JezY7TFCKiIiIiIiIiIiIiIiIiIiI/gNTRaX5W2ipssrc3VZdg4zauvqSuKERTTJP34ycltbivA1CBdqBjk6zuasb6NG+4l4IFeizo9+mDwMOYLAQO11SBYaAYWNyAyP51OrBqFABL+A0Jh8wlk/H4Z8QKjAZCJiMKQhM5cJpYGZWahMWhIA5YwrPI6BEC2iRcHQBWDRWsSUsR2QLrOjHgCseM1arsK+pMhRY39jMLra2s3tBtMDO7t7+AVBzqLJHcEKTLpCVBI6UfgTPh1VZCmgOHFuUE0gFdXEgFAye/PVdY9HoaX4+A87VBUoE/vyxL3GVn1P6oShdQF3DP5AbPbAX/SWQ2gM3wK0x3QGJog+kCtw/wF5dpVQk6ULaV4YC6vE486qfnjOX9EtxLvczfO039pvnrSSWPAcu3O/e6If2+y8iIiIiIiIiIiIiop98AkvhLOQUzTUNAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/35', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA/1BMVEUiIjwiIjwFBQgAAAAAAAAfHzYaGi8TEyIODhkHBw0hITsDAwUDAwYICA0dHTQYGCsPDxsTEyISEh8MDBUcHDEfHzYAAAAGBgohITkBAQMGBgoICA8cHDEWFicSEiAUFCMQEBwKChIeHjUEBAgfHzcBAQEJCQ8aGi4UFCMVFSUUFCQODhkICA4BAQIgIDgfHzcDAwUhITseHjQLCxQJCRAZGSwNDRcCAgMhIToHBw0XFykXFykQEBwVFSULCxQiIjwEBAcBAQEgIDggIDggIDkaGi0KChIKChEVFSYNDRgVFSUJCREhIToCAgQBAQIgIDkAAAEXFykMDBQUFCP////SjoYDAAAAAWJLR0RU5AOIpQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAEMSURBVHja7dXHUgJREEbhO57BHAHBhIoKigqYsyIYMYf3fxeZUmrmBbhdVv3fpm+v+tRsxjkRERERERERERERERERERH5F4I+CFOGAf10DBgGDEYBQ3b3h0cYHYNxs4AJmJyCtFlABrLTOfJW92dmmQvcPCwYBRRg0bklWDYKKJJbcS4VshqY3F8rUY5mGdZNAjagEs1N2DIJ2KZai2Y9ZGfX4P4e7P++DuDQICBNwpH/+0E+GXB84j0gC6dnfzr/g3PvARdw2X1X4Mr3/cY1zVZ3uSlRvfUccAf38fYAj54D2lCItyd49nv/5ZW393htNfmoew34hK/kXoRvv59ARERERERERERERHruB3pLEkHV5j/PAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/36', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAgVBMVEUiIjwNDRYAAAAgIDkQEBwTEyIhITsdHTMBAQIFBQkMDBUbGzALCxQhIToQEB0UFCMTEyIRER4LCxMODhgZGS0BAQEdHTQPDxoTEyEZGSwODhgdHTQMDBQWFicZGS0fHzcTEyEKChIRER0NDRchITsBAQIHBwwMDBUYGCsiIjz///+ZZXTIAAAAAWJLR0QqU77UngAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAACkSURBVHja7dZXDsIwEEVRM7TQTCih19D3v0EcgUDwj18k7tnAXFmjkZ0DAAAAAAAAAAAAAABlV7EP1b8MqNXfGoqAZvShBBBQtoCnpNXuSAMK3Z4iwPcL6WAYCkaKgNcOjDOziTLATc1m0oC52UIasDRbqV/ASwPCDqyVAZvMkq0g4PEh2fl9uAN57Plfl/BwFAaczpfrLfp8AAAAAAAAAMDP3QFdXwWyIbyxnQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/37', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAw1BMVEUiIjwNDRYAAAABAQIGBgoLCxMXFykiIjwJCRAgIDgQEBwTEyITEyELCxMAAAALCxQdHTMcHDICAgQZGSwVFSQRER0dHTILCxMUFCQUFCQEBAYgIDkQEB0UFCMTEyILCxQAAAEDAwYcHDECAgMbGzAPDxoiIjsfHzcZGSwHBwwMDBYhITsFBQobGy8WFicQEB0MDBUbGy8PDxsRER0VFSUZGS0BAQEfHzYTEyEKChINDRchITsBAQIHBwwMDBUYGCv////BFI8KAAAAAWJLR0RA/tlc2AAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAADdSURBVHja7dZJUgJBFEXR4iGCNFpiA0rRI/bS2IKC+9+VKcGkFkA9BveMcvZvZGT8yCgCAAAAAAAAAAAAAAD7Lqet/EHhsOgM+Fc6sgSUK0G1XDuWTrK/gxAQb4+ndenMGRCdSxfWgEup4Q7IWQOa0pUzIDzC65YjIGkHnaTbU3+Q+fzUIhqOsp+f3oS9m7EjIN4cird399KDLyB4fJKenQHRizSxBsTS1Bowk+bWgFfpzRnw/qHhpyFg8yGpfCWLsAk6Wc9PLyItv40BP6v1r+NXCgAAAAAAAADYsT+HYQtt041EpQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/38', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACABAMAAAAxEHz4AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAG1BMVEUiIjwNDRYAAAAgIDkQEBwTEyIhITsdHTP///+x9RM7AAAAAWJLR0QIht6VegAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAA9SURBVGje7dDBDQARAABBNSgBiYpc/6VcKIEHYaaAfWwIAAAAwGtiGvLGQGndNx+oqw8EBAQEjgkAAMAdfqIwCHP0hi5HAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/39', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAArlBMVEUiIjwODhgBAQIdHTMeHjYBAQIICA8iIjwPDxsAAAAVFSQfHzcBAQECAgQhIToLCxQUFCQYGCoFBQoKChIUFCMhITsDAwQZGSwLCxQODhkTEyEFBQkgIDghIToaGi4XFygCAgMTEyEEBAgHBwwMDBYHBwwMDBUCAgMhIToWFiggIDgfHzYhITkaGi8eHjULCxQODhkhITsDAwUZGSwYGCoiIjwUFCQfHzgQEBz///8ErfYoAAAAAWJLR0Q51wCVQAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAADWSURBVHja7dfbTsJAGEXhguWwqSAIQmmtyPlQlYMivP+ToSTwBmSHZH03nbt/JZ1MZoIAAAAAAAAAAAAAAADciULxwRsQlsoVb0FVNW9A9FhveAue1PQGtPTs2QVtqfP/femqZw0IYvW9AYlSS8BrFGXnxZsUWgouMmlgDQjeNfQGjFT1Bow18QZMNfMG2H/BXIl1/kJaOuau8vzjvPiUvhwB16N4aDqKrwFrbawB252+LQEXP0r31oBYv9b5B/el9Gi+lv89TLw7wP40AwAAAAAAAG7mBC13Cew97xkyAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/40', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAqFBMVEUiIjwaGi0AAAASEiAhIToFBQkDAwYhIToQEBwUFCQeHjUBAQEDAwYhITsQEBwQEBwhITkCAgQcHDIKChIUFCMUFCQHBwwKChEhITsBAQMXFykgIDgfHzcaGi4fHzYSEiAODhkGBgsLCxMJCRAICA4LCxQICA4LCxQLCxQJCRAODhkDAwYgIDgfHzYXFykGBgsCAgQcHDIAAAEQEBwUFCQFBQgZGS3///8AB/vCAAAAAWJLR0Q3MLi4RwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAADXSURBVHja7dfbTsJAGEXhYVtBQEpBQY7lfFAU5Pj+jwYaGp6A7JCs72Yu/9VMM+2EAAAAAAAAAAAAAAAAHklOT9b50XO+YA14UdE6v1R+rVgDYlWt85Oa6pbBb9L739pQ0/PkWcCHaweuAa22Op6Abq8XXZa+lHoCrgbKW+eHoUbegLEm3oCpZt6AuRbegKU+vQFf7pdwoJVp8neaJuH/IPrxBNyO4rU14PIxir0BDW08AZnkV1tvQezag0xpZ/4pDXsdvAHR0XwxCSfz1QwAAAAAAAC4izNo5wiHu1PlLgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

['1/41', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACABAMAAAAxEHz4AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAJFBMVEUiIjwAAAAHBwwKChIUFCMgIDgfHzchITogIDgfHzYhITn///9G+Dn0AAAAAWJLR0QLH9fEwAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAABMSURBVGje7dOxDYAgFEVRjCGhdQNHYRpq1qFzVOMMFPDjOQPc5uWlBAAAAPzRcQusDZxXjR7IrUdfQWCHQBlP9C9MBz4COwQAAJjzApyFB7HvXxH1AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTA4VDE0OjI0OjQ3KzAzOjAwJisSXAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMFd2quAAAAAASUVORK5CYII='],

['1/42', 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABRFBMVEUiIjwbGzAQEB0HBw0EBAcBAQEDAwQGBgoMDBYWFighITodHTIKChIAAAADAwYVFSUiIjwYGCsCAgMAAAAICA4PDxoSEiAQEBwLCxQCAgMhITsZGS0AAAALCxQeHjQTEyIMDBUfHzcDAwUSEiAcHDEDAwYVFSQPDxsNDRcaGi4hIToUFCMgIDgCAgMgIDgUFCQXFykPDxocHDEODhkYGCsDAwYhITsfHzchIToJCRAKChIeHjUHBwwiIjwNDRgbGzAFBQoBAQIPDxsaGi0ICA4hIToNDRYdHTMLCxQcHDIICA8gIDkTEyEUFCMBAQIFBQkcHDEHBw0VFSYQEBwHBw0FBQkYGCoeHjYMDBYgIDgfHzYhITkNDRcEBAgICA8NDRcZGSwdHTMSEiAbGy8FBQggIDkVFSQSEh8TEyEWFicdHTT///+McmxnAAAAAWJLR0RrUmWlmAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB+MJCAwfLRU/Ip0AAAFqSURBVHja7dbpNkJRHAXwE0rSzlXGRCQkZYzMc6ZIZgoh8/s/gOuGOh7g32Lt34e67S97r7vqdJUiIiIiIiIiIiIiIiIiIiKiP8VWU1tnd9Q7G1xVqW9045unyZDvb/YCvpbWtvaOTnOC0y/d3xUAunusS3/QnNArfA/6QkD/T2d4ABiUHTAERCo+DvsQiso0m9+8EaViXsRHK+MIMCY5YByY0OJJwC05YApIaLExjfiMyIBYMjmr1ByQ1PN5YEHmFlgWEVjSk2VgRXDAKtZ+JevAhuCATSClJ1vAtuCAHWBXT/aAtOCAfeBAC6IZHBqCA7LAkRYcAyeC/co41Q+C2TMgKzlAnQPTF+U95o/wUqj5KpfLf75fAzfhryxv/hM4pI6h0lGslOsWCBTu0ob//sEDeG1C/T8DVKpgPY1lrNfDolR/eYBSRbe99Ej4GKzOU6lST4nnl9e3d6NK9URERERERERERET/0gfhsyP0op0mowAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wOS0wOFQxNDoyNDo0NyswMzowMCYrElwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDktMDhUMTQ6MjQ6NDcrMDM6MDBXdqrgAAAAAElFTkSuQmCC'],

    ],
},

]; }",
{"status":false}
],

[
"редактор ресурсов",
"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",
{"status":false}
],

[
"темы.изображения",
"function МР() { return {
0: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABAAAAAMACAYAAAC6uhUNAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4gsOCQ0Z3kO7CQAAAB1pVFh0Q29tbWVudAAAAAAAQ3JlYXRlZCB3aXRoIEdJTVBkLmUHAAAgAElEQVR42uy92XYbObOtGwCyIanGrqq11n7/lzr3+3Kv31bDNjsA5yIiACRF2SLVWC7PbwwN95LMJJOIGRFzmv/v//6/SAAAAAAAAAAAAPhXY/EQAAAAAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAQAAAAAAAAAAAAAAABAAAAAAAAAAAAABAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAAAAAAAAIAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAgAAAAAAAAAAAAAAACAAAAAAAAAAAAACAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAgAAAAAAAAAAAAABAAAAAAAAAAAAABAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAQAAAAAAAAAAAAAAABAAAAAAAAAAAAABAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAgAAAAAAAAAAAAAAACAAAAAAAAAAAAACAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAIAAAAAAAAAAAAAAQAAAAAAAAAAAAAAABAAAAAAAAAAAAABAAAAAAAAAAAAAA8Lmo8BAAAH4bYvzxnxuDxwgAAAAAAAAIAACAT1vI/6iw1z+LMX88V/zrx7EY8NzPAQAAAAAAgAAAAADvVPRrER9C+rWJkSiG+d+NkUyIFI3hP/ee/44xxb+JFK2dF/WuomgMkVFRwOa/YwyRtXPBAAAAAAAAAAgAAADw9kW/CYEL+RDIeP6Rovx+CEQhkon68yBCQCDynov+8vNJAR+tJRMCxaoispZ/JOIfnaPo9PfdXBBw7vTEAAAAAAAAABAAAADgjOK/LPy9Jwqei34/kZkmEQA8F/fekxlH/jshkBknIj/NBQDvuVAXYYBi5MJeC3ljKNY1xaomcpaiqyguWv6xbsg4S7GqyThH0VmiEPK/PZ4kAAAAAAAAAAIAAAC8oPjX7r33UvB7Mn4iM4xE08gCwDiSGQcu/EUAMENPZpxYEJjy71OMZKYpf27neC2AiLv8dS0CQEOxqSksFkRVTbFpKNYNhcWCYss/j1VF1DREriIKngUDovmKAAAAAAAAABAAAADgBcW/l07+NHGRL4W/7Tou8gf+PdN3/HsqBhwOIgpMIhgMRNOUpwBUBLA2rxg4R6FpeBqgbig2DYXViov/dkFhuSRzdUWxbSm2LYXFkuI0sWhQN/x5XMXTAEQQAT7qefIjMI0BAAAAAAABAADwmxT/fuIifhy42O97st2Bf9ztyAwD2cOBzH5Ptj+Q6fr8d4YhTwMMg0wR5OLfeJ/3/p1Le/+xqmZFf2xbCqsVhdUVhetrissV+etrMuNIYVhQXCwotoFCbIgqMRUU/wCIAO9Y9L8m0QEAAAAAAEAAAAB8suJ/kAK+78keDmS7Axf++z3Zw57sbkd2uyV72JPpOrL7fRIIeDqgz0KA9zwF4D0RRSJfJAZYQ2RdIQC0FJua4nJJYbGicHXFIsDtLYWrazLdgcLqisz1DYVpouA92RgoNvlzQgR456I/hJTiQHQsAoiXQ+nLADEAAAAAAAACAADgExf/fU+278gc9uS2WzL7Hbntluxmw4X/dsMiwH7HkwCHA//YdWQm/vdmGtMqQJoAKItKLQjFCDC6iov/tuUpgMWC4nJF4fqa/G5H/ssXMocD+S9f+fuUD3/ic0b93Cg4X/e8eC4BIjwzBZDiGlUAkNSG0qQR1wQAAAAAAAIAAODXFnnq3s9j/z2ZruOif7clu16TW6/JPjyQ227S79ndloWAnqcFTNfxv9eOv/4osYAmhqNvwKQCMTqXDAFju6DQNhQXSwrbK5486A7kDwcu+iV9gGKkaB2FotMcbdF1RjrA5c+L0ggyeI541DQIXecI5RRA8dhXFU92OEdGpzyQ2AAAAAAAAAEAAPDri720py/GfbbruLuvxf/DPbmHB3L39+TWj2TXj/M1gL6Xvf8hF/7B585xKEbGj7r1hmQKwOo0QEWxOZCtGwrtPn3+0HUsMPhptkYQpaAMxlC0jowVX4Hj8XNwXvEvRpA6vWGmkczkiVTgKeMc5VqyAMOeDlQ3FCtHsaopVpFMjHytiCACAAAAAABAAAAA/LJiT7q6vPvPBn9c4O/IPT5y8f/9O7n7O/714wPZ3VaM/7qcFBC8iAmBiOK8SPyRc7wxZKR4NHaiOA5EFU8VBEkc8OPAnWgtNp1N0YFUVUROCs/KUfQVGRO44IwRxeYlxb+ug4goZAYp/PuuMHeUtQAiImP5GjiXzByTsWPTUHQVUVNn1wCIAAAAAAAAEAAAAB9Y7MnoP493T0TTmMb/7X7Pu/46AXB/R9X9Hdn1I7n1mvf+tRgcx1z0y2j+EwO5n2EMfy/Gk/GW4jQRTRO5caQwjmkMXd3+XVVTrGpyUmCauibTLoiqmkzlKTrLxSzMAC8s/gcy/cDXWNY7bNdlAUAnAkJIBX3q+Guaw0LTGloK7YKIIlFDEAEAAH/e/fUn738AAAABAADwQSJAkLF9ngLgff4DrwBst+TWjzIFcJ+Kf7vbkTkcuPM/5nH/J4U/ERku+8j89FuZ/1sj6wPRB7JaMmrBWNVEVUWhbSm2LVkpMs3QU6xrMlNFsXJENmIC4MLi3x4k9nG/I7vbk+n2LArt90XSw5h8HaKxbOLYtBSbhsJqRWa1orhYUbhaEYVAMXgKRBABAAB/TtGP6FQAAAQAAMCnKvrSCsCYu75dx8Z7uy3ZzZrsZs2GgNsdrwbsdmSGIY/8a/Gvxfvx+eYF3075d2IIfAiKvDtORGSJ2CTQulT025tbivsd2e6aQt+RGVZk2omi92R8ILIhCws4VP1ABCqMIIeRr//hQHa/J7dZ8ySIGkJuxPdhHMmMQ/ZjcJZi3VCsawrLFYWbawpX1xSur8lMI1GIFEIgawwFMkStzSsaOPQCAP6tRT+iUwEAEAAAAJ+l6DPi5G7U6G0cJcZPjQCl67vbkTnsC8O/gchPT4v/Fxb7LxEDyokA4yeiwZBxHdmqonhYphWFcHXF39MwzhIIYuCVhBetH+D5wM+BUSIcDwdOe3jkiQ/3+MBC0HbLEyD7XbH6IfGOruIEh6ahsLoiv7+lcL2jcDiQH8ZkDOmNIWNyNGCEUSMA4F/0voroVAAABAAAwOc/rKgg4D37AOiHmvx1HZl+kEK7l1HxYv/7DYv/488V9WsYI2aDA38/upMunWjjJ46n85N8X3G+loBD1PPPgxC4QO87st2Bu/2PDzn54eE+r4Fs1mk9wEzjfAKgqnnff7kku92Q//oX+b4nmiYxcIwUpfgP1swPurg+AIDf/T76XHSqeuOEPNUWtfA3hsg5RKcCACAAAAA+5NSSDiXZDyDMpgFoHMmMI9mhlzg4f7Lz/17oNIAJIfkUsPfAIMX/KN3/aT5qGSNPW2IC4KcikPHymMrOv9usueC/v6fq23/I3X3PAsB2I2aAHP1YjvDHWgSAxYLC4SArJR0LM/J3yElSg3NkNL0BaQ0AgN+9+D+OTvWTvGeNfA888gIwxbh/rCqKVU2mchyFi+hUAAAEAADAuxbZxdiiHmTyIUYONfpxNMb4IUeS8vuT6QPjJ/keJSEghvR9GhECUPq/AO9Z1BklAnK7Y7PHh3uq7r6T+/6Nqu/fyD0+kn18YA+IvpdJERGDiDj+r3KcwtC2MiHAwgLFyAdYKwfduqHQLsg0DVFVU7QeaQ0AgN+7+PcTm+JKhCpJ4a/rUjwFEGbJKWQkOlXWp2JVkalqNlR1FVFdwTAVAAABAAAAUgcF3f1XP47csZrI9D0bPe53vPd/f0/u7jsX/9+/k3t4YBNATX+Ypjw5QtLNkgI/HXhHjnIkIjZwrCpOCViuyLVtOvSaULHnAw63AIDftfhXH5phSEkpnKrDsak0jWxOW0anOssiaFVTbBtOtmlaIt8QNQ1/DaSmAAAgAAAA3vwcY4wUcLKT7Vwu2JzLu9on9rX1YPIhRxL5HmPZOXEVkXUz86RoLe9Xgh8fXmPk/dRBkx92nPig+/93d+IB8EBuu+FkiL7LHhDlNIg+L2RyhLxngUavWSUdrsWCwmpFoW3JLpcURQiAVwMA4Lcu/sUjx3YdC6Vdx5G66qGjqwAyNZXeY7X4XyzItEu+Ry6XFEJgkZUIIgAAAAIAAODNKursQGyMFNVWxrS5K0F1zdFuTUumOnDHwlvuHOtB6D3PWUVxGV3RMamLj6amWFdcaJYxSoZwUPoREpeYxv8PB7KbDdn1mtz9Hbn1I39o8d91snIRTntAGMNFfwhkI1EgIkdEsXLc8W8aCssV2esbslfXFNJobKDosQYAAPhNiv8yOnWcpNsv5rR7icvd7zkxpbh3cnJKIQDI+2xYLMiuVhRWVxTGlay1RYoxUtD3MYPoVAAABAAAwKtqf/PkIzqXxxGrbOhmFwuKbcPd2nEkEwJFonc3Ayw7Hvy9VUSuotA23E1uF/xj3YhxEv85F5IGDvMveRrIodR2B7I7NQB8YLO/zVoiIA98uJ3k8FqkP5jyWsXIfx4jGSKyPVGwltx2S1GeR279SOH2lsLNLdnuQGG84s/btrgYAIDfRgTI8bmSkHPY8xrVbsteKtsNJ6rstmT3+5Scoqaoufvf8lTU1XUyVzUSs+tjmE/nIToVAAgAeAgAAK8p/lMMkY4i1vVsHDGsVnIwuSJ7OFAYuFiMfiIT2GTPEBGFwDvc9A6rAMVaQqz5+9KouXC1oqhj5E3NQoCsLSQRAAel558GGv83DNyl0gPrZkNusyG72ZI5HDj6UUdXn7nOJ4UAYzgFoKrIbrZkFyv+/Nst2e2GzP6WzM3A34OISgAA8NmLf1LvFNn5t4dDLv7XnKJi12ty60cWUmUKgNQMkNg4leo6v9fe3JLXdJXgi5urpSDvadFC2AYAAgAAALxGBEi7/S7vaEvxb6UjEW5uKfQ9+a7jA8/E0W+WiMWAQgSgWIgCrz1jlUKFLVyS2wWPSV7fUFiKQLFYyDRALVMAjtcFcFB6nhAk9jF7ANj9novzvXT9O4nyG6enO/8/OyCTTIhM8vn7juxhJ+Ox3BGzqdtVuGM7h2sDAPi8xX/q/vu0+2+7A3uorNfkHsQ35eGehQCdpOo6vt/JBFW0lmJdk10sKFxdUeh7MuNA3k98PyT257Gy6kbWkXEVkfWITgUAAgAAALxCBBAzPVPxFEBoWzLtksLqikzfS0di4M6FmhLpIchYspFy0S+/H2UE/NXFv4z+x0q6/21L4WpF4fYL+dsvPEp+dU1hdSVTAG1aYUCX5AWXf/JE08Tj/UPuZPGHjKyOAx9G9Zr/7HOmc3JhMjiNshu750Nw14lh1kBGTQUnT7HBNQEAfHJC4Puan4imYn1qu+UElYcHTk65v2MRYLslc9iT6QeyQz9LAQhNS7FtyB4OLLKPI5HXP2czXvW88XVNxtcUgyMKDp4pAEAAAACAS4p/Q9FaMtZQdJo/3LIL8biSKLeROxI+kKGYjd6MIWstBWN4RNyYmSfApZMAsfz+rCVyVRr9D1dXPCZ5c5OL/+ubvAZQsxlgdJwKgAPSC54GnkUA03fS+d/L2D9H/ZnJi/ATLriYEjM4ya7sNLG40HW8GtB3/Pt+woUAAHx+1PjPBzLDKPeynleoNhuyDw+cnHJ/R9X9Hdn1I/sBqKA6TTMBwFQHXmkbRp6w0wkra3nyrarYgHe5JFt3FKqaTFUTuYDoVAAgAAAAwIUiQFoBiBSbmsg3FJbL3OEIPo0jsm8AO+27iiP4XOq09/xX9HOrUeCrxAnHBX3L2fHh6jp3/m9uyF9f8wrAckVhsUxmgITx/5cRZAVgHMke9vzRcYGeHf+z6d85j6ShoymAMcdkmSQCyL6rD++eJgEAAK8t/vmD9/9pGtn9f8cFvt1uyW03nJzy+Eh2/UhuLeP/eu+b/MzFP1aOooijRvb+nWVvgNiyGG9XK4o7NrylacFfO1aITgUAAgAAAFwuAkTnyMTIxXPTcP6w7DkmrIwcVuLGb10qCa0xZPWARJTz388s6p52/+3cJfn6WiYA+CPc3LIXwGpFsW2J6ooFA/1ecTD68WGW2KyPYwClQO8Hnujwnv/stYW5dMxi8OI3MIqvgHz4M/0FAADgVyHTUDrRlFanduJtstuS3awlQnXDa0/7Pd/rpuJep+9zwYmhoCdrDL+nWsdrAasV2eWS7O6KEwLSVNZEUaeyMOUGAAQAAAA4t/hPIoC1RLV0FQLv8fvCiIiN9SQtQKYA+N9L0a8HI3VIVj8AOnMKoOz+SzJBWCx5/H91ReHmmoJOARTFv8YBphhACAA/f6hDkFgqiZ2SPGsdyzc+vL4wLzKzyftc8Oue6+STISEAAHz6+6aXFQARTu3hIALAjtcAdmx2aroDTzuJoDob/9fPVYjmwVoy1pLd12R3K/5cy5VMGBxYBBjH9PVjjWsBAAQAAAC4VASQLkIkIhIjtmCI84eNJVvXYkTUiBuxlYOQ5xFxz4WknSaK+usQLpoCSGP71lJ0FRf2iwV7ANzckr+65gmA6xsK11cUUgxgO48ARPH/88LcezZ19J5onCTlYeLIvyn7ObyZ2OAn/jpqDDhOaRLBBAgAAIDf4L6pJoAjm5gaXZ067CXlREb++57XqHyY+ePMkDWsSIbvifLv7G5H9mqX1rLYRLBjU9bwtvdmAAAEAAAARAAWAeT3gpMIvrqm0LbkNKatHCGfpjTiqPuM5M1ZAkBy/pcfo7N5/79tKVzfkP9yS/6vvylcX1FcLrn7v1jk4r8quv/gRdedpwB82v3nsXwx/jvD/f/kp6fSB4DjIkyMvAYwyuSBPD8irhkA4JMX/yZ5AIh3St9znKmkm9jDQQxO+xyhWvio6H0xveepCGBYhDV2EBFAPpd+Xvk6YRxZsI08bQcjQAAgAAAAwNuJAOqiLyaBvq7JuiofWCQ/Puz3FPY7soslxf2eTY3k36W846ODz8niX0UFXUfQBABXUWjZACnqj8uVjP5L8V/XufOPQvLl11tFHDmgJtf/KedQv1mXqTQEjCdWC2DYCAD49CJAkGkmKeonETP7juNUx5F9VMYxm+iGH6xS6e8V0YLl57CaljKORNOY33tDoIi1KQAgAAAAwJuKADJGH60h4yoyvqbgOJfYhEDeT2T3ewqrNYWra4rbLcWmJbJ7GcEvXPhfWkSmIrBYA6grim0jnX5ZB1DX/4ZXEmJVzb538AJCsceaTPjC7LBq3rL4L380Jmdcy4EaAAB+m3vnJJ4pk64C6EcvvipTMUn1Ex8Vvd+KGSALsYUpay+GqZOXrzldFssKAIAAAAAAPxQBYmSjP2uJrKcYHBnreGx85IOOv74me3NDcb2m0LZkZVVgVvzrp/3Rl6SjBAA1AXROvAfkQ9YBYtsk078Iw7/LLrN0nChEOcyOyaSPf/Sv7v7H54SAmRjAXg/YZwUA/BZowe4n7s4PAxfskgjAK3Ceb4BH9zXz3Pte+ryURYD0+eRz9x3fn5GYAgAEAAAAeBcRYFaMW44rspZi8BSalmzbsjP/ckWhbTmuTwwCo3Nk3uJ7sJZiJV+3adgIcLHkmD+ZTkDx/4ryXKYzeOS0FxEgyIj+iaL93Ev4nAgQQvqTvLrhcEkAAL/FrZPH/ycWUmV1irwYqXqf9/6LYt386B6ZVqTKFQMvhql+9rX48+IyAAABAAAA3lMEiJGLcGMoVhN33xuJ3HOO4wOrisgaLuhO/PsfxQHGHwkP0iHWlQT1CaDjrwPOOMDK1dApAD2g6uEyxJ8eXC96LunPrSUiQ9FYImdnyQ8AAPCZ750mRhZJifJOvo79SxzuLNr0JSJq+juFJ4sYDRpffF4iMmIAiCkAACAAAADA+4sB2pGvKh7JTz4BNhXr9BauxKY4FGlhWH7uyvFfQsF4OcGnPVWiWORRh6c7+2/1HErxjo5XOWoOso4wAAQA/CYCABfpMimlhbnu+/uyUD///mlCyBMBGqdbRAimr0kQAAD4U8HJFwDwS8SAaGwWBKw5fdgxNDMA/JkHwKzg14JRpg7yXS+P+0cUjK86xBqvB0vPJlMDx//RNGVDwNd+mdmhmbLBo35+y14PbAaIwywA4LOfvHl6iYzhAl1d+8uVACnS4zkGuHKfTP8mzIt/Fmsnns7S+ygEcAAgAAAAwMcVj1NaC9Dd7TSir4eSEwZIZ1eOT1YCHEVnxTHZo2h8LcaQGWTEdByKA+zbPK6muHbpGhpTpDa4NEkSK3gAAAB+n/fB2bpUKtgnMuHI7NSYnwvgpVigUwaxmCQoPAIAABAAAADg4w8+xvDBR7OLy8PJk0kAM6vpf1TvP4kMPHZQlui61AWBAPCqw6s5GltV5//ZGsBbPV+IeFpEC/+qzmsj9mlqBAAAfM57pzj8W0skE3CpMDd5Is6E8PL3KRUK0ipWzJ+3FNsrlyeo8P4HAAQAAAD4ENIut5GuR5kZPzePu6hIN2a2L2C0gDSFp7yTMUyMQF58iDXBkxl6dq4uD6pll+ktYgBnxb+lWFcUK5eNJNPfQfEPAPgNBIDZvVLupUkYiDnO7/he+KP7JB295x2j9+Qgn1s9cQAAEAAAAODDCHF+UAk+H15OHExe7AFQ/maKIAzZuZ54/x8eAK9EcqqND2S7A5muYyMr/46rFccd/xgp1hV3tnA9AQCfnWKdyZT3yxhEDHhlZz6tAZT3TfmawUsCTvbgAQBAAAAAgPcnRi4eDUf+xXLHW4v/5AMQ3+TrRef4o6p4f5zobcfU/8RrSMQH2L5jgymJsUpu02+5a6reENby9bNyLZuGYt3wRICDBwAA4Pe4f2p6Ckf2HU1N6cerTHCLe6e+zVmXjAIhgAMAAQAAAD6ucNTdxxDIjOoc7+cHoBNdkBd7AOjvFbFxRlcMdHQ9hGw6CM6vx9VVeujZwXoayYijNcdbvYOwoodWa9j4r66J1AwQAAB+l/dAdfgnM59eOp5+u2D9LZYf1qUknKcCOMRvACAAAADAh1SOeT/fxGwCqAcf499od7wsCvXwY23ufrhK/xAF5CUET2YcU+RfNKYQbXiv9U0Lf2vTYZZcxQLAYiFpAIRRVgDAb1H8q8O/CZ4d/2Vyyvgj4fRIDHipB0D5OdLPi5UpTQaIFia4AEAAAACAjzwAhZCOLUbij9QM8PgQQ7lUf75GVHGBis4/GYqmOPiYI9O/0hQQnHUN9SBpvCczDmT3e57mkIMsPePj8OovXVU86p+MAR3FpmVxAEIOAOCz3z4LsdR4SVCJnKKiHirmKBHgbEpTVFmdyn9m89SBQRkAAAQAAAD4oOKR9x+PCvFi7D+WfgAv+bT6uU8chKKxRE5GIV1FVNXFbiWKxovOlxKlyGsAI5lxyvv/R7usb/MIZw8Aco5C01B0FcWm5ikABwEAAPAb3DuTG3/gCYDgyYyTxPLpakCkY3H6p3e3UgDX9z712CFi4VTvk6UogPsmABAAAADg/U9AvJ9oBu4Y0zjJKHnI+fIxnC7yX3gISj/XlQP9mlTEC2J//DJkbcMMA5Ga//mJjR3LNYA3e6ey+dBqLI//Ny3FtiVyuIYAgN/s3qld/tLkT7xTZikAl0xR6b3SOXb7ryqKVU1U1yyc1k3+3Lh3AgABAAAAPoRkyCcu8n5K4/8mlDFyF3RAYjwpBOjYeCQ1R7LZCRmHoPPPmHrdxoH3/acpRVqZMsv61V8or29EaynWepitkqFVtJaig6EjAOA3eO+TKSkzDGT6gUzfkxl6EcILEfUMD4DnCvrj9zidPojH63AAAAgAAADwbqjp3zTxj1rsB59HyPUwc0YXxBwXjcYQOcfxcFXFu47OEVUudZRTMgC44BoGFnAmT/aw5ySAcUzizVs8rmWyQ7RGVjjkmrpKrm9FVDe80woAAJ+YlEQzjkQhkB36vPsfA4un5RpV8f5mXnCfTH87rQGIaWrl2C9FVwBUOIUIAAAEAAAA+IgD0JN8eDEBTKeZ8s/P8QBIhyAxNzIasWRT0RirOu1B6hQAOKcqz2kNZhw4BlDWAEgiAN/cADCtcsj1dGwEGJqGqKopWkxyAAA+OUHM/iYp9mXtLUfhTmn9bSZOx/jD7v+pu140NnmjRN33rxyRdTxFVRoA4r4JAAQAAAD4iCLSeC8GcgN3Q1IHOXsBmHOL//T3xUiw3B23dn5Skn1yjEFeUI/7ic2r1PjPeyLPiQBJzHkrAcBkJ2se+Xds/Nc0/JG8AXCIBQB8crx0+Ucp9if2AuD0lClNVvHHhfv/SSxl4ZuqimLbUqzkvpkicFH8AwABAAAAPqDwpyjjjpMU/JqBrF3j0ghJ/40xL3OSL8YetfiPcgjSJACeBHBZHMAKwGV1+ST7/+oFME35cBve9jGNhVgT64YPsm3L3f+m5rFWCDkAgM+MiqNyz7RdR6bvyHSdrFCJj4qsB6T3v5/dH0+9D8p4P0+9VTxFoD4pTt4LHdamAIAAAAAAHyEAeDkEhShCgJcYJBYDSP+s7ID85BB0cv+/iIwjVxFVjt2PXYUOyKsPsjHtrdq+ZxOraeTi388drC99dI/tH9O+qkwCpImAmtcAIAAAAD71e5963XhPZhiJkgjueX3KTxKP+/R978UCuPilRGfze6C1FBtOTIl1XazGEe6bAEAAAACA98fEmCcA/MSHnFEMAUN8Oj6uGcYv/gIS+2clA1k/6oYPRroLKSZIEADOLf5DdvvXCMBJulYaA3h0eL38yWLmH2L6l2IAdccV1xAA8Nnf+/SeKatudhhkBW7IBqpqihvPvI/q+2QZlypid34PrPNUgEUKAAAQAAAA4IOKRy0gSbogZhxkHWDKKQDJZT6eNwKpkUflQUic48mYFB+XjAItjOMuIsp1nDi908gAACAASURBVMYk5qTrOr8ilx+W9fCr17NyPPpf1yzm1HU60JLFNQQAfOZ7pq6/8X3TDANHpyYRdeJJgJQIcIGRqhr7WcsCd11RbBsWSxcLFk/bNk1QzdICAAAQAAAA4H0OQDFFAKaDj5oA+imPRwZ/uiB86ZdyjnhsXOLiJC9eu8XROu6A4PBz0XXMrv8S3ajdK3GwfosUgKgH2hhFqLFEzooIIKOsVnb/rcO1BAB87ve/EHnqbeQpgOQB0HOaCk2jvP+9PP72iQAg75bRcvwfWZc8cPieqffRCh4AAEAAAACA9yeNjuuo+CQjkWJ8lH7/FSOQaVy8qvigIyZxqWPcFB0Qg1vgRQdZIu5kaXLDNLGooxMexzGPr3rSmDTNES2vblCaBJB1ABT/AIBPft9Mbv/jwL4pYgBI0v1PKwBHa3A/urvF4/c/nXhTw9u6SqapUYTwKFGqhOhUACAAAADAuxeOMgJJQczjxARJO8i8AuBTEsBlHRDpFuvIvxgfxapOUwDk+JCE7PgL0THWsUhyOHFwfZOnTRnlqLuslRxq1fwP1xAA8IkxuiqlYvfQ8/SbD+IBMOQJKn2/PPuLmGTsl+6RdZOLf0lQIe38474JAAQAAAB4fwEgsuP/oMUjH3xsWgPg3UcTXz4CGZ8IACRGR0Xcn6soNjWvAjgne5IYG7/sICsdrHFKkVZpteMduv8mxqLwl0mOpqFYV7waoE7XAADwad/7ZLd/GHLxP448BTCMvBYwTXI/PVNILXxv0nufdbn4bxr5kKkpNQHE+x8AEAAAAOC9D0EmRBkV91z49z3RMHLxqKsBXmMAL4hAIsodYY0ArCUrvm5kAqAqVgBwCLrsOgY+pOq1nJ73bnj1lyvMqrIJYJ0mADDFAQD49AKApqeMI9l+INt1ZLsD/zj0LKx6FlXPnn5Ts9TZ+15FVHPSjSankEzEUVWsAAAA/kgqPAQAgA8hBDY5ChoZpx4AEiOn3Y9wnomcIco74JqBXBU7/7L3T2kE0sk+OWKQLruOfF3SLmvXSZKD53EMn0dYLz1exqMrrJ0tjgKs8o6rHmrBj4uDH/36uAhAUQDAm7/3GR9y5F/f8xRA37P5rdfu/5H4/ZN76Gz/X9bfop2vSMW2pdgueAJAxG+eAMDqFAAQAAAA4J2LEJPi/0KKjkvd43HI3Y/gn5SAkZ6fAoha1KhZXHkQ0v3/0gQQh59XHWT5QQ+S2BCejq0ak//eayg7+xrnWFUUnZ1NcaS4R7zG8o+h2CPWiY2TpcN8eiLq41g+7uWv8ZoB4Pxb2an9/77nCaph5BUAnYA7V/w+fr3qulRdcdHfSgRg06QoQLyOAQAQAAAAH1WhcCdklOi/QbrHQ080cjTScxMAPyz+jwtGyUCmyvHofzJEqpIQQFUFD4DXHGbHidc55BoZLTqPTAB/JNz89GB7NNaax/95n5WSv8MfWvzra0THi4v0DOPDLE3DlH/3+DUjP0ZjyJi8FsMiGaW8cPbOME8/AAA/eZ3KutQw8M6/vAdaef9LUbgx8F3zhffQsviPMtUWnZWUlIZC23LqTV3xFEDlkkAA0RQACAAAAPAhxYqRHOQU+zfqFID8GHzegZR/d9b+vyQAqAkSSfZxiv6TFIBoHaYAXnGYTQkAXceijUYAlvGNFxb/M2EnRiJrZF1D0h0ql8ZY/5jrp68H7eR7n30YQpQEhuyhYcSQkXSixp/YK45xVgRENVPUSZqq4tePNVI0yNSFuoy7Kv97vJYAOE0RjWqk428PBxYC+p7TcPzE99Vxmgl15qX3hvJ16LLQzWapNRf/+hqW9SkIAABAAAAAgHcvYIzE/xFREffnxQdAu/+Rq78XjkEaeroHqd2NqOZ/7aLwAmhyFCAKlssvpzG8t+onFgK8n0dYvQWzDnMRA5i8AKTT5ap/7Wum/DC6ZiFrF+qdQUHjM3m6RoUAfU2ZyfMLRQqQ1O0PgaK1ZGLMyRhEFJ2lWDeydpGNF3UFg6ykMWispjXyexUmAwA49d43eY66FeNb03dkO/YBoEnuoZO8N4aXxQDO3veIUrKNGv7FWov/Nr/3aSIAin8AIADgIQAAfEgxkzogAxcpw8iHoHHIHc0T4/8/HYE8UTRGLRarmjvGeiCSsX9EIL3iMKteDsX4OY+d+8uyq38iApQu/xz95/I6x79t/L8s+Kcp+SqYkQt+mnwWXcSEkcYsBrAZo/493TuW61NGNuprJfCEBTknXgr8+giLhZwQZHWmbaWr2ORxYk3YEF8Nkgkbfe1BCABAVqZ06k1NAFMErhipTlMSUc/e/9fXssT/kZPVt7ah2LQUFkteBWhlCo4g0gEAIAAAAD66gNRdyGlMQkDqVoYLi8hU+MsOpHNp5J9HlbnI0fFxshiBvLhAnSbpQE/80MuhNRrD1/fcCKuffT1jspijKx11zb+vf/5vKfxVCPOTJGPwqkV6zNU7Yxqzk/gw5iKi6/nPPDuK6+9TJBHgxvx60a+ZJiucnAqk0HfcUQxNy8VE4b8Ql8uULR7aRSouYtMQNQ1RCHnPGMXGxz+XyufUD+6X6efgHV/XYnrbd/zR8eg/j/93PPavE3F0gfhdvPeR08i/hkW6ttj/l6meFIELAIAAAAAA717cqEu8TgLo2GPkPeXUAaGXGQDODrNEuVNsLBczMi6eChcVA+CC/DoBJ2TDPy5GJzEFDO8yATA3uZIuFxFf499991wnKET8Sl38YeTIzGEg2x1ycd93/HuHA3cV+z7HMI5TNhSbeD2DxonXMkJIr7XZa9Ja/jFNAMgYcVOzT4aODjdtGiEO7YLdxNuGwmJJ5uqKX1/LotPYtJxBXonhJgrN9+Uo9WGW/nDicY+lMAMx4H2vi4rekyfbDykBgAW8IfvfqPj30ve9svjXCYAy+UYEubhYysoO/xk5+HUAACAAAAA+gGT653nPkbyXDxYCeEy56FxdEiVn8p441VXef5ROJecgu7lYAM57iEPInX4dW/VT6l7Tc27zrxQBuJtscsFvZZpDrudvWfgnMWzMo8DjKF1CMQfre7KHXeoa2q4jcziQ7TuicWJxQH6fYshFhfoBTGORCBCeFWmSw7912UVcjcS0kGg4TiwsFlLsy4/X1xSWKwqrFdnFgsLVNYXFKPnjkWII8N14y+dNWVxqgVkaQqa1nHi6WLSWL4O1LJYaM5/UwL3xTa+XmcQkdRyyeCerALr/T5P637zs/vl09U2EO/W90fe+9P4naQANT1Hh+gIAIAAAAD7iJJQOrSkGaRzJDn3eKdcuyCUFZGmEJIfcqAfc1CnmyLiI8f9XFeNGCkndKTdTXt0w5X75G4gAcVaU2ORUH6uc8vBbHWbLUX8/kemHVBhwsX8ge9hzkd91ZA57sl1HdrdjA7F98Wcj/5u0TzxIvrgXwzER2bJfwzMCwKyL6PIesXOFB8AiTQOE5ZJiu6CwXFJYrbjgv7mhsLqisFrxpML1FYXliuLkKSxaothQjDXcxy+h7O6XBX/hm8IrH8Wvx5HSAHmM0k42afw7JgGtTEaRFAi9PigS3+TasT8HT+uQ+nOk1Z2xSPSIb7P/Xzcs1LULCou8qsNrUxbpNwAACAAAgI8tfpJZmZcd8sA75ewoz91lo4ddY3JB+bykUJyKbC78rbiUN2ICWNXFCCQ6kZcfaLmbRbqXPnP9jycuyuvEhvLnsaqS6RxZ97aJAx9d+I/TfJz/cCC735HtO7LbHdn9jsx+T/awJ7vbSad/4N8vd//T+P+Yxv7NMOa9Yyn+U4Hx3FRNaZ6pxYS+juoqm/9pcbFccnGxWpG/uaGw21K4uqJw+4VC35EXcSJME5FfUfSewiJSpIa/HkSAnz9Xjrr7ZpKpqRjy9I3GqKpJpBefB02B0M+n90fxd6DK8QSHRKTqugYbOkpMHESA17/fqVAzsjhn9TUtUzy6rkPB5xW5l3zqJ69b2f9PaTdtjgCseQIA+/8AAAgAAIAPLBpzDrJmlvPI85gOsiYdduN8FeBH9eGxCKCd4lTAGIrG5uK/qvOuM7i4MDEp01pGV/0krvPzNY43eZQNX8P0LRTdK47/i7/P819dwIdexvh7Lvp3R8X+dsM/qiggXX8e9T/kzyEdRO0wUhn9J+Pg6efla0kLzOO9b2OISCYBnDtK06hyd7GpeQ1ApgDs4xWFm1sKN9fkdzsKN7dkDgcKt1/IS0xhCIEsyZRzLb4Af3IhcnyPezLKH1JsqgmBRZ3gU3c/Xfc0AcJ/brtOTFVH8ZYI+UapQqgW+6sVhcWCwmrFe+J1TWG5JKobnvyoa4gAr75fhpkwl6Z9xlGmdKb55NsL7p3xyf1R3/PE46aMvG157D/KJA/2/wEAEAAAAB+GkU6/jvqnffHg59F/Z0QAzijGVtPosuwscyTSgqiusnKAQ9DbiAHjkAUcfUzDW3bmTb6mWpTKbjr7PVSf9/Ehyl14P6XdX3s4cNF/2JPdbsltN1z07/dkNxsRBfa8+7/fswDQiyfAUBR8yVeDHf/TKLg8/klMKyclZE3jpAgmAoApBAFOAihMNSX6z8hesW1bCqsdhf2ewv6GC//DgczQk9fOppgbBhFCAq3y1/+TRAB9XZwq9kP2g1CT1Nm0yDTmuEct+oeBV6jUVT5lzPd52kSnAET4TN3/5ZLC8oo9HK6uko+DGQeK7ZJjIGNIzvG4X152D9CpDX396vVJa3BioDrb///5HZFFgHLtzeb4v6A7/8tlWgUoVwBwLQEAEAAAAB9WLHJBJFFmfspdTH8kArz0084KFzkZ2fkos+6O8zSAmsk5XJMLCxjjQy5MUtb8lEWdt3i6nCpMCx8AzqqnzzvJUY77TyM/x/uebKcd/i1/7LbkNlL8b7dk1+s0EWD3PAFguo49AWSHmAv/aX4dvOcHrUjaMKfMxAp/BnPKB+DUrz2/hgxpl5EnAoyaBC4WZA8HCl1HoTuQ6UQA0L3nacrTP8XXD4Z4HeDfbjhX3tcCp53k15FMQYUg4uiUDeMmLfbFJX4Ycte/kyi5ceQx8v0+eULY/b4QWrNPR5qKqiouEI9XOK5vyH/9i8LuisLtLdHVNcVpSWFZiAAO982zr71e42HgSalxYtFm8j/c/3+x8F1MvKX4P13RaducyiFrU9j/BwBAAAAAfFwxJN1JzjYXEWDS7uAoXeSnBeQ5R5VobTIy025l2om0jj8bdltfdy3VsHGUTnOkueHfG+zlP+lwEeVDbiO76MbMIrM+3WOkMZe9uPbv92T3O3KbNdnNluz6kdz6kQv/zYanAHZbKf6PjP6Ggd38xymbvXntIvunIlv5c03TKB/L8nErr92J14TxfibAmMlQtI6MHXmtZhgoNoe01mD6nnwS+NjlnGIgrx1Oy+KcNYaCma8b/CvvefL/pyDTMpOIN+nnYginbvCaFz9OnPQwTWT7nmgcyYpzvDkcWBzSn+sEgMbL6ah5CLJbLi8qk3fEw3LFkY7X1+Sur8nffiG725K//cJCzpee/M0tT26sVvy6k7hI3D9f9hzQJA5e2RnS/n+K7tT9fz/ROdG3p/b/ecVN0joKvw6q6iTgxAoGnAAACAAAgI88DGl3y+euIBf/0yzOapZT/pJCUffB0/6/5h27tLucft40OLy+urAJqZNp+j53J8PzEXOvUwPMU1dyvc4iBHwakgM7O/LbTsz9dlL4rx/JbrbkNmty93c8/r9Z5/F/XQvQDm/R9eVOoazMxBNRb6c6/eXPZa84Hr9+nvt3xwJBOT0gHWXylozzFIOnOPmcaT4M5FO0WcjfqxGRzlUUrCXjXHYl/ze8LmdGjz5PgKRR7zEnNvR9nurQwl67/TrO33VE3rMgNE1E05ieG7aXHzVSTj+Pii/j+HSqqpgCiE3D+//LKwo312S/fCW3WdP093+R32ns5ED+CxtKhrAkalt+/iAl4IVCoExI+akQaLr8OvFifhte7p3y3P4/3w+zd0OUsf/QNsX+f4VrBgCAAAAA+Bg0mko7YpFMGg82alQVjkaXX3LGKosU/ShGIUPTsNlVGoG0eUoAnC/iFOZ/ZpQEgDGbk72LIZ8xXDg6EXKknRmrin9qP8m1TG7fQy7SdMx/uyH7+Eju4Z7cmoUA97gmu1mzAKCFvxr99R2bKo6DGMGJC7w/0e1/pnA3xWvEnPj953596rrHZ/6/6bUqQl70hRGhRkXqBAERkV5DNQB0FQVXzfwdft9iL6RurtFrJ87vpuvzvr4W69K95zH+Pqc5TJOIPz2/xoY+TQAYFQP6Lnf9dSVARAaSlJV8fUI2fFRDTZmMsk1DYbGluN2Q3WwprB/J7nY0Hfb8PYnnwET8/4shcJJDVee4QNxLn70fpP3/oYz6lJ/rtZ54QuOl00zP7f9HKfxD03Dxr+aORRoARBsAAAQAAMDHHY6pKBSClx3IKTshB5+y5V9XLGrGsRxOtdAo4wEdYpAuvo4xcGGqkxy6v6xFalmgvuZLHR1UuctluICUmDIjHWUKnyAFQHPXp4md/MW53z4+knt8ILfZcPF/f89F/+Mj7/tr5/+wT0Wf7Qd+nYxTcoBPAsMP0jHMDwqGN9FhjgWBwr3eWJsc520IFNXgU/5OLM0bbVGwNDUZZ8k4eW2WyQS/UeGfO/1TGue3YoRo93su/LRbX0Y/dh2ZaUx/lzv447xLLI7+s+QH/fk4FoV/4SGgYpw8/ur3EI0hIyZw0VmiqiZ72It3g3g49ENhMinmgzGS9558CGRjpLCI/FpM91cUlacFwWk+5dGLCJSmPsaj6bd4UrT7sTiaDVJjXXPhv1hQaFtOA8D+PwAAAgAA4FcdlHkfcsrRZaV7vPdcRMbiYH3KqOy4SCwOQbn4N9INqSha2Rl3Iga44hCEg9BlhW7IxX8qftTRvCg23qbqNHISNjI6zpGOVEncFZlfPwGgTvzSlbW7HdnNmvf6Hx/J3X8nd38vY/8iAGw24va/J9MdckGQurcSCfZcx/8NC/uziv/i1/G4CNbpnYF/zxbrGs5ajqBLsWQN2cWCd5WrmowWKHX9e7wu9XqkeLchdfY12jHt5h/2IvIcWOgZBp74UBd46f7bYZA9/57d/schiwryI6mxYt89MeNMqyHHY//lXrmucxhDxlqK6sUyyBRBn70ESA0HY0wCDhlDnoisMRRrKVYhApy+T8aYPUA0+aM7FGkeY7p+x74p5+z/kxUTwKbJ+/9NXfwc+/8AAAgAAIBfcRjy4nIdPNHEnVKSjOu0L3vsWv6TQjIVIWm/VQ5CeiC1jqiukhlSdLjVvV7EySaAyeBqGvmaHnV93+zL6o6r/qhxZmJ69UsLjynHstn9Pu/0Pzxw5//+Xjr/d2kKQNcCuPiXXX8/zTv+WlQfF3B0RnfwA0WBWFx3Q1MqU6wWKlb2zquaP5qWwtUVjyqLIBCbhii4zy/OpVUmKc67QzZ46yTeseuyoePhQGa/J7fbyvU+iBhwEIO/Lsf66Qi/Fv2+uD+KOKQxqmaccs78iS7yyfvlkUmkCYHI8b+1asRamLEaEQuikakq+bdeCsloDH9eiAAnhMFJ1qV8XvvQiEaJ7tQEj5OJHS8o/jXVJlYiduu6W8viWmhbXp0SgQ3XBwAAAQAA8IGHIel0TBN3RmIoxluPYsIu2P/P7v8mmf3Fpk4dRqor6YC4FBMIziv+U+HjOaYsdz/HJOCYdxAAqDC5SkXIr94/1u6v7vsfDuzov9lQdfedBYCHB3IPdywCPD7I7v86rQekvWAt/H8ShWlOFN6fhSTGlZMAZIhMR8YasmI6Z9uW7GJBdrUid3XF+8kSVWZUpPushWQ57i/Cl4o4drcjt91wHN+eYx6dRjvud/L7+zwRkHwA2CMg+z0U5oFesuG1IFch9VSn/xnR1LxEtImRjOXJnlhMc1SFABddJetUJok4wVqyRBT0NaqvS9xbZSXEc6EvHg7Z+HEsVixCju8853WWfmO+ThOL2L+U3LBos78Grg0AAAIAAOBDEAMzipTi/0j2WLnwmaRgKLwCzi1AYuSDqrHcrbKWOyK6GynFYxIBcBC6qABKIo6ODvcDXzOvAk4uBt7iES7XNWLF6xup26j74jF++ONAcoC3Ot69XnOR//BA7vGe3LdvIgDIBMBmw2sB2h2WeLdkgqkfR0Xc7/QsnU3k6HNlILLWErk9xaYh1zQUF0sKV1dkN9dkl/LzbkmxbcnUavT4OYv/FOnWd2mk3264yOeVjwf2ddjtZMWDJwB4EmCfkx3S1MeYo/+08NdiPxTFYQzz5Ae9r77i+WJKIaAQ8GzxcnKmEFTFYM5pxFxVERlLxjqi0sOhFAT+1PtkiryV/f+O10GScWOKgJx+Ornx/AUsJt40/m+x4OmaxZL3/5dLMU+tsP8PAIAAAAD4wIMzkYxCTsmsyvYdd7t0FaDsfp57CNJCUT+c5MWLWVyKQJI/j+iEXFbgxXL8X83p5LBbGMK9+RqALbwdxNAqtO2vcY0vzf72XNS5hwey6zV3/h8fqfr2Hx75187/4+N85F/c3VPX/6iL+15j/uXnPP78b/X1ZiJACEQ28ISI4xWJsFjKmsSGwuqK7PU12cOBwnV2RI+V/1ydZI31K6Id7W7HH+tHstsNue2WDR/XYu6425LbbsmoAKCGf+oEPwxc6GuSxjSl9ZqZeV/5ejqOY3wjw8TZ9AYRT7UUBabmyMemobBcUVwsyC5ZsAnOkak0wQH3VioEMBr5fc4OfY71TOkNg6zB+Yv3//meSDyVUcs1UtO/tqHQtBL9x7G49BmFNQAABAAAwL+0cAye88A1ImwcCwMtP3NBNi/c/z95jDVWin3ZM64q2YWsuRvy2TLjf7tDrXaqfXYm77mbSTIZ8LZPHDP/uXXp5yZG2XstdpM/qPg348gj3bstufUjG/19/0bV3Xdyd3fk7r6naQAtBtn0TTt//tnO31uO+cfjAo/m48PxGYEgvsX3UBSw0fgUVWf3e4qLLY/G3+znJohqehdqivGT5JWfWPXg4n/LEx6bNV/nzZqL/8dHnvaQKQDt/M5c3yUxgGLkMXHKBpoz74fj++CJhBRTRDS+5tF6IgJMI5nekLUsptq2JbdcUri65omN1UrEuIaMCK3kLFGAwSpfV0lPGHMCgD3s8/1Dd//LKM0Yz3L+JyIRuOu055/9NHgNIEWnwv8GAAABAADwsYUjF/bJYEpzkcs98viKzrF2h4uRyNjURFXNh1JXFIqIAPxp0fZs8SFjyUYcytWpPPkCaBn5FhGAxWE3ptgyl69vMdHxRCx4p+KfJLYyFf+FyV/1n//ln9/fsQjw+MAF4W7HO99dl7v+0/S00HuDoj/+6Pf18TnuGh+tUcTy5xd+b7MpAO/ZeX4YyTguguJ+wWsTu202ytvvKayuyLRL2YuOn+P1oMV/37ORn6Y7pFjHO17/eLjnSY/NJv+/Ute3z0WfTjzFovA7Mcp/8tdHj+9be0I8nQQYiWxHtmvIPT5SXK0obNYUHh8oXF3x9VquyLQt/7+qmsiG3zPO8a3vFXKtOfJvKCIeNV1BBcD5dT5rEsfyOlvUFY12QaFpKKyuKCyXWRCo62ykCgAAEAAAAB8lAFDkjPCUXa2RZ9oJDeIw/4OD78lipzxkFisAuVCsOQJQMqujs3/uQejIATwdVssOtI4g6zFUx1ND5LUNKdyMZteXXU0/vUMKgEmxjuQcm5Hpj+n/9M7FohT/tu95hFeL/4cHcnd3VH3/D4/9f/+exv7tZpP8ATgGbEy73eVj/l5F/8niqywCUnLGiWKt9FU4yiV/aYEyMyvTVYAUl9cnJ3wz24uW3HnvKYbwOUweB85tt9stX9PNmqr7O7IPD1Td37Hg8/BAdv3IJo+bDf+/+k7SAcYc7Xjs1n/8mnzmcTxVGL7Xo1KKNyYEFvkOB7J1zf+39ZrszS2vv3QHit2BvRuahqL3RJX7HOLNLyz+07rbOOaUj4PE/3W8EpDSU8KFq2+zuNuaDQAXC4oLKfzrmuJyJfdNiN4AAAgAAIAPPkibwsnaTDL+qm7aUza/eu7w+6Iv44rdfzU9qmuJipMRVfsvz0EuD5Flga8H03KMnyjvHMfcgUw76VIEGq//3pPpOi58N5u8A304cEEnXW1zYkz5skrEzItWq74OEndV8zXmv2fe9zHV0X/Z/dax7+r7N3LfvlH1/T9s+nd/l1YC7H7Ph37Z90/iiPevLmrjSx6zIu897Qv/SCA4Xr85sXd+wVJOcprX5Ag1RdOiPxnjjUN6Hul4dHS/yKyz2Pm3fcfF/3abuvzu+39Y6Lm7y7/3+JB9Hg6HQuAMKQ7uh93+n9zzzC96DMjaIuZyV0xt8HUjLWTHkVcBQiWCzx9sOKfvcyOLo7bbk+37FPdI43TS88a89HWv026GVwCoqvL+f1VRXLS8AlCLOWDlIAAAACAAAAA++iAp+44Dd/hIu2KF+Z8p4qdeXFyUBoA6Kp7yxnUncsHjkVVF0ZrTxc/vXOwf7Q6nIl+Lfh9SkW/KGD8tzKZpVvAZEWZyUSifa/JsfrbdStfznl3t9zsu5qaJv9ZbTQDEmE2rNN1BRRz5fRZ73NPi9q0LwUmM32QE3N3f5+L/2/+S+/49R/9t1mS3W3H675/G++nj+lbfoxb7x8U/kSRf6J8XRpkxzicBtMufouXo+ai5M3bO4/Fz1YeUdZ9y0TUKUVaC1GDxLVZJLkauuRmGFOuXvB7uv1P1/Tv7PHz/ngWf7UamPXhKROP6ZiaPp3b4P+GtZeYD4b1EFPLjYYvoQp3+McNIZslTGybIc6QUkP4kNP5Po/6k6OcJAI39HNL9shTdfjRdE0+83pP7v7zXhbZl13/d/y+Fb3jfAAAgAAAAPqpINVpwqnlcCGRiSCZJKQIwBjrubf70QKSFjB6KLMf8Red4HLLSbnHNGdbOfZxh3FsX+oVAkooykqJfJiyIYvFYx8JdXKctphzPFmJav+B/3kf6UAAAIABJREFUw0INd/ymPBlgXZHc0LPj+XcpgjZrMrtdLtrCG+9uSwER01qHdP7rOo+1mncUdWLk4v/Axb/Vve/v39j079v/sgggjv9Wc9+lA5w6v4WgcknRd+yJ8OTHsstvLLuCpxHhmv/c5XjMU91/XdMxQUbfg0zl+Py6/Vn3+tlCMokM8jXGUUz1DmlEWtcr+DE7XSx/XAE3kekHFnx2W97xv78n9+0/VH3/lv0eHsXkUeIdNeudvP93RDvqdfPTTLSxh0OxxjWliNdjoeiPfb+bROTSyEfxSmHBS/b//dN1oJeKMvwbEnMr3f+wXFFcLikslvzzuuG1gLpG/B8AAAIAAOAXHCJ1J3IoIrDGUUYhQ8qgfs4R/YcFkVLEAMaq4n8tu5EaIxed+7wpAMeGe2VHPkiBTpQO3LNuvk5RlFni08gd11iY16Wc8ZD2rYmIO1Fi5sdFUOACsLx+45g8ANzDA7lv/+HdZ+16TmPKKn8TtKh1VmKseJRV48i0q/2uh3ntUu/3LHw83HP3/+47TwDc3aV9cCvmcDzmOxTeFm+37/+k6E/xiDY/TiKMZM8EN4/AtI7IZi+AaIw8l2LKpaeZSSd3MqP3/P0XBe1ZhmX6OHhJAxmnbAaqxaRXM8k4Lyg/6jWbRv+LqL+N+D18/4+kPHyfRTzajXT+ddVD15t+o47/T592IVCUXfXkYj/0qdDNBqHS+ac/1ANAhexp4s7/OPLO/2GffSFkLYDvr/EyYciyyJe6/00jawBq+lexAF432P8HAEAAAAD8klMRFxfTWBSePu/6Bp9GZc25I9Km9ME2KRKJDf9c6hQn1/jnOqCfqegPIXfo1U16HOddfDGaoomLeiMRi2accod1GNLeuRkndp+Wwl7FGC72szO5Fv0pplGKL50qMF3H3fDNWrqfj7zD3fe881oUPObyZ8uT4oMnPRznkcvIf2waGXF/h+sZI+806wF+v+cusLr+39+L4R8X/279OCv+SbvnhaD1Zl1/Lfqtmxf96nWhkWxaEFQcf5lNMItxYC0M9PnkPRd2fc/dbMktN8ayQKT/jzMmAWbj5EnUkumTaUrpIMmbIlKKB40f2UXW4t/za8UcDln0uZNkh+/fqPr27Wnx3x1ytOPRdf9di/4n9ygRcWeTXCEmMZLjCOMf/lYXCxNAz/dFjbhUEXYc0/2hjH588TqNtRRl2kfj/dL4fyMRgIulCN+O9//R/QcAQAAAAHwYIeQudPr1lAtK7UifedCfjUOW48+6AtDUfBiq2ASQysi4z5ItXhT9fLD22TBMu/VqmqbrEhq7R5S77tK9T91HGfmfdSRVOJDCSg+hab9Xr4nsfp/0AfAy2toPLABsN8np3ozDLAHgTfLI9aEqr9mxqd1xFOBboTvgavr38JAi39z3bzz9IPF/uvP/pPN/YfH/pPAvivUoKyzR8f89Ng2bXTZiANY0aUKCO4A1/1onJ9IajCkeV8PXXCcexOsgyu673Tki2qfiPapZ4FE6wIvvBzrerxMrw5BN07w8X/Vaf7AAYLwXs7s9x/w9PpJ9fOSJDxUBHorif7eT4n+aG5m+Y/FfPt6XxjSe/6IsBKMysq58fgIRSaTwH/hjJqQln4vz/FLiKSHQsRdKdv9fUFgsKKjnTd2w8Gcw/g8AgAAAAPjgQpejpEYpNOWgLw7ZufN4Xh7yKUOkWYFkXU4EqJs8Fm0/wUFo1umXwlx3bIu9WjMOfHDU/fuuS0U9Bc+F+NDnLqpESyXRQPasSVIX0v5/8ecczejFQ0CKGD3IHo+vq0gxebL7XZoGSF+33Hd+jwKk9EIoCpE3v6bS6bRSCPJo/5qquzv2PZACkItAybDvJObvqAP86q6/JiAYk5MPqpqorsTlu6awWEoGeEtBY8DalkJTCgEiArQLWatw+XPr96qj3YcD///Wa/57PpAlohgLU7uyEDmnSC+EHBYBZeJEYhZPdc8/TJALIZvcHTjq0m7WVD3ckX18IKvXXKc9Uud/mhtpvnExHk8IYx/x6MyEODXk1NeeCG4s3EoUnbX0m886vMl7XfJVkVU3GkYxuRzz/Tk8Lf5/9H73RPC2knRTVRSalkLb8n1gtRITwCZNAmH/HwAAAQAA8MtIJkjTWHSsJxm79a8yj4rWpL3mtPtc1WIcl+MB36VbfGaRocZy5APZvuMCfShi0fouF/zqIC2HSSsZ6jR57jgPQx5b7vs8NSATBFrkJ1fqKZv/aUE/WzVIB1PKUYG60+t9MSY+ZPf2cZpfvzcqeJ6KJmwSeexjYHx4u4JICtHk/r7b5XWHx0dx//+eXN/dbpsi38i/roCNZYGc/A9E0Kpk/UEmW8JiIQU/H/pD21JcLCkslxSurvKfte1cAGha/pxE/BqR4sAk4zs2eSQxWnQaAecnilVNxo7SUQz8Pcpz5EVTAM8axEWiyaf/d14F+kARQI3b1ONisyG7fmSPi4cHueYPnAKgUy9l57/Y9zfv8fw/fn6Uj+lH3Lr0nmltEqGijJfrc5Ss+HW8dyznpxYB9P7B92zbdewlIT/OTBPP2P9/KnhTeq9j8W9B1Mi6T9PwFEAlYiH2/wEAEAAAAB9a8BZGduU+O+m4rBadVETXveBARMVhOBaRZ1Ei4mIyjZMuiJPR5191ME37xT515tlgriPT9ckN3R4OPIKtzugqAoyjOG8PvGPuuUNNGqk2G6We8rh+MgScijFrnzv/p5IFnnSndOSb0oizriOQpDm8ZQF06hqnH6VrzFFrfTaUe4vc8WRWKa7/qfh/lBUA6QSvH5Pru+bXp+mJC7rA8dT/Wff81ctCxnrDYsFO38sVheWS4nJF/uaGi/+rlfz+iseBl8scCaZFW9NkIUxWCfg5EImCJ3s4kLu/I7KWnKvIjCOFw15GmHuKzpGxhsgX3+tLi9Dy2mgho1M/Lid5xLp+ci/4kNdmzxM3drfjqMvHR474k7hL9/hIdrclo6aXhanmi+9ZZxb9zyZc6GN+7gTGJd9TWrkRTxXxUdExc1IRgMx8IutP6zqXay065dbn+zep540vJkbkWpqXPjeM4f1/l93/KUUA8goAX5cqv+eh+w8AgAAAAPhINBJJzb1MGn0XM7pTnf9LDrSyD8lGaFXeh5aP1AX56IOp/r/SDv+Yinp7OEjG+D4X/hoh1/fsHK0xaeNE5rCXDPVRDph93uufxuwfUBr6FdMVaaQ/xS4Wh9bkSVDsMEuHV/+M3eK10I/ZJ+Cdzc6ycCQfk+dJCEklCMNIph35oFxVl13fsvjvujQC7pIAcM8igIzG291OzA+73AVWIeVSoaPs+mt3VU292pbCSgr862v++fUN//zmNv/Z1VUu/NuWO4F1zR1CZ3MuuIoMmgAgRp1us2FRQCLMWHhoudBQjw35Ps05Yt1zQsDRr9PjSB/7GjUTu9pz3OOOu/9q+CgCkN1u+bWqUW7FNb/kuR9/9lw4FgC02Nff068tvx/fYf0gC1Iud5zbNk9ZqcdEXSeDyWhN9gb4k4pPMVslXd+aRn6eyOh/WsPyIU9dnWOimZ4LGofKE0Fc9Ld8XZbL/Oum/jOFGAAABAAAwK8/FKUJgKGfjY4/iQC8pPg/OuAkZ2Q773xEnQr4yHFI7SzqSLmOgWq82F73jLdkD/prKSzFeV473WaU3eRxzF1/7UCGIvqvLEQ1OlCnLyjO9vRT5zc97nFWUBwbM5ojYeBD8r7le1TXeNP33IU9sFGdORzILg8U2ybF0l0kAui1GsYkvrjNhuyjOP8/3HM3WIzf7G6X870vGPt/LsYydf1lxz8sl9zNv7qmcH1NXn4Mt7cUrm/411++cOG/WlFYXfHfVyMwFcD0ue+Kke3SWJF4RYesITMOSWSITZ1cxJ+8doru84v8Oo4K/phMOW3hc2CL17T5kNeoKdMedlty6zULP5Lu4B4fZq9Ljsv0bx/veFz4S7eXNLYxFF3/wCsY5QTPu0wDpGkUk0TVIF4TSVxyxcqVdZ/LbPUjCSJqBy9ipRb94usyjMmE9Zz9/5PXQ6Z4Ys0eHywALvnXbSuiN/b/AQAQAAAAv1IESPFaQzahk3FIimEeAfiTg+zTP5HxVIlGSwWURKJlp/gPGoc86vqrCzQX/bvknG83Gykot2ns2O53PBUg5nq26ySObkgmcykGUP0T1KFf89N9YawW8+FUC3xzSmyJ8fkiorwup3793o+l/jhNZAd5LA976dLvkulVEIOyqA7ZL/3+iu5/uk6bDY99b9Zi+veYRsDtfifCzCAiSzi78Jp19cpDvZhWplH/qysKV9fkb24o3H7hH798JX9zS+H2lvz1NYsDV1eFF8CCn/vaqVUPAetmaRkzM0XvyTjHY/51LYWDfGihXAh15kj8eXHxoteknEJwjqLh3XKSNZ6ZEPCezzNZIbFdX7wON2TXm2T+mF6XsoLzxLPknKfzCSGEiv8rd85tNixNpqZ2VvxrlGfU+2Y5HfCWIoB+T8Vzk59b7DqfXOjrOq8C/Imu83pfDUE6/kMWb/te1gCGLMS+dv/f2TzlVsljfzTxFiuZigMAAAgAAIAPLfyjjPtrCsB0FEt3KgLwJ2PUhp53S09dflusA5TZ5+99ME3F5JQj1Q4HLi62Wy7612Igt5EYve2G/0wLED00dt1MNEnu0WrGN9vjj7mLXx5Iy+L+VIFw/Niri/+PhIDnfv1exX/IKQZsrMVj2m69pnB9nUzuyFgK1uVD80tFAE1GkJUC7f7r6L9dr0UQkNg3NbI8ivt7yTPrh8/bWqIrpaPnb265uP9yS/7LV/JfvnDxf3tL/vYLj/5fSadeR39TFGA97wBqIXDqNSD+CTqSzJ1Lz8Wuvn4LozsTXjH1YQx3k61J+eXRuVl8YekH8K6vV5mGSa7/+z13/zXecf3IQsB+x6/hvs8eGmeue5y87uXah47YO5kAcZLfntJLbJ7M8Z5oHChaR3boXxfL+MKiU/f/eTKlST8Pi+XcZ8UeT3H8Se93EgEoq17pYxhy0k1KX7mg+Kc84RZdJSkAddr/j5IGkIRvh2M9AAACAADgVxAikcb96cE5RSX5iyIAZ+hhs+igUlVRbDUHWSIAKZsFvmvBqvnx/cBdfu0oardfnMXdWrrJa+kwHvap0Chd/42fWDgJPsX9pWI/hqdFfvnzU0X8jwr8skbRcfpnRJfy16cyyV/D7GuFwNdUHf97Xo2wWzHo29xQWK3INg3vs6eiSiYBfjYCqyPUpQncdktmr51guT5bjX0roxjD5SsQ+n06l+P92kXe5b+9oXBzS/6vv6T4/0r+r79ZBLi5YXFAdv+jJAJwd7aSrr+Z+1787NuZpiRWGV1N2e2SNwWnPYx54uFcAag07NTro0ZmTVMUOPJ9u+p913XkuqvYZovYP7tZs8/DViZ29ntJ3hjZcDK+TgCZmTwaSShRw9LKEZU79fIjGZsMN1k4XZDdbimKQEPkX7yScf73qnnzTYqeVOf5JAZUNb9OdQXgTxz/n3xKVSHvZW2rSzG4ZhplAoDSjz97Hj2J/yOJAKx0TYinMdT4k/0+5D6A/X8AAAQAAMAvORQVsXcpNk72IfnAFPLHCw/W8fggb7IYkHb90/4sx1NxN5je70CkRaTu6h/Y0M9t1hwf9/jAAoCayakAsNnkIqPrZM+f/RFSnrTnbv/s0Hiq8J89Jjmi7WcF/o+yp1/z67eCow19norQiQoRUNxyRbFuyNbFKHLliKL7+bpCcu3O3X9zOJDbSgG826aJDXNQ9/dpXgi/tOY8WQQWxf/VFe/eX99Iwf8X+a9fyf/9D01//8MrALe3LADcfuFJAS3+pVNMVXXZ61QLYX1cVZTSiRQpYEgTJC5Ye9DCP4l0OjJeVUnEoEqizJxNsZ7vJQCo8Z++Vu16I5M5axHt1nniYxi4u1t4aJx13cvdfi3+U4FfPzEtDYtlHuc2hmJVsY+KfC/2sKcoKwBU+2T4+T4vQKLo5Lmq12qx4G6zTK6wiOHypNWfRikkqtP/OKWI15TIUq5lnSt2l88d3f9vuetPjZgxLpdyL/hDhRgAAAQAAMAnEQE0FkmL/2mS6DbJcj8R+XXOTjHHIsles3QVdbw4j7Da9ysmQh7ttDJKbLdSOGp2+P09ufs77iyuH8lpgaFGdl0nj40aRQV+fLTAL4uOH43w/6DAPz5omt/teSRTAHYvMW3rDYXVFdmrK7KLBZEUU6FuyDjOq0/PgecO7UScMKDd//2eC8DNmsWF9WPuhA99ivwru+AXjf5bceSvK4nsW0lxL13/r3+T/+cfmv7+m/yXv8j/9ReFL1949H+5lH3/hRRfrzjsizmn7TpZqxCjw82a7IYnIcxhzxGTksBQenWYn4gAT/7UFoWkFjDaVdbiv6rS7vu7FWuTJEp0HYs9MuXhHh/zWs5eUjhUADkSfcw511z+7zPRR1YeYtvm6EYtrq+u0uOj9zgziQnmfs+fS43mxoGiteIB8tbFv5mvVOlkQtPwiLmmAZS7/3/k+H/2V9F7SRa8RewuJuDOFrvL/X9JY0gTF5UrIj7VkNG93/sdAAACAAAA/Lj4n1KHdbYTKQfwfCC6YKyYKHf5kxGguiPXs5iqc8ahz/4/6v9J3P2566+F/50U/+Ii//CQd/73Oy78xVlcHw8TjqIRX5CQcGok/6M69B9xuDaB957t4UBxucqd6v2eH08xAjTtgkzbk6lcUUg+X5Do89CMg7jA7/KHTmYc9vxn/VEX+NLECmt5f7euxOV/ycX/l6/c8f/rb5r++S/y//XfLAB8/Sq7/18oLpb8bxoe86XX7FvHmKLvzH5H7v6ep1WS6eE9Pw6deFKIaFcWMOd2L8lQLiTbluJCUg4ktlCNC991j1zvS/p/7zop/iXqb7tlEURTONLkQzzL72Fm9KjFv5P1pKZhAWe5Ykf962sRdq7Y2HF1xX+vXcyv1XZL5BzfTw97il1N0Toyxs6MAM1b+HMcJxIkk1Unu+g2Pw81XtLaP7b4TwasaVVjlHu6T+P/Jvgn0pB54XWIcg2yWWidYxjV90PvewbFPwAAAgAA4FcU/1ooTWPyAdAuSBqHPI4AfKmL9XE+tpNOSNvk7HQ1VUvFxBsfijTNoO+5WNztuIhYr7nwf7in6u4uj/0/PhSxf9JdHPixMZPPY/4v6BCZF/7ev+JwrT96OVj3nRgr7kQEuCa737MR3tBnEzt5LKM63Z8yv/NTXk+Rbi8X/ru8BnA4EI2DPIfPj3+bjYAnw79KnNSXvNd/+4X8179o+ucfmv77f8j//bcIAP/ISoCO/C9TrN9FBXJZxA7cTbbrNVX3d1Td8Yd74NhDXU8x3SGPwF/i/i///2iLXfdi3D3tljcNZ5fr33kPB/PSqb2T59F2k1M4tpsUM2lS9386W/SJz4k+jUTpLVcStXg193S4vsqpDlrYOUfGe7K7LZGruMvcHdj34pmi+zUeALF4rHSPXDv8sa7yiLmkN6TEgj9459yoeWZhlpnXAZ7p/F8iIKYozyqJaEHXMcoJgPeceAMAQAAAAIDnT5LiID6M3D2V/fa0U+snMlL0mnMz5TXCrDgYRetS5Fk0MiYpe//qC/BmBal2ePo+7/pvt1L4P5C7u6Pq/jt3VO/veLRYCw01+uu7POp/HCv2Qpfof+2Bmk54PZAYHw4Dr03stVPPaxfh+pps31NQszY/EQXxAnimEDaBEwBs36Xdav7c+7zz3/f8/C3d8M8ppBTZ3+UR6pYN/3Tn/+tfNP3P/9D09z80/c//YQHgr3949P/mhjvCx13/C4r+tEqRoim3VH3/Tu7hjtzdN3Lfv5H7/p0nVWTCwvQdd8EvED9mUXca8Ze6llK8LJa5iBEHfHqP1A79//ty4oMncZzs+7vtloWfwz5Ft1GZ9nDudVejR+n8c9dfJj6u2cshfOWEB//lazJ29Le3vMbUNOz7ttvxz2Pk52O7yLGmx34fr+z+G3rG0FOedxyxymPns3vwn7pvLoasyVhSx/+9zyLxVKRonGsimd7rCjFJpmhC0+Q1DPWSsA67/wAACAAAgF9ACCkBwMgEgB36lGVPkmNNk39y2jwnFimN/utYpO5Dti0foJMrun39eGrR2bHDUESHPXLX/+Ge3N1dGvuv7u/yHrkW//t92gtNhf+Jjj+Ob08fe1N4LZhBCnMxBdTUBJKxW54CmHj9Q2LuTk8AeHboFif4HNu4K1z/h+RZcc41mo2Am8Ldvml5WmF1Rf7mlvzff9P0zz/kv/5F/r//h/x//Vc2/ltdsbFXivaz5z1X5f9pvE/Rm7bruLjtOnL3d1Td35G7+07VNxEAHu7EAG8v3gfymB6JVPGM16r6dGTX8mXqgMerK1kHWKQow3cd/x/GJCKZw0HEua2sAMgEQNfx//lo5eOs7yjt/Nscn6fFv058/P03pzv89Rf5L39R+CLRjuIFQNaSGUa+p1nLY/8SlTiLNn2Px+p4yoooJaqQLUQ1jJvzwxAiv7d5NmUs41vJs3GoOaP7/2SKhIiFbeeIqjp5MKigGHX8H91/AAAEAADAryjWOBaJi33ORp7EtGqQAm2arwmc6aydDkZlDKDsorIjsny46m0Kf434E8O45JCusX4PvOdf3X0nq6P/GiemnVQ1kpOs6JN7/p+s+I/HxSw9jf17N/d//Rqn1gCmKfsu9L0Y9I1SrEr3LcSUQhHLaEQtBPU5qj4A/VC4vovAMPT85z4nWpxt/Fc6/lccpxZW7PifDP/+/ocnAP75R+L+vnJxvFrlKDgVLX72PFWxRCLJ8v9xTHvvKeFAR/6/f6Pq+zdyd9+TX4XdbdPUTupwXpJfntz/ZfJh0c4N7xaLJHKQ5JfH99gl1+ut3f/9Ln9sxU+ivP7j8ET0Obd4Vpf82LR57P/LV5r+YpNH/9ffNP33f/Nz4OtXCrdfZPyfVwWIiMzhkH7U1YhI5vlR8ld6AMRnRIDobFHwy2vJGsTN6esyeL4/eS/iEa8EpPtGkI+je9y5glKeAChTJKoUxRgd3P8BAP8/e1+63TaudFsAOGp0nHz3/Z/vnM5gWyNJAPdHDShSsi3JctJ9GrWWV+JREglS2FV7yA2AXLly/YFCcDUI2EUQRcCt71IsUlQGgNeAQu2KzDnaRIkMVY2TkboCKD9ulJYi/jAqDmPiMCPePf0iEIXT/+LHd2kKiNkfRakBGyGe0YP+zu1aPAPirwEF8dYN7D0aSwDilSDridcXrTHtyB3fkpYEL80pZGUcKclhr4wZOb7rOiAY9aadgWDhSPdPE/DlEsJ8AX61wti/1RrCYomU+LoGKFxyrI8TCrqmfZNvBsZFkkyCQAj4QUwq2XDyfPPqh0hVTpIPOHv+Wvq/OgY8nRTd8myGTZDZDD+aGTrhUzwg3DtOjq45TCPpJXnD7nbodUCmkmbPrI/+asPHc9R/zGwvU9LDcoXn++tXNHr8P2r6PH7DBkDbYjOkrCA6C8YHsGAgHvbojwAwBvfnZEPXmDNecMeNZkLzj/TXz/lq/EvBP0q52MA1EGMo4j1GewO818Q7914nxx6E+REd+WSUFcYylhXeL8y/24shV65cuQGQK1euP1WsifRI2YYBDbfM4SD6fxhQH6nj1K4GomwsxptsV0gkWixLpEty5FjhbjNM80jTl2nzfgd2g2Z/Ap54avrjO37+/Kz0/qQjn1L+1Wv+zK1afOvrU8NFfXzObe7jB6ZXN8MP9XzZB4A30T6ZSWK0pFfT75Cm1ueOQoz45RiSCWBH/hTCKugBejJpvCK6a3Q8Y0yRdtyk0k2AOYLgSC74KBOwYPoegHT6IGZ4BhsR1uFr4uaUc7JOharOiRtDj7FkxwPJJXakdX8B+0Kxd5xYQVN/qzXwnXrt1553cY8neQ5R4EMzQzNDfu1NC7GpkzeAKz4FwGCMZEfSEWJBvDxLdKfZKzaJ9jy4tlgrz3F/3PBYrTDl4ZFYHv/3/2CQBsBXXAvtLEU7RpRQ8bE0IYp+nCfLIwnRpQaq1wDP0b3ByHrjhhY22sJdHvcf/X7HcbcdMdyGgRqKqXF2zj/krUbNiYSGPnTcbRTDP07BsVmSkStXrtwAyJUr158A/5Ho1z6xABhIDynqzoRTA8DraMW0GSoKAGsAyjRh5KzqUab4tcZpHF/Y9QigtluMB3uiWL9fv6D4678I/MkDwD4/g3t5EX8AyYEOfhwldkcAHd/auJ9s4s+DtLPffwPwmj+xrs4AHFkxPCFjqu1bYF2BKIlx7LvEAug69AUYejSpnExYr8p/F4mKEeduKAs0vCsrmtwR5Z0aF3a7xddw2Kc/6Oj7KuoNPH6O+e8I+pnyDwMZb3bd2C9ht0sgf7clf4pNYqrwuu3Y/V7ll18AWk6uU2posKN9qDHjHtkPczS9m8+xIVDXEMvi07T/4NFzxByPyUSSaP8sATiZ/l8h+dDXkDA+aEIbZvOx9v/bN/xg8M9GjwXquuU5h5CaPdJYnZgx8tc/4/qM2rQuGa/i/Tzc7mj/v/aeJ2tMM95YYtTLNXo55+rMfZvjbtnglhMgStX8Loo8/c+VK1duAOTKlesPlDId4+ksGiL10gRAsBISWLtkHwSnCcpsAMhgSsf/iTuyvTIBQIP/Y4dxfbsduM1LMvr7/h2KH9+RNv39L2oMPCVn+v2eDBCHs0Z/H92ixde+pkHya8B+tKFUv09fHwFe/cG/d1eK8euvyUxfF2vJFbAEl4zWRlKPd863IYaANKR4jXbsW4ETdBj8VWv0LBiU7O6UBT9qvpBzeNzt8DXsdmCfnmiDb4hKrIwMJ54Z7LOBzQ+PchNmAPSdpE6wfIXBvzkeKepwk6bfTPvX4F81X26Z/nMzLrQz9DSYI+MhzBfIgpjNCPynGLN7u//jfcfj8RDzSAL/uy1FcnaSTiKSj1ti/4j6D4r6HxYLCMsVAX4y/nv4AmH9QGaIavI/BZYAyHZh/5SAJnN8T4nowGp3AAAgAElEQVTG4HlRP3+XGMDXmoKsd5d7gvn3ms7x/Vw1tKEflHFoUMfsBrNX3fBTcbeSbFPXZDJJPgDWZk+GXLly5QZArly5/tCmKPgEpIhOy5NVoWr70032RZRIDZ6YbkvmatIIKJwYAcIrWdlvg382hjsm8M9a/+9/oWP6zx8UmfYTDdVeXhSNuCPn5w+YHL4D+E826VPXbv16jTbrUt8jEy/DlHhDj6XoqkY//0+a9MX3QNU0T51jr+SjIKp5gSZYFzhhj/K5A9Oq/alJ5S0UZ964K0quUHjpWJsOqehxUxIToYOwo+k/xVeCdWP/AUt0f72eJGucYsjIywCGgYA/RU522Axg8G+Oh+R3wAkdfUfT7w82rfT0n1I5Yk1GeJR+gPKHOere6wY17vaTDMy01IOjHXeUcrDfk+zjQLIJf1VU23SdRrkflRhvuGCfhzWE1Rq1/2uM/uMmCBu4na4hSNpy74XFAIr+b2K4//HSKSuT+8g0gjX+y8GmCWM5m4nEzOHmrw/qe/E0tvHSc2FSA3HU7K4bWjuTe3uuXLly5QZArly5fn8jAHAy2eMkHaYGgOf2OpduiNiV2jEdski0W+cwFoli02LhLptQaS3nMCAo2FE2OBul/fgOxX/+Q9P/nwj+n56QOs0GYj2Z0Z0B/ua6w/c+4J+CfJ3LzZM5Awn800YxTqblUVOK/ZCcxH2AaOH67Oq7gI8xmIxFiTFyVYWAkaLjYlXR+aaoPI7GkiaAOX+u+c+LXhflHhz5Z/Sk85bsbm2aFiPFhCUzyXgoke5PQB02L4kdoP/GRP5ggsdIOGbQeAKsnmjHPV5rlppQ9nAQI0Dx4ei7NPFmuYNetze85hMgTMyHSMacYTaDsFyCXy4hLFfgFwvU/7czCHWVEjvuXewX0Q8I8g87MUKU2EeOkhz68bT2kuUKiT2D1xgatAWOO5zNICyWCPq/PKLZ43vgHyA1oDjCkfwtTEislFFzTq+Rj1x+AGieOQX+kMA/J1rgc/D/XgmAurYhoLwE2Atg1KCJtzdR+dgDSkuAGUXWyftg8gLI+v9cuXLlBkCuXLn+wIbI0AfrbiUBgI2rejJsY8fkazatkofMTYCCnLYLpFgXFP9XEPW/LC8zRdKAJ3iazh5IH4z0fs5KL358B/fXX+CefoJ7QsO/FB2mnOhvNU97D/Tr6ZtV0VxWmURRTne0FqAgCYRMkFRDhKd5WrYxWDBmgOgH3NiCuZvB2NWvWW12Y1kkA73ZDMEVfWAzgIzkrMOD/ZokQGl2jRgIBlmTTBcHfz2wOWGpMHWfmSVdB8Y5MIUDBwC265Aa//I8Bv9T4E9a/2gtnidDhoDGoK49KBdymjxi9GaffCw4hYJp7gOucxOoeaDXrJYY3HjegKU5dY3T/vkC/10swS/IA2Axx7i7oiQvD3v3+5GwjajJYQ8kddAMCDJ7BO9PGB/m0vPNDQ9nsVHVNBBn6HPgV2vV/CC9f0Osh7d02+IsT94W7DY/DKfMlDtdn6NGzrQNKU1Skp2E+GfuDX+3JgBEkeGYvqP76JCYOP46L5F45r4fSRqDKRl2FP2HkpMiNwFy5cqVGwC5cuX6Uxsi0kHyZDJERYf04435LdFVWsNureQhh6pGc7WqwilcWSaK6oUMAJwG92QUhoZp7ukXFD9+JKf/79/B/fpBbv9JP52o2Le7/L+Wwa2nqkINN4CND0NRXZwBza7rLmlF2QsBY6SK0d8XMEgUafl6DAA2AJwha3wayVSDddH20xS5riHOZgiiSFMd+P9aR86mWNZC1DnloyZAkIg9MaVk5gc76tPPmCto8CeQSQAomdB1BiyxK+Kxg9DUYDeb0Vrlx4vWputDGwDySmHZBgABwijUffE2kBhD/D+IzKFPMWUa+H8UyGntf0ka+Ib0/isCwPMF+gDM0PUeDRHLT6Mu4/mkKMOhT34Ix2T6KNT/EG83/6PrEiUPevq/QPDPMY9zXq/N24kHKsFCjCop1lH8K1hO9RkAPJ65I09YLeCIYfNvBZ0hUAPNi4wHJUR98hkRD4DLz5HcR7Sfi578i/dNAWCI5ca/mCUAuXLlyg2AXLly/f4GgAItlNMOIdA0ktgAYaJjvhpk2DHNmN2z2fivKBHs2uvo/zilTRph9/wE9tcvcD9/JNM/jvp7eRHq8EjvfyP4P7vR5o0fg35rKNaQ5Q2F/CtA3xW4MXScqV4kjbxFGUAcaVS9gKIUWTUkDfLUFPDey+UERCngXxZpijybIXgSTfUDasl5mtw0EGv8WShSE+Csrlxi1cKYDcGU6xgIDF7/mqebdxMCHu9+UI2mHmJVgzke8LxNmx8M+KfTVe38rkDIqKHGzJsYEzuA3OPRuT2MYw1foftf3bhSIIUd8IOctzn4eWra+MUiMTc4reOz7kUxyDTWsskhGwGS/wEME/mDel3mwmsV70WWJCo1ShvmC/BLXKuBGwCzGU7/izcMD3UySk/3lsGLeapoyyGO76P3uj5fSwzhx+CmKpkQ/quL2TdxkooQxvp/+dkbGsHRGmE1oaymxHtcUULg+FBjM/jPlStXbgDkypXrz5bx5KzOemOerHo/TkS6YNN61iTO2ER3Fw+AIpkA0iT83U2RztamKbjd79At/fk5NQHow9Lk/y3d8LXbsPgK+EdQj8Z2GBlHAF8iDgsITY0/Q1+LlDfPDQA8HoleHZ0TLbrpMGveOgfRezBFj0aNMQFLc6Um+mbwLzpWApDKPC7WDYJG1o+vH8A/PkJ4eEA6+WwOsZmhRKDABkh8J/5RUg+I+i3rM9wp3kwZfrGu2sQIxg4QBwem65McQ0/69GO+Rq+ePj89BVa+BRLVNopzg1dfo/nI+RPqP16DoVGRf4sFRuCt8SPOyACwabCZ9VnO5TFp5WXSL14IB0wEOHYplQTizfR/uQ9VVZr+z+f42hcLCEua/LftRawH1vwnNoLyKGFPgM+i3k+M/k5YV46iV+k+/6/2AOBz1ZOPxtAnJsCgzUTjyfq5pLkURfZm5T0N/2/HxqhF8gXIlStXrtwAyJUr1x8B/+BZY50SAVhjfW7q+Na2xZzdcNux7pamvpG8AFATeSGw4Ok/xadZzkvfbsE9PWET4AX1/na3pbg0inqapBl8GPyrTXaUDHWMNpSkg6YhB2gEEqFpkv8Bu0MTU4CN8Rj0mhAQ9B/2YHYWbIwAQv03SU+u9dD38jJ4ZZObYq4IvFc1Tog5Ro0z4xfzNFF9eKDJqmYA8PSf2BLaB+AMwMJzn6jzAJA261qucu1LggmFNygqsDH0tw0YAVmTxXDu8/hKE0D+P/58BPin19u9AZvy5IgVrcu2pYk/NWxWa/y8nSUDwLL6POd/Pg6e2Ed+UKAfUxFQAkLSD2FLvE//P9H+sxlbla7B0LbSnJLEg/kcJ7ZM/X/rdcdAjv/k/k9yDiP3nHDaRGUJyb0Po2amkAeAxGNa968G/xB1koii/1NcIxreRjgNsb3gmuLiRiGzo7jR68aN3RwBmCtXrtwAyJUr158piiMzkVzU2bWaaasxfixWzhjROrLpETrEE1CuG5yGXLoZ4gkhO7STm7/dbsFtXsBuXoTy73jy33dicHgX8D+KuaMpD4N59jZoWwS5TQuhadMkkeLVoEjpB8IGEC8EehjOQt9sAIwB1/cAOzUVJnCBU/GQmjWfAP5HZ94lZkOoK5wQE2jyq5VQ/8Nqlajkq5V8L87mmDHPa6AoSTLxCrjU6087nGtq/OT3rn3tJ00A9XgpDsyPp/8TMHfR9/RzPUcxfke68eG8eAb/zLyoKqT8L/HcYJMGz1eYLyCs10iPb+pk/PdZoCUE1P1TDKkZvEQiJoZSf7UHgpzbkfs/sVb4Gp3N1eQf/Q6E0eLekSbpa857ZeLYkV/HILrzkbb8Gi+VS8Ans2RYRsL3KQH/yoT0dwLP987Tb3ouRjEypBnMfgB66q/vNxesMQNnjAApVlP8XYqCGGHu8yQ0uXLlyg2AXLly5bpkwy0bn4E22ByzpiZs11IiX90yaf2/mpLgVO4a9/+QAMHhILF+mAKwAbvbgt1xzF931bTw3dejIvoi6/mrmqbfNAWfLyRTPLatAAr+PjICKgjMEKgrMoqyEjFm+gFfx3YL8XBACm9E92qOhLNHisPTLuOfoP0fbW5pqoXgsSSwv0wAf7UmA7VFcpNfLJKrPP/LkYDkjB3fkn+ww3mMyThrAnqmr/tDwCrG8+vuTMzfWbD/Gvif/s1zaQd3Avxnzx0BE5GeVDUxNsir4QHz7v2XR/APX/B8tiTVKMvE0PgkkMgATeISh57SDzCalOU7Jvirzvcpa4dSR0iCFNoZ0v3Zt2I+T0aVrjgf+3f2XurpXkP+DT4IA+CucpXXwOdoDZrECjLTRlo42zT7FND/3j1pavr52c2ASdxrWnNBmuHynnfNNSYNFvS8iXKfnDC8CpJjmJwAkCtXrtwAyJUr158qdtPnj77HzStRWQ1rbW8BJioGMFKmvQBnnsAx+OdN0aUbOP2cjx3KAAj8G2oI4MQQTQxviYk7+3omUXfsIB6bFqnS8znq3+ekgV+QprpuqBkwS3nipP9HRkSZmAnHI7jNBsLQg9nv8GucdsA+AMcDRRl2It/4LO3/yTGgyDih+6/XCBjXBCBXawjrlWSnI5iiCMDZLIF/8X94JQJQPaZ4SJAbforAUzIVuDNlfgpczoG3c82Ctz6/4HufBoEY/Jclnj92vV+t8Pzxx3qdmBxk/geuuMyj46PtCtb/d11KAOg7Fdvpr9b/T8FmtAaA0khwyl/hddy0qUlHx+ii1xwC3jNJooDypI6SDPwkY/4TGjxTHwq5ZsZeAMJi+Z2gP2g/i3j66nXyy2c3A9TxZ68bNJzsTtJEbm6wQUzUfpZbTPwZ4m+5lnLlypUbALly5cr16sZ1SNRIAdWkXx2BytvAld7cRZ70Kgd8ps+PNknv7eN9SCaARwLEux1qhnc7dAynTPURWIQbY/709JSN/qoyUftpsu3ZNX29xkk46eDDcoVgq2mQLdC2aBBVOAgVu0IDQIgIeLyH6BxYohOjA/oeX9tuK7IHczymBsdHsuDfO96QKNQy2SoKBE9E+/cPDzB8/SbNADwmczxGpLGOVZ2c5MuKzP8UG+Stc2/gZH0INV9Aw/1eOWuz35L53/r5uf/fGUaPJ8Paf4Mn/zTt9itq3nzBj0BrN6xWwmBBmUbx+RPjiEkOhiI6pSE5pEQSju80iqZ9TUa7yJAsGW5WlTTnRA4g7JTiqlQSfR+FQTUBgsqVh89J5xgxU5glxektPqQG6GcZz01BfwgiJzOvSTbEGM+IM36cJoHc67kqDxEghoasowjk8zExatQSoAubSyKvkPc7m9gmzPDSzZlcuXLlyg2AXLly/VbwzzFqQ4/TK72RY0rkrWZkegNnaePjbJo+VrUYkJ38zgWbbYwA7MAeDmCPe0oD2KfpIW2+zY1T8bfBv4pMY9C/WoH/8ojT1PUD0qlVlnhsagQadS0yiKiBL8X7wfGAUyluZmxewD79Avf0C+zzE9iNkjfwxPFeufBvHQujNunk4YCZ8az9X0NYr2F4eEQguVxBrNFdnmmwUCbNfyzc5eA/RsRNEt9WKNmAPa+xv9EM8L2v3fPzzwL/o3Om4/5KNKdkt3u/fkDg//AFaf+PjzA8PqIPwGyOxn9V/bnO/+ocC/OI7k88TRd/C85x1/epS5tXci3TOmZNdlUh6J8n0z808Kwvb3pQg9SwjIqYOhyryskVH/JSuQR8armWunenxIxPMpVUfhx8T0IJBDvrs8mluhfbBPaNmKg6MJYkGjwhv6fsRMk0xutLNbuncaLvHKuz3iHMeLNolArs+C+JDJn6nytXrtwAyJUr1yduqt8GVSqmakgmW8wA+JBmVWsigSfHLmndeXPHG6YLJ21GP29+vocjbbo7MQ1DR+54k+nfyStVUymM6iuRyr5YyLR/eHzEBgABf9ZRh/kMDcV4qsjgtSBJBOuG+fjvcdLvnp/B/foJxfe/oPj5E2MNX57BbjeYatB357XFnwQoZRPurACoWGGuNUen4ev+QnF/iwSiRANbJM0/N4Uu2eDLlNCNXLRl0jalEN/g8/CPvszPAd1pNGXhRK6CDSs8V/7rNxi+fgP/9Rv4L18hrB/A66QGZud8NmjhybHIkAZktzCTZxhSLGm40e9B1gs3RKgRWU8SO3j6f2njgoGv92MvFUoCkHx57SVxhcb8XQCqj8XUEyMk+r1M5e95r6AEDrwPeRWtR2yNoUfArU07R1IqpMSbopQ40FiUYGJM7wn3aAJQE3Hc0AYwMYyTVPR7Hd1Lrl1fqWnslLkrysWAk25sTgDIlStXbgDkypXr3qD/tSgxBsPBK9B8lA0rcGSU96hZjeFks3ox5XYK0DTwKwvcIJGm/PImQEhAIILaZPYEFnii45Pm8xZNp34NAGPDv7rG6Te53/s1RqYh6H8A//gVwgKlAJHy1fVEUTLtmfLcdwT6n8A9PUHx4zu479/B/fe/4J6ewD79oljDjUgdWK5xDfX/Fsq5nnBFjlAj8zQ0P2zRC4CYDjJJnS8gVhXFO7pkfnXLdM8oWnCMYsoWBUTYE0O9z6LX/x3B/wj4qYYVX2uxRMZKnM3AL5dk1LgC/+Urgv9H+pdZKzM2wbuCBn/PYid9P6RGwI2NrtPkDiPsEY7cFDPAuiZ2SikO7heVNv+TqT9dn9zMoOm3uTNTZ2oAeEJhHx0z/vzO4F/8Yzo8bx2Zk/YdADcENKOMzkPke0OFUgwYSmwEVIE8UtxYxnInwGyCkmf0xKKKZxJvLjhPo/XFJqUkaYi6IWAmze4M/nPlypUbALly5bo76GeKv9r0GU3V9AMC/z1p5o8H0tQr6jxRbk2I1+dVj/LiVfwRayKto82SHcPX9zZG/Np44qSmhjD0ohFOJnEfnLQxULXsW6D07yXSh2PdkKZ6DpGm/aFthXKNIIFkCzEdS9PTxH+/B/fzJ7inX+B+fIfi+1/gvn+H4ucPcN//oun/CxkbUkKD9x+KNLwJQKnzGguXDOVogipO6rM5TVJrZHuc0/deSinXpmZMY1c+EiMWgf74bDPEPwz4X73WhFpNJpVlhQ0r8alYjhpV/us3ov2vxcNCIhqL8nNj//Q1HTVlnSbVQtUOicoeT+Uul2a0R2lGmuRnURT0WrEpiU0rd5khKV/XIWLjtEfpjumHlEDCLABNLf/UazYqVhf5pPgBTNe/bV55M/jv6fXuybRRmZQej8je0E0AALU+S5GEiVyobvBY1gEgVuM1/8G1KO9/IdA9NPmnGP+6jMpc8V4RdcNb+6U4fL8TM1PIDIBcuXLlBkCuXLnusXlW5ktGjJ8CxcTRBpRdqr1HQ7nnZ9SWb7cIRjuk0wvl9krdqqGNdpqcp6mbOCMXLtGT5W/HVzPdzwJCpt32A/oX8Kb3A5T4134jymtxaeNaONSz8xQaADe7MWKWeXcEWzgIAGCOhhoeRml0A/7Mdgtu8wL2+Rnczx9QfP8O7ucPZAD8Quq/3byAkVjDQaLFfjvI1X4ONmVcR4dmhrEsJTYuNG1ifHzQ4XsE3JwbU7aZYstGiv9jm+r43nWgZTSkL8bmTCk59gL+V2sE+mz69/Ur+C9f0+R/tUSJQNP8PvDPL4cMSSEEPM+q2Yc+F5Pov2to9PqeYkwyAOT1U1EKgBhymtE97L2/zU1IMR89UELHEb1I+P40osDfiaUyut/q5ghNtQ2lKrAe39B7RPzoew4nHXQdpbBsKY51T01Nul8pWZl4EFDiS6xrZF3UNYS2BXPsILQ9GqueiXn8UBOAG7A6BnDUcGKGxnXvHUa/P4ym/RO3f5I2gLX/s83JXLly5QZArly5fhf4V9MxAf7imk2aVNGiDmky1B1xo7bdoN78509wz08ENJPG/FofgDgFzhzhxtnIxogm1vTDKNLLBA8xXGIKB6rhQVN10djC+Ll+ZNo2Aqw4QWI6vOlYcoDTLXs8QtztcPMX8bXF3Q4s04wJqPHzNEdstLCzv/v1E5sAv37iufj1E+n/2w3Y7ZZi//oEktQG9GYQec1xkP/bURoAONT4g7M48S8p0pAp1veK9VLZ7WCdAAfW14qp4jCA+QczAOIl52DqnWEsHn+WZhBDJbQziG0LfrGEsELdf3h4UHF/D+AfH8msEs0cQztL8XeXOuBfunYu+TsxnniRMGjV1/zVhqS6YSKeEkauzQjKud26i2UPkkYyoObdHo9gO5qEsxEpS5L47NL1a+75PgB0f9LGfwM1R0NABgBLhtg49FKJw5n3HPYsseRZYrdbuVeZ3Zbua7vEhPAeWVoAItsJ7QxsXUNsGvQMmXVg/ACBpFtBnztmEOkG0C1X12gtxTHDRO6rV77fid8NjBhSck3yBxuXZglArly5cgMgV65cHwL/PNXgiQyDUjbECyHFxXVHAt4ULUf0fwae9vmZaOZdArgxXK+H1Bu3iYGYCYGildg1OpngRU4l0Bv1M68b87RjollOja/o8c2VjvDT6LbT31MRZbTZj9ttMgzzyVchlj8h1g2Ci6oab9RDkI0xb5KLHz/Q8f/lGYH/5gXcyws2aRj86ynoBwBuvKJ5MAZyRpz4UZfvINo0UQVnpUkg2vF7bHR5DVF0ZCwLNLYrC2o2FKePd6cmwGfEAPLn8eKmyzhRQ+eMx0KzUgqUn1CsXZgjoA+rJYL99QP6VawfKLrxEcJykbwbppP/6TrTBnbn6OTTRs81rA/li4Hojx/bJJo93TuiMXg83znH8bVGwERWghPaJPO5eN0G8kgh/bs9HFDzz/ny2qdjagJ4pwaVvldF/rsU/ZdiFJHqLgkp9J4Rb3zfMT3Gr9r9Hn1JXp6FxWRfXsARYwlZAXsxRdT3dk37D4slmMMBwvKI9H/+OQAIStZirmFmvNWoCjFJI3yQyMSza/0j0jdumE6uEWEs5cqVK1duAOTKlesm8O8HBNBMxyRTP8yOJyoqxeWxORN4j5ManlZtN2CfntBlfrPBjV13TDFJN8+Q9WaNpypBqPtmYMMods0ecIOkgd90s0egQJtpmUkEk5j/qY3XzXRbmgxF7/H5eALvxoBxDsiODuzxCKF5QR18+wsp2ATKoCgEvMhzPh5FJ4sTtA3F/m3SJG2/x0lip6LErtQQx3uAf72xVUAUxMCR/jYDdU35/2jxRI3cwpn6HxqUGXBuu6WEAWM6Ok/+fhTrN47jhz7XAGM64WcAMjLSJNd0Yl6wrwabqKEpI/lRtDMIqxWaVK7WCPBXa0X3X0GYzcAvlujXQFF/JsYUCUrX64lzOgNa3XgbNSdAdM46reHVZsDEAwD/NtD0fDgP5C64Bl5tsmjgDyBGgGBvAJg+CCDG6M4tauAP+xQFqFkMZxuL93lPMJoVxckJXYfPhen4+j4SwnUGj8zOOB4R3G822Kx8fhIDU5STbfB7nFhyJFNA5QHAaza0Mwi7HYTlHrwf0hrg9UONP2MtysnCDfeWqUdO0N4SE/f/Wwxjp2D/3D3SObl+78KIypUrV24A5MqV618M/mmyPzJg2m7BHNFcTjSZqhnA7ABL8Xn2sAOz3eGGbUc6TnLUNxMJgLlkMzTd7CtaKm6Yu2QSxSkExyMYtSl/tQnATvSTycrIWdlYmYh9iA6uwXYIaEpmOnwa1HgIHW7+Q9MgnZUmW0zFFu1nDGmDGDy5ZNMk7bAXJoDdbVNzgPS1Qvv/IPiffu+mJoDSSMczQD9eY/B37eM6Sz4DLYJWNlts2yQ/KBwer3vrrN96buc+nwL716jLU1A80hOzkZhJGeJMIyYzRDSj5GPSYjoFJzHM5hCWS4z9WywxrnG5wol/20KoGzyuAZkt2Dgzoh0faaR1I4C/zlNnZZQZrTb+JA20IwmQbgacHAvlWM9Rj2U5pn3zIVNMhOvP7zgikZ3oObLNXOJDIuDfp/QRarrixJv0/12vaPgfZ+68uzZZAuWDkib0AB068lt25x/GU/aL74X0u/ZwwEn/yzO4p19gf/2C4ud3ZJI9/UImwHaL7ydkDoiPGYRtER3JVGYzCMcD+K5L0iZjhNVjqxJ8WYIpkPUDNqQ1ccU9hhswRr9u/fs+XM2uOrkvxDBqhKE/DL3WoiRvC5M9AHLlypUbALly5fog+OcpMoFHjorDKfJG9JnmcBhNnc1Av0uxTXa3I03nLjEHKBJQT9tf23DruLgRfThG3BiRBtQe9hC4UUE00TCfg2lUA+A9zacBBUQZWNgUNceAZPL8bt9UM9OgH6UQRI8Ttng8gN0pR+tykndfFOm4DAhOdUyYgH1uhtCkTgz/NIX4WvA/nTLfkp9+FpBTlBfrpd0kK/7em1w+vwR6Q9uSYV0r/7e7LQIHO4jU5F7P413Kvn7d0/X3SkNkPG02I7ZDcvR3YuwHRZmSFwr0Wog1RTFSEoXETjYNhNkcnf0XBPhnc4h1DWBNSpJg/fohplfp1bTaDynCLYTEtmGWjVx/pO1maYYrwLDumZ6viSGtF62Z5tfPX+PUEpY3nTluVzfAzkkWWILE9G/vk7fFe+uG7gF6+s/XLkZ1HpOXwZlIUvNZ7w9K/8/3FHukhgTdd5Fx1UP01eUMAH6tux1S/p+fwf0is9IfP8A9oWGpe36SBgC+pxyVB41Pa5zSQ5gdAIOX9TBKZyhLsGUFoSwhFh4NZG+9psM4ilHkGRzfd6vJpLpHsUyKJVNa9nF1/GmuXLly5QZArlwZ/MsGj2OMiPYv4P+ZtJgvL7gRo+g4+7IBu9/SVKpLm7Kuk/xm6Aek/Q/kFdBTtN4teciT5200TfZwwMbEbIbPeTcHu92iYZy1qPkk4Pym5pN1pA1N3VkLTcD7ZNJ45aZx1NDQm2ugSWkgt/+ih9h1KXO9UFNazrx3Z4Axx1D1PZl0dUJ5Nl2vgFf4+ORwqie/FoRIUwZGMXPgCszqJsakpLsAACAASURBVGB667G+5PGjtWCUBCDWDUYuks49zmYQNzWEugJL+t5P0VqfO67T4yuZ4Gas9R2t4wR4ecIvjS/HKRkWQT81kSQ2rSjxODRNclFv2mT8N5thM6Cu8fpwBUBRIvDpOwJDEezQj57TKEGDAVJMEWkImHyKMSNWS6wqfA2OTAirMklgapImFD1e42Wprgv36vEzMSSWib5urpn6nr0vKR8O3QjwgzALhNnw3v2Ym5rHI9gDauKlIUvSJpFRKSBoPmsCzM1WTnrptNeLYoIdDmBmeI3ES8wevacm8Ran/j9/IuD/6y8oflAD4OePsQRgu8XH4hjAGEYT/ugKiNwk4QYMp3xwtCitb9MdAaoKTFlCDEWSLlwLovnnVVrMyBBQswqu9byRr8Tx59wsDV6ZTNrrpBe5cuXKlRsAuXL9u5sAPEkxQy+0f7vfI/h/eUE9JmfKU7wf6vppsk+AfwQy2aE5eMlHBqZsXhCLFF/bjFImNShTQnuoIW63YJsXsIsl2NkcbNtS/jYBya57W/PJmyiesogDvXJbtg6MsR+igo8gA0+UGTjwJnRAc63oqAFgk4lYtInGPdqAjtzMIR17yguH4M+C/6sn/681Aeg5vHdMTnTrkyaATEvPbZjvCXJ4Gs6u2kwdns/BL5ZgFwvUEs/mYI5HiF0PkaQmYAzEN6QrN4PJKQVZbejj6HxrB3qTgCVrg3li6Ejfb2xKjWAwxI2WshJfidC2eL1UFYSqwgZIWVJDBmnt0Vq8nl0P0KHBmjkYaVSZfhi/QNZpcwOg65I7OjW9Eu0fhEISSUog56ZpCcQ1lO3eoWTDB4ghoGEkUKKGONGPtf2jiFAGUWfW9EVg+tz0XwxHafLPJoRe6cNfA2k6Bu94BHPANBVDU2+7J819TyyeEEf6/3vIUl5bmybgMcbmIt9z0azPbV7AH1AWFg4HME0LsYzvg/8jsrXcywu+rzz9BPfjB4L///6X4kp/UtN5g43dw56SB/qxhITPmx0g+gFi8OmaKQqIdQO2nYHd7SDMD2C7I0SSHkRPKTcupR1cGtV49t9zNzo99b+6gWhSc0klC4ziaeWEZRlArly5cgMgV65cl2xiKMJJTPSYksl0/+cn3Jj9/A7u50+kar6QIzO7+/dJl2p4ku090SI5VWASt3Umk9m8Bv7Vz6HTtAEwPRhjwDonk0xXNxCen8A2DTiOdKsqsGUBviD6cFHi3xhJAWyiiJILfKgb/H9Zyd8HlgNYez2V861zwBplmSCyOSBNLk0C/4YBhAbJmlrK4CqkGMQR6P/oJvGcHn8Chi4FI9NIR3AO6biuQPaFIbr6NJHhXlRXdr0vS/RbaFrwyxXY5TOa2xHbhc3OImnaWe98s/nhe4BCT/xJ+2tiTI2gGLE5NPJLSOZmAn5oEsvAV4C/jvcjlgyu7xLXPE8T+QUGjJi0ABD7Dg3UdpSWwEeAn0cI49zzfkjXPAMXNgSkKbmsBY7NY8ZLWYoRIUsyYtsiyGxbCEMPoRkAQkNrvE73Dw20idkD1gpb4FVn/kvXrwZyfB/lY0XTeUPO+TKtfw8UE1PHEsBGV/xdor0PxLDyxJq4d1Ps3Jqk12l8gMjvD8dOJGGGQHxYLMHOFxAPe7zPvma2ypP//R4byU+/cNr//TsU3/8C99//YhOAfADc5iXJzbojmMGnZuaUXm/SvY7fG2JRIvif79A88HAAc+yUkaIC/tceyxiUwaRJ15oxYCC+eq+8zmQyju6X+t4enUvNgHABwyRXrly5cgMgV64M/jVYZJdn0f5vt+A2G3Jiphz5Hz9wIrOhKDmi/gNrXmnKZUbmVHGkkXwLiL678WYQAQAwAIDpAY4WjHPo2F5V4NjArW2JBYCGZraqIZQlTn3c2AcgGgPGUiOhKPF3KqKE1zWCQ85Cdw43sR80hDPTLR5vIjkZYBgS2CcQYxjYCQiebBe1uSD/zSm4hA9o9JXR2ejxZR1d6EiuN8Ycu8hTZnKiZ2COZm+ftLFVMgAoqAnQthDmC2wErB/A73dIwe7HxomGj+8HAZh5q+Fl0vRvxIqwmt6uGBOODPPAKMmITfpoSzni2j1cPQ54z/NGgCPHe6Y4xHgoQVz4uRHmw3hBDarxx+yiCEjbpjQAM70HTNMJnIogrOrkz7BYoDfBYgF+saRYPA8hBAij84AMDZZEROeSXp5j/6YMmgtNJuM7TVTjB6Lrd+RWv6frMb7eNOT72oDg2BwOeH/dbqUBZdn5niPt4vjvvce6MR98n0DQ7eX9IVDSiHt5hvDyAm7+hBKRiu6f1gJwVCn/HY42pKg/94veV37+gOKv/2IT4Mf3RP1/eRbwb7tjotnr1z5JazEAAL0BazuA8gjxsIew3yOjgt6zAjWtgRspHAF7yz1x0hBiJlcEc2Juecn5iK8ef1wfwGvkeJQ1AcNwGgmZK1euXLkBkCtXrtc3d+RiTNMdNPQjjSdFMrlfv0QCYJ+faVO6lyg5M/jXwf50IzMFOZeCo0leuN5QWcdUT4q8m89RBjCfQ2hbMLMZeRJUYKoKoqbjauBhnQD+2LZIAWc9eNNgU+BYIs2Zgfg96beaSszNAN7M0dfEcXpKGX+LLn8jSB3R0zXzgKPjmC4d6BgoQPfuMWFHemOTBr0kLX5VoQ6dptOfViZR12NVitldWCwh7PcI/g+cdkFu5T6crO94TxO2aVb4KBovAIAFiDhhjOqaO695j8lzgppW0QP+CwM+Xx8AnMXGWN+nxoE0euwY8MeIZnxT6jPpkcVsj0EaMybosUS3PYnc1IA8ugKgLMSXINQ1mhBuN+DnC6HCez9AUNfDNN99FN3JLBpml4BKnJh6KrxxvQhLSWvvY8SmJ0uhyAxV4jbZwb9p5fem59wETjJJqSt2R7Gdiv4PPebMf2r835k1iYklzAA44HsDJWa49jv+W5F3isPtZABA1pQxKAXx5Pa/3aDh39MTFD9J68/0/18/k+5f0mPSxH7aQB41UlUzBvwA0BM7jf/liNihT2aQ9/BDmd5nzzWXrm0IajDPDaa+E4kIM0P4GIXDAUzhUDpjcixgrly5cgMgV65cr21WeAMUVPSUGADuwG5eyJ2ZpjGbFzLZo6ko0zFfm8joz6fAZrKhfg34nzQBuEJA8zwAANeBcTQ1221l82x3O7BznFaZrgfTeNR8MoVST2WcBWOJfsxu0TPUgLMBmqFYvTj049d9hynwFHiPwNsUHGpgGC8zmrp5G2i0ezwBdqbp8+P7AcxAz5ubFm81AeRvKrp3xQ70VTJdlKaD+9QmQCwKCFUN0Axg2hn49Tq5mx/2YI8HgJ6nhVEoxuJETmvgI5KAkfxleq0o2nC0hKyMAQMBvQhY789NLWsBgodobEouAMCGknMAPSBN2/TIMrGpAZaaYTaZNHKz5pVrWJoQTFwYZaAHNbXVuvXxRF7HbWKUnkoooPSBsJiDWewgHI/gde46IDPG0Gs31kLkGwe7sVuD66rghAlaw+SZcE2U2kkSQFDyhn5IVPPDAYHaZgt2NkdmEq33USnPFEky2SOwc1vyWpHcez+OT7yimWfO/P9dMKrv3yJT6MAe9hA3G3CzZ4nPhAIbN2CNsAZiWaGyYyDd/35PTeWfqPX/73+h+P5fKH78Be7H99Hk35L0BvwwNpN86/mrKbzxKt2GEm7kb2hfCnXt3nyPVMA/sr+EutdJysQ1HgDaoNdjI82yR892i8fp5RnsYgGuaQCchRAh+X1MI1VzMyBXrly5AZAr178c/NPGh82kDBtQcf40TZ448o8jmFCbSmZUr01QXtvgXDEpNW8BZD0BMh4zqV0H9niASM/ZMGWWXKFBou/iKV2SaehE88f4M849xyZAaGdg5nM0kFLAw0ymwB8C25PfP9sIee04nznmH3ke0+m/TiTAKR+BxeABvAOwPZjeJHBxpjES9YbYOomfC1VNcguUXMS6xukvO8DbifP9JzQBgOjmgdgiXiaGHQIHml4zgLVb5XSvmCm3MELMG9fKCCQyA8TymrPoD0HfRylLcv5nKQkYA6bv8PvGjmLDopZjTIBCnPpMTHXv/PwnqRbSiGDjMt0cjNopH0bGfwie7JiZQT4AZr/Dj8MBPKVcyPNy5NFhDARrMd/durE/Avt7kLQE/RDsmDFg7XVZ9lPHf2EAoFO+TGn32xTrVxYQbXNq3snmeuqea1j7ftintTgMb07Br2kEXPueISyA4xFMVaGD/69fib3Da5FMSMPxSMfZgfEej8d2C/bXL5z8/+c/qPv//hdG/4njfzL8M0N/fWSpcuBPJqgsw9DN6jvcOxSLJBYkl+GGnIGzDKar7g0hQAyR1hY3iLYUnfgC7ulJ2GnY5AsYy1kWKRlD+zHkJkCuXLlyAyBXrtwEAEXVBR8SjbUnDasYJx3TB5v+nZn6TzXNU2O/e2w/5DHERT/F35numCIJj0z3HFKOdfCJOj0COw6Mc6hfbRqk/7czCIsl+NVGNvHhSFMp0jLL1PsOTIBLGiFvTfLuIUUYAX8xtirEEJEBGccixkAU786ePscQRo2RkYeAsyl6jmQXoWnQfJGbANqQznzS5lU3OEpkfoR2hhRzXu88QdRaWwCw/HwGj2wU9b1b1/uJN4SmAWvQyIZgfJ48pCg97XDPv+McRdKpKSU3LzQweOsYvzW9nDBSkkRnon3XuvVpg8gYfD5yTpwkFcg9iM+BgK4y5bsXBZi6BtP35FtA5oecpAGAjR6SOUSOQ2SJg3rtb11LJ6wkMjoFAumYkvIC9ukJ3GIBYbFEoFZXlFZg8BoiSYWY/+33YA5krrrfCwuAk1nwtSeTwUvWVzzz/3gLGOX3CUrCsPsdeUtU4FQsqQFMerC7LfjFMt0rBqL/bzboKfPrFxT/+Q9O/ckLwG5eUMJ1RKM+8dzQvhvXXNf636jOqErQYJPND91blC9KJIPJyF+byMzQHwAuNwJUMYzSJNpswDVtkqUVuJ49sTTCjCRrZZVMVblha21uAuTKlSs3AHLl+pd3ARSFlYwAPRkNkWZTmgGsbdVazDPg/7VN5b23HCdaSYoGBM9shp6eryepAseOnTF8EmBqcUKnTMfCfgXhsAd/QB2vH3qAwYOjaaM97BG4TKngd2QEvNUQuOcxPoF2GvyzGVvTSDwiAMVT9QOY4gDGGrCmA9PD+JhMwDY4pNzHpoHQtLhhnc2RaTFD34b0OOXnb1p54hxLNJkjkMU681GMG7l784baWjLM6wwCFmPul7igQcBrzQA6TzKh1SaRGgSN4vlMWivnjutrXbt4wXM8+VxNySnuz7whU4lqam8opjFFvyndNjcASkouEI+OI5iyRIlDqajXiuGDKRNExadJLT+uuYGiDQBE0fbSJLVbzLcPz0twsx+UZlACGAt+tcJfLwo8Lv2QtN082d1uSIa1AXs8AmjTuluv51vvs8qPwgQPMBhkXdkD2OenxPggmjqaGO7AtSidAoDkiyC+MtgEsL9+obfM5gVf7yvg/+rrWUWLgjUp5rU4MxGfRmte/DhWJv9ixsnyGUcTeP33b7z2kXmBTDd7PELc7VCaV5WJdWAdHqcepXzBD8ioqiqMZdQ+G7kJkCtXrtwAyJUrl9FMAMp7FsOnAXOSjfcIssPYyf+PbyO0hjMmyvGJ2djEOBDOgF00pMPYsdi2EGZz8KuVyAhM3xHbADfhDgBCjJiEYGyKp9Kg94y+9O+29TqZSLEkwpE5XlHS8ZhhHjvFK7JRoek6sIUDay0Egxps03ekGw/juEXWdusmy2IBfrlEl/fZDCJnvrP7vHVi4vbpTYCyBGgaCOy2zn4RDLx5nVgnFFvrCrBmD9CbZFYmp//2RpA5B+amzQACZvI11RwwU4B/JvN+6qI+TSAYfX7J9975mplGt01M8cykKQfeAlgPNniIgdgVFOcXywoj3toZhNkOTIOGn+wWH4sgLIlY6FhB+hApQDFO3LiyCWBCgGhC0sfvdxB3DdjnZ3CzmaSHRI4PDQEbTU0NACZR47dbBPw7+nfzMpIxmTMGlFet77caNpcWe690Bqw+T8akBjEZyIbZDOnoITVlMVr2WRok9vkJY2X3u2S2qZMOrvVlIFlLpNhUSXYpSmT4OPrgVAy6ns9G9r1zPPlxgBpVwPfLssJYWY7hNHbMtLnm2E+MDc3xCLYoAF4cxdK6kUmo6XvwlEYRZgOEtqXfr/D1j97vchMgV65cuQGQK1euc7uqCxyx/2z3wqj8Y/P65lfrnV/7flEAxAChrgCGBsx8BqY7gu+U5IGOiSswT906B+ZQIEW37yH6AGDD2UbA3/UUy79T2n9Vii7fL5bkiTCnaSvlqRPoQcrpBmxZoWb5SJt5NmszRqL9YlVhM2GxhLBcQlit8f+zOfj5AoFDO20C2Os26Lc0AHjTThPlAICNJFCO77ShLwp2qi8Aimek2LNjORkG3lMa8qZR5DnQMDWLvBT4XwL2XwP67wGZ6d8/wyKaAlYTAoBTk3ZrKPKzBtu0yTDvcIAw9OS230H0dWr4cawkAf9AzBL2spAJKgPBaxNKAl3zfQ/GFcQA2IArsdEFFDGKHg7YIAqLBZi2BYgA9rDHZsGvX8kEb7Mhs1UG/zT9v0YL/9a5VUadl/wtYQLwPc0PAIMBc6BGQAio1+97MPsdxJcXZPGUJf4+GWba3Q7168xw2G1J5qDAvzbou/YaZv8LNnlUPhIoYUJGEzg3MsuLtwBieixkFhTpMSqSSRWKaXLl35bjzfGC3uNXbQfmYMHyvUpd54ajJIcBmwB9D+DR+DY0ASDWABXkJkCuXLlyAyBXrlxKe8t6a5kA2+RYfcYs7G7xdx8ArvLciM7LekiZ8jiLkyCKnBOdNJjzTQBXgCkCAkCSFLCj9QjMKeNAu6sA9nvyH+hOGwEMEgjsxAuSEH7rMZxksCNQLyC0LU4q53MIyxX41Ron9mw6RTR/03UQt1vaaJdgywJMVSXTMgahNGEPNcftLcCvH8A/PIBfryGs1xDnM/z75AOAmu3ftFHl5wgVMjsYJCnQy2uLX4srSnyOZUnNoD1YS82gqTTkdxlFTkH1WxGR731+7e9e8txf8UnQnoDT5oCJ8TTf/XBAbw5yi2cAOZJsUMMmyv0BJ8FQkHSANOrRueQ/cNVFFKVREclI1e7JMNMV4HSChU8Z7mG5glDXKCM5HtAv4NfPRI1/eUmmq12HwO6KyLp4FhibtxszlzSf2LSQo/14XQdKWOl6CLtd8vFgkBmiGBnaw54SEsiotTuiDGKS7HBrE0+8IUpqYBJrKdQ1srs4rpATXz5yf+F1xTr7AtcWlGRM6Qp5DzLMALl2fWnD234Aa44QwJAHyaSZxlI4Po4+QKDEjcCnOjcBcuXKlRsAuXL9m2tqGGYlmi1ls6sJCm+WvBVgGz9J637R5laaFU65e1cyiQFyrIeiVJs88/qGWLk5g2c9OMkJpokBRPV0ik4sZl0dxg4ibdNLBvtrm7/feQxPgIHaBEY1KQ11BXE2B79YQFitwa9WENYP4OdI0w91jZFr3qNh2WyGH88t2Gar0iJUA4AM3ULbQpgvICyXMHx5hPDwAP7hC/jVCvyC/35Dm+fiNM7qdzQBSmxwxBgxX17WHMfI2XSdOIvTXufAliWA21FuewcABjfuEz3zPZtn5p1m0tQ4Ej75c3PD8542NUbrVZponO9OQLI7gu+H5FUy9HS9oVY9cnPTqfNVUQOKTNLE2LJw6DfgzfsxlucqBPzZfsAp7W4HOuzPkEmgPRyQrfD0C0JDDIAjJga4nz/B/fyBH89P6PZ+PIr06GZfiWnz9tLUlrdAadByBECJxuAhdmhUx9IKNgfkCEjTdyKnMl2Pr82fZ8uYa+5pKr5S5B50ngOZusaWjPNK9b5GUp6bgLC1lFDiZH2FqoZQVWhmSo8D3CQcBmwCeH/99c/HfOjxofkYiYGvl8hNo01uAfA9nWUI6r0+sl+Ifi/IlStXbgDkypXrfxn7TzaFBmjzRCC6wEz2UKMzu2Wg2/eYr8zGe2oD+TsYASfxdOJQT02KpiF9baOovmXKFJ86P0/doplaWZUQIIKFCGFkAJc2mGxg52ZzpO3udhAOGJ+IE8ku0XfJwRuCl5zqURThZCoK74C6mwD/9NzLJtbK1F/0/kT396sV+C+PyAB4eEDK/myeYqcCTv3sbovmZXWNAH6/I/OyARso1GCIJZ6jMJ+DX63Br9cI/h8eICxXaAbYtGKaJg7uv3NSxbGAABBaFa3HDt/0Ac4RxdtCrGpwrDd2BVjnwB4dgMVjAH4YxwX+xsbPNcaR9/78Xs89shmaJ1aN9yr9Y0gJJnx9sXxJpQUIs4SBYKv8LIoyRQKqRIP30gBG55Em4abrwYKBYIwkRXBKiadUlTCbpYi4GFHG8PKCDIDnZ7DbTWI2DH6cXQ9X0P9HqQrMforJp+KK1Aozbcrwaxt6kbxEP0DsOgTE+rplABtwim2GnsxZlW+KToi49r1ADEYp3YE9RuYU59q2+EEO+Rqgxxso+qPHLNJjxiatL7yP1fS+41IE54UNptHxnsgvTIdNgAARHF8bMSrD2zh5n8RzEfgYeWS8xN/VWM2VK1duAOTKlevvAf4jTQSMAGk19ScgHdsZArrdFkxzhNj3EHkaxVFkr4AagMtjAS/9fEpXl3i6ppENHrrK04fe6GnK5zlAqSLT+PFCTMZjONFKRk+OwENsWrBtK7rWuMXJndB3SRYAw5ByrT02FMzEqPCcLvqciWB84/NXz/kE/OPGNxnzhRpfS2hnEJZIzw/rNQxfvkKgRoBfLHGDy27a3uNEs8VjEGYzbAbsdum1xwARaLJe6Y35Ah9nuRIPAImwqiqh2v8Rmio3AWhaFmjzHosCHEtNqgpc00B0Dhw1m1xZSQ533JVgXUFsAIPpGmayQf+bekP8reuqY4ZTYeMKWuO4tkJDgLBphQ4eixKbCbc0NBjgciO0A7CQsujNgNNuc9iD3W3xvsSZ8TFi05CuG7t5QUPAw35sPHpN9J++3q0G4/gDkU1LGczfsg5VU4KlACZEMKaHWDhJX5Din/UBQewrLv83Xen0GmPJ4H8GYT6H2M7wPsMfnDpSowwAXHH7vYUn6SQHitxgqmpcV9R0sBXF8U2jOW9lXvD/YwQbI5pjhoAsC5YsWW5SFikpwKV/jXXYDA+/kV2VK1eu3ADIlSvX36AJoNzejWSyMwgkh/bdFvx+AWa/Qz03bUQtAGnd/clk82QzqsHsxJQqnvv5tzazakMr8XRE8QwMJNmwjid8vNkrCVS+5Sg/bQIYg872bCxFuuFYNzL9D/MFuMUCjbu25N59OIiJlyVzuMQIQEdsCB4iGTdJM0Bt7l6j/E6bLHKMztE5p3Fx0vih48cNDU4+aGeozV+tcOr/+CgTev/wKB4AUNBbhg8QiMIcyTMg7mYQDgeJYgTvZQolulxu1iwWwjYIiwU+ft0kM61bpnP3vEY405vWnaFYMdSOF0J1Rq0xAgBXV9IMgKIEU5Zg93uAvodIk0+jPSU+OTryH4/31flABo9JXh6s7xdmD7N7YJR7HotBJBuhTeBMQNqugXg4QOw7gOCST8E1RnTTJsCRARrF43Ud2P0ewm4r0gOm0Ju+Q/nQAa8lIyyiPjUJb230Ei1eJFNCJ1dr7orHMOfu7RzRaDw1Bgd13arf4DSWaePz1jWvJtzs6SCN4DmliyyXEJbKXJTj8ZQJ4K33GG4uyd8j5gE3pCNJEOy+htj1icFyxfk8ywTg40ifW8WecCK3Im8Sfg+sKjB0bzK+gBgK9K7Q0aG5cuXKDYBcuXL9C5oAJm2eoE8bGDOfQ9jvwa/WaOzUdUlvSL9rXIEReIMHsCFlFmsQOwWh04zy99zGNfDnjGUN/tmhfrVCuvr6AcErT3xms0T3dDbRt9+aekybADX+bHA2sSQqmv7XNdj5HMJiDnazFSq83e+wAbDf4zTveEiO3scEjpkZAJFMxHiaE0NyMZ8yA8zbaQejY8zTfo67Yo8Hlk5wA6VpcFq2WCA1f7VC7f/jIx7TL1/AL1fSJBBzyGEAe2woLQA3vfawSM0OZQIYnU0eDfSzsSW5BsX/IW2WtLNGmVL+ySYAPX4wBow1CfQ7hxP/ohxTyusG2SF1A7auwW43EAtKijgeASQpIIwbAeoa+btHR/5u4C8UdqZ4c8OSo/zI3E0c1xXdGuPgOAKQJ7SNNDpxDdZg9hVq2PtB2C38PK6lasuU9hjFB8QOPf793Y68SVy6Vn0gM7we7xVdjz4iMdxujKeOGcfhyXXkPUA8AkRqdvB94oqGhznT4B25978WffdeAsQ164K9S5hd1CR2Ed7D6IObw9wYJsYOfKTBKPISkgXx43PznBhNlu6v7OcQ+Zhf6TNxIjnhSEY6IlY9H47J1JKX0LbpXj14MIVHNlxmIeXKlRsAuXLl+jeBf6LHWtxEGd40NA3pvzuJFAKP1NhorMRamf0eTOHQwdljBnSMkPTyeqJ5zj38LdAPkNzXeTOvwWvFz3OG7vTrB6Sok5u8XyxpEzZL1MyyupxSrpsAaqNpihQtFZoGje+2W7CLpVB43eYFzHYLjnS8drPBjOv9Hjf3hz3GlbEZlkQ2DTgd9gNuDgNPi9QxPbNpNsqpXlNA+XWw5IFBv0yuaVoWm7Rh5U2zX1ID4MsX8A9f0qS+JVmFNdSs8NgEqdAzwhwabBZxJvjQp6c9zcomHwVmaSA9uxRq7ruNmt98rWj2RCBGCEpBkvEkSwNiXWFMXduCeyZ2wHZ7Gu3W95Q0EV6XgwD8axoC8TWQxSCPTfvqWgzetIkfynycuM8jY8ABuIjXLd3bBAxSk9C2M4i7HcTuCHHoUwPuwibASfGUFgCgx78VBwexH+j5Te5DBPIxLo99DVSiAcfBXXL8ps1SMkMVl/oYsekIgFoFAASSN77WUSOA2WBvxSneg+nC3hpgjwAAIABJREFU16SkllTjc8vvA+sH/Fiu0vsB+z7cg11k0AQQZSUNgv05gX9ZX3N8Hzgc0EMnRGmYX202OT2G3GwCA2COYCiaFooSbE3vT/MN2PkC7H4PsZnhvacsIYYSIDhJy8gMgFy5cgMgV65c/5YmgGwSS4ilR3f3YQAz6yH0PXieUNMEylkrNHhT1whsj8cR3dswWNUReARM01QbTu2+zQT8a8q/ocd1Ywp+WC7T5P/hC7nJryGskQUQ2xbjn4riesMnbZQnJlMpYsoejwIe7GGPAH+3g7BYgt3vwNPnknlN1F6JwToesRnQk4s5/QsiEUiGZ0Y3VSYb7Ej59BCjyrM2aWLKOdWSVV2KFj/yhnU6NZuniL6wXApQkoQFY7BB4Qc8J0UBpm7ANA1OL9nkK2pDKjp+ZZlAiWoGMLsCfRoUZfnvdL3Q8eRja8oUA4gsiApCjUwG1xKwrLAZ4JoWQkM6b80IGega8yGZRN7gC/FPAvjnvD7ORtfZlLMeiPHDU1YGfFEmupUkgQAZr0nzAACgLCHUNdiG/s5sRnGUSwjbLZhdiwyNYwdgfQJGArLeB8JyPXKxRIpAtxl8ioQjGQMaD6akCMPr4EqviNPjx4al1KCiax8fwwMcDupvU3OBJF6XgtJpHKU5I2f5lAaRloJVpbCIkO6/SsB/vUYZwALvYbFusdF4L28ReV/A+1loWmwCLJCB5hdLsMsNSj8OB2TM+eHUDPbKhousM5FPDCkmszhCPBwoXWKP7zEsKRn6xD7zHo1pOcoxywBy5coNgFy5cv17mgDRISUxFiVAhbr0EMmo7kzufaxrojajbtaI3rtPwFWyuHGqlDS1ard4jv7PiQSKxhuLQuL5NGUdN3yrFFHHjvI8wZ7Nkg9AVY/jnq5pAvAGXoBfACgK8GWFlM6qgtDNsCEg2v8DygFIAoAToD2Y3Q6/tt+lLOzDAY+dAEKanBMbQOeanxhnTTdto0g/kjxILnUlzIVIZlihbdF9v2nwOC6WSUKxwKi+0M5w8s/mfPQYmH3uyGDNUbZ6CaYZUvxfjJgCAMQeYQmGTY0ApiejTtn9PcH/dD2UJUoCWFYiCRoFgn4yOnRkBmZfniG+PIN92UDcbSHQOjDHA9iuA+AGEEfZcWLEOUnNuYbAWxNX+L0xgGcB/VtgFRTb5wT8uwRi+Zpf8NpcoUEpTVuZ5SPabjK5lHucKwBKSjaZzQT4+/kCJ6TbLcTjEUJ3BBt8YgFQHOSljZbRRFylfIhXigaexiYKfozpMV8xyLuusZualaGuiQnVUOzeAMY5sHSNJRO/cHHD4d1mANwv1SSea8o6BP9Mc+cGJiaXfAH/+BX8l68Q1g8QVsQIa1tKhSnuA3YV7d6QeW6YzyHstug7sF+B3+H9n1MdrJ+wfVTT6CbmBZ0z4weIg6VmckdMswPYwzG9Nw99MpR8x2smV65cuQGQK1eu/1HwL00AijOCWEEMERsAEn1Hk8/Coba5bcEuFqR1JwB7PILtjjTlQkkATjRpcxLD+fzpE/CfNsaRzYzIDR43so0Agdi2Sa/OPgAPX9LEZzaD0HASQCGNhJs2fkoSANbiho21tbXHyR4Z/YX5HI/H8SAgnzO97XZDwG9i+NX3xKY4CBBk4zAIngC1H8d3BQUwrBk1dJILNNFT65pc0CmmT+vuiRqbjBSVMR9HpnGkIh9DkRpYADuQPMKD8SXmXdfhJLosmeolLwJwDNYoZUGBl7/9tcMpAdZBsIqeTsfL0dQ1LObg6BjbxRbc5gXshpsAW2yidd24AUQmkdIMiGc8Nqb/Ttf1R803P/L5OVPKc8/xXDoF+1UQpV9i3Xhav1wSvXuNbB+WpjTK3K0sMaOd11OMxHwpITY1GZzu6O9twB9oUko+DXGgWDs2W6Pnf61mO545RxIzaAwA+NPzNblPmmvXJRv/KVO8yM3QqibPAUzvAGvBxgghRrDclGUpwAfM+c7Y/92PpSKNzYK8RGbgiQkWHh4Q+H/9SvIlagwvltj4rKr7gX/dRCcGHTKryIBwtcbJ/2aDa22J93k2z4UwZl3ccpxGa4zYI3FABpn4SIym/iGxsvj9AzL4z5UrNwBy5cr172sCENiS6DvgjOEE2lK+coPa5qYB285E22gOe5xkssv50I8n1hq48CaYgMJogy2Z6xRdpUAAFMV4eq2ngYslTv158j+foyN9XUm+PdzLUV5PKIsCIASIZQBTVQA0/TbdEcIwpEYAUTDt4UCMAPp8R0yAjsDffo9mYAT+mVmB+uAhUYUBCFyrnSBP/Uj3q+UKUTlBM1jiSKywWCRJBYGpMJvhtLRt0/HThnz8EQJEU4IxaCgVgwNTVhAF+E/NIPV0lw32bJJm/JO0qKoJEK0FUzhy32YDrgobZZsXTIpoWvm/XWzIG4JMIpmiezjQBK9XPgEDNtCG4WTjbrQ53GuTPP66bqroqfNr/07B+zWf6+tEs4j0YzDY12uD14UYVapYt8VcfCmGB0ynCOTyHjnSj/wYwBUnjJ9oLYSqBlMTg2ixAE9MnbDfQdhgU4B9OaL3YCag+Fqn/NeaAK8ev3PNm0tBoZqO4zWlvFJaosfXNaZZdD0eW44hZBo4P5Z6vfcA7+aO71Vj0z+auK/WuDbWDyq55At+fbHESFhqyN29uajeC0JdAcxmEI5LMPs9+PUD3tOPSP/HezuyfGwMAB2cN3u9tgmg/saIJRaUsaxikkl0Y94B5cqVGwD5EOTKlZsAqQlAjufWSb4ymxzZ2RyBzX4vmxvLU8xB6dg1dR3imPavdew6hihGAEfPhSbCMtVj7T85rmPc0zzReYl2zRveNPm/I/g/VxKn6ABCAbGKYOoKGyFNB7FrARZLnAZ1HZjlMnknHIkWeqTNIXkDgG4A9D1FB3ZkCOjTRo+OWWqcOJRQlKXoYyNpXlkrzVp+cf6XuCo17a9KCFUt3gF6jZysG2YDjOK9wvkNrTQPlK+Cbij8EzWotLaiqSFwLFhZSkoE6s6x2WI3aA5pNy+S+S5JEXv2hiCjSF4DxKqBgRpAniQ2MeDGPzBtXLMCCMyFMDKIHIHQa4H9W6ke056DNqXkyD59vRByiZqubmxyMS+QbcJrUuQ+yyUZfqLXh1+ymd9cpD6S+DGi2nMj0+J5aWcQ5ni9+eUK72Ok0eZrDoYBQRo3MuUlx6untPre+hbYvwU0T7X/HPunmyd+TV4ebYsNWLq3yH2RnoPVj63A4l0n+FdUPNN0Zb19bFs8jyQDGx4fYfj6DYbHrzB8/UbT/xWujwajRT+NWcRSNb7mZzMwyxX4HqMfPd/He2LGUYPFSmpC8tn5CPNCrj297nPlypUrNwBy5cp1URPApgi2UJYQ9xVYpjQfj2APC9Gx47TyiM72fY8bGpqiycSfJ0qUCS9NAA0g9AQLIGl5GczWtQDawJt4aQbMUvYyx32VZXK+/h0bIQYZBHpiEQCqCkyNG7/YthSPd4TQD+NpLxkpWvoaiAygx+MaA34teJwEW4vHmhsABWU6l6VsRiPR/5EFgBNpBklBJSNw9CNKBCpJSxhJJi6JHqRzF9/TlZ4D/P/0jSp7L5AruCkLMVs0HDU3n4OdbyEcViif2W7A7lYI/ilBQuQ0nBbA+fC8JihtQ4whqRFgfGq4aBPOkTs7U7uZdXNvA4AzAGRk5gma4s/NHyCmj5KsqGg/ZPw0yZtiuRRzSr9+wKnvckU+FaTvdgUxAOzJGotFCaEKAPUAZjYHczgia+h4xI/DAbwwbwYIgNNxACBZk3/rpV/UCBiB2zPXiPnoPdykuE1uirJZalgsJeLQ7rbYELF21EyUJsDQpwaFYgh86Dl+8BqLFAEbJAFmmcxfv35D6v/XrxQLu0Yvk7ZNTeBPfv/ESNAW2V+kxffUWApHWltDD4aadgHoeHcwagLoKNBrkh/0+zY2vApJgQHtrcKJJrly5coNgHwIcuXKTQAB39qheujB0Mbc1A2Y7gjx2EE4zEcxduaIDsfiXK8jrHhKGSPqxSnqDjd2LuVd0yZKzLJY68l6+xL17OJm37bqa0RzZ2M5AhS/HVxOEwycg1h4BO91k47ZfC6TRvyaB3vYy7EzxyNNfik6yrM2PAJY1VTh8xUBvQAoLg0MNVHqOmWnk1GV5KjzceTvnaP6X/qa+d/3nMv/V6dTitHAPgyhKAFqZK6Y2QG12Lsdsmh2W0qFOIB9ecZ/xUByl3wBiCViuh7XiR+wKRQ8GkWSV4CW20iSwIi6zqyACPEtl75bpv5GgX+AFN2pmyOa7s+MGYqnZA+IxPSpU1JF26YYN5b7rB/Ar5bYBNRmn9oEcCon4fPDcYAerzvPjTZi4JihB9+hB4MLAaIPY6d8LWn6yHL5hPUn2n++N87mBIYp1nO1Jq+XCGE/h1iU4OhcOZeueWOQAWZ4fU1MCX8rI0DWSyGmf8L6WrLp36OY/kkSzGyODBJX/J4mML9flQVKqDxdn8MAMCBzB+U86f7ogCR31gJ0dhz9+IYcIJ49PikKU+7rbP7Knzs7itXVjblcuXLlBkCuXLn+7U0AMs3i6DvOjjddB6ZpaMLRo/FfCCrLnlz/B56WRXS61ppSZynqikC+NSNDu+gUEZV19kyx5M0NZS+zPIBjwrTL/B/Xk2sAbS3EyH4BJZiAxoGo7UfwD36AMCxSA4D138GLBwDnxUdmADAgI+aBbATLEj9nYE/gSo4fT/jJfZ+nsHeh4v+b6ad62kzH2VBihK24ETDHtIjDAcweIwHtcplSIfb7iW/EXiVtDNgQoPViKDISr7cBjcW8H8eM0bVlpp4MvHamgH4K+vk6Pfc9DX40QNEgg9MzjNLjq8SHSCkS0oRiVgr7fZDDuxhTLubK62MxBv9VOW78nTEdRN8On6ja/YCTWfoQ4KY8Fqz6O0Ydp4/StT9aUZ8LHelKcYl+scDmyfoBhsdH1MNXFU76DwcExoVTsgwD0VhwzgEcHAAxT8APKcVg4lz/Ga8/ngO3hUsme8QIGR6/gv+Gk//h61fw6zXGmC5J91+WAMSK+i2lGtiRfSaI5eX9kFgVqolkSRJljAXbEUOHjQE1i+eNRrP2RYhNA4Gun9C0IxYYFGXyW/mnS69y5cqVGwC5cuX6HBCDee9IvTSBWAAUTxe9h+hx0iF0f6Ygq+m0Ic36SFccSOsvdHGQz6PFaKwEImxyirduNN2XmDsG/kzD/7ttaDRFMwSIUKBEIEYwdU1gjqdsAUGdnuiqDaFMd6dTIuWeL9NV8ScoMApQ6Nb0tVum/bkuu34A0loNAUJRAFQ1TpvrBsK8B3NcoBHgfJFSAA57MtbEabSwAagJYA8HXC9ktinRm9QEMAN7RPjzjACJnCMjMJIERGXOyRRhYe3QNSnAV65Rc/6eQV4UI0YEcKQnelWgvKcQ00qMZyuJ4k1+FCTrYWNKdLMnTbc421cK/Bevg38NKIsSQh1pQuvBdEfwZMQJFMNp/JiSbdXUX5gAfDw+CQhfBJIZeLLnR1WldA81JQ/rB/CrFUYBxgjheEhSIb4HsHliWaBZ6X4P1hwABoPHykxMSCev/x4NgajvZ7x22PF/RmaGnPjy9RsaQn55xNf58CVJQqrq94J/Xl9smNu0EAK+H3py3zd0/cl1puj61jn0EOk7ZAwEfxr7eg7829QcES+XlgxdxRC3wbXBprBy3s1EppMrV67cAMiVK1cGMbwxcA5iIH17EUY6YwQcaTMoFEZiEhifHP8BQHLhAQhk+EFNEA2am1k33kkyrRdS7rJkfEvm9z9k8syvlZkWAGgeyJGJIUCsvZi6YUNlSCCOwf+Ibk8NFD2B5lg9ZlVYN9Zf6+eS63OvIYC0TomFYfoBDAPZwwGn+2xE13WYDHHkeECMpxP6P6VDiDlg36GuuOuRCcDXHYMIJQcQQ86TNfRGEsA5lgCbd3JTqyjS5wzc2PDR8TVqx7GPzPBxjkwnnTAAxKiSjT/rBiP8KAo01gRqmPb/1uT/HEgjmnwIHoCc2Q2xloyKZtPHwe7p+iE/huS2Hv7cGqNjLSCwxcl/UPR/v6LYxPUDxKZFMHrs8NgJY4pYVWUBtqrBFSVY8mOwxwNA10OklBeIARkBr2TJnyOva9WJeePnRuC/YFlITT4aGK/nHx5SxN+3bzB8eQT/+IjNATI5/e3gX5+TokCGhKyvIR0bfm0s1SgKcJR0Y4tCsX16bARoU9XReU9xqthwoESExQLNMZcUj0smmXgNVcIIkJSMf1LySq5cuXIDIFeuXL8ZyDDN3LlR7FAsx5sTaQ6IMDiM/840lkx/Pt3kMPBg13j++tTh+5+6gdHHlkyqpiZ6I6d3ASQTGreO2GMpxfQYjSLXcv2ppg82skr0hfAVgvSmRRC/WIhDeyD6tT0eEsjXnw/oKG67Y5r8h5CMAgEoOSCkyT+zSfQ6YBDr3JghoK/HaXNAX59sfKlN1phqT2s7GitU82iMeFSwaV2oamIDWARFTStSFo6ykyl/3STfCpIOXM1k4SZAVUEIrTCXPEsmqGkp1xy/NmvBGAPWHgE6kzTb3Mz7TUZ5cdKcZWd8icWbLyCsVwkIMhgkgAwA1AAoUlOKfUHKElxdY4zlpgG73UDc7yXSFLjJNCipySuNAN080ccm6gbT9F4ocaY2mUGS3MOvKQby6zcy/fuGiRCUCoGRptg8+qP3OXruEAOEpplEolLTRkncYlXRMa/FB0Q8YLxPLDp5P6T3RG6QcFTmfJ7YEQ9f0ChzsYQwm0OsW/TKIdlHdG7s1ZErV67cAMiVK1euNwGr3jTojf+UDhrj/R/7tc//l47xdNrq3OsxYv/GY/S/0gxg8FxFMEOd/B/YF2LoIZDOf6T5J78N7b3BxpqGEiR4nZhhGE2ojU4DCMgSkAhJNuMkBomYdb72/cDNhEnsnnptAoYMp3sQYBXaObmnFwUAGKEqiy8AywNcIUaV4iFQFLdpmVV2O9Q1hIlfQvJMoEuOGEmxKNGwzTow5gBmsCOfDg2C70mLHwH/CfgfmXu2M/CLJYL/1Rr8moDxaonU+PkCAam1YOpBkj6ieIekCEtbN+Aa8lfYYUxlPNQoQaFmFGfaczypCeHNJsDoa+cakiRlAGtFzoCa/wUaPz4+ou7/8SsM376R7v8LhPUDNgmqmppL5m9xnceqBgADQYC2Mt8jCYwrk+mlbRpKBdkl5g9L7LQUQLNYJo0fbJI8gn94gLBeSUQuR7yiDwBKcWKWf+XKlRsA+RDkypUrg/R8THP9gWYA6eohBIghJF8IpluzMR3Rzo0f0BQyBJUGQJT/YSD5SEwTf0X3NzFIkgTLTCAEnND7FM0ZCyd+AufMOke/D0ASgAAy4WQjSmoeRJd05pGAv/gFiFfF2MtDe30AaZ1FynIm5u/q64pN22qc3ocQKJrQJrNCY8BRNKaT51SAKUuw+z2APaJR3lSzfYYWb878/ybwr7w92DMhzOfgV0vU+j88gn/4AmGFzQAxUSQ/BTAAxgcwLKNiHxX2D2hbcO0MYtOCnc3Abl7A7nZgt1sIRzKwpOhSSTIJHqJn88lT2rqZNC5P/SNIKlKQaWmdJv881R4e0e1/+L//Q8f/RzL+a1thhvytKO3c/AKAMJJnYfOK02ssGVna+RwjQndoDjqSA4SQFoE1dO6pSTKbYfOHozIfvqBEglgRYbFQEbnUbOPrLr+f5MqVGwC5cuXKlStXrj/Q5NEJHDFS7GVIxpoxjI0iB24ARJnMi3Y9KvBPjQUBqFMpzuhzSBPKd8w6WVKgfSQia5MZ/GiQbgAnj9z4sA5/3k7czEH935qx18c5+c9Hj7tzEKFCFgC/hggwyHmxyTStKMAR0LTbDcSiALsvSLahzNv0eeBjC2Pn/GlDAOAdbfyUIl+UEKsSQo1u82G5onjElej9EQAuwTM1vm4SPZ7kHoGj4wpHNPQGrCQwzMBtFmBf5mA3G7BznE5Hiak8iGRFmCghYEOApV/MOHnNyA4gJUIUDoBjXeuamhpramo8gP/yCMO3b+AfkfoflktJh4h1/fc0gBX2VoQQZ7KeQAF4R4aX9uUF7GIBdruThBD29ZDUF762ikIkErFtwc8J6M8XENZragaQDGRGHgBVJUaZ8e94rHLlypUbALly5cqVK9e/thlA4CEZRapIMHH2Dyp9QydDxETHVr+jkaU248SfCUJTRnmAH39+xqxTwD4BHAEVEumpPx8bjkWbtMwjo8Qp2J0C/XuDFvEDqJEYAQCeGhYDGWgiPZ4M1KoaXFkKbTtWW7D73Xha6yn3nWI7XzMJnILii4C/dQAOfRNiXQv4Hx7RDd8/4vRftPGLJbrC0wRY8urJj8FYA4aMGGNVg61qsATAzXIJ4eUZ7PMS3OYFzHaLqRWbDUZWcmJF14lpnSRTAKR0GO0twa9SrQcdSxoaBv8LMrRbQXh4gOHhEYEtyQDCaoWvbTZDc7u/M6ClJhOAgeAcGig6NLPFdYVsBztfgNtu6DgzA6BDqc8wjDwAoivEBDO0LaVizJIJIHtBSAoARWWWxaQxl5sAuXLlBkCuXLly5cqV6+/VEOBmQEKOJ54QUcWyAUCKGpOvnZv4v2LG+d7n58w6GdQJlDUJ0PPPWTs2MjsH6P+UczubAlqDAA1ApAcyreXJdNOAaxqw7Qxc+wJxs8HIvKOixg9IjYcQ0WeBmRz6WOpzMTXGm0YrcmoC+yC0LYQZ0b5XpPv++hWGx2/gv6FBHpr/Ef27rpN0ghsKZUlfcxCsA0Ou/7GqILYt2JcXiLM52NkcwnaB1PTNBuxyCeZwEJBq93syqexTlKJXbIgQTw0lif3Bkgoxs6tpor1c4eR6uSTH/y/ibRDWa5z6k+5fmkh/Z0BLTIBoLRhrUuIFx/fN52DnCwi7HdjdFgxLLfoeoO/HUh422SQWQCD/h9A0eMw4MpPkHKlZpaIyM/0/V65cuQGQK1euXLly/cOaAvr/Gmx/phnnNc/tTwH6W593UchxC9phvyrB1gTWyCAvNg249gmBctOC3W3RLf9wQPDWdQjc+j6ZBAoYVrGpU2AMkLLZY0z+Cc6JNl708Zr2/+0bgv+vX1H/TxNgjkwEi27/J2uH2QDOgXEWTFnhVLmbyeuybQt2v8KJ/3aLH3s0qkOwSk2PI0ZYmuCRui4NgCCMlCgSEZPMIh3r4SuMfZzhJFsaAMslGf2Rz8FsrkztCjEz/NuvNU56MQaCMWDIkC9WFRgC73a3BXtYjiUW3o9iKkWWYp2YJcamTX4AdQ2BDRyrKk3+M/jPlStXbgDkypUrV65c/+MNgn8SCP87HLeyFC+DYJ3yAECKeqzJtI0y193zE+q2N5sEjA8HCIc92CN7AwyJxu2TYSM3asxEIhCV14FotimiL7QzMseb4+R//YCa/8dHjMWj+Dd0/Z9DaGeSN392HajJebQWwA0QywJMX4m+PMx52r8He9iD2e1w6n88kiEg0dW9B3vYSzKC6XuRpUj8JPtGCKvBpIjHqiajwhYn2rNZ8jCYkYnhfC6NAnld/yRAS1IFZl5E5wDKAqBpwB4OCN77HhkVLAFgeQ81UtgcE8z/Z+89uuM41m7NnZHeloOnk3TOuff+tx71oOf9L3t9RxINvCuflT4iexCZRZAiQEqiSILcz1q1Ch6FrOLmjtfi7fpGx+lWCuoKFXQzIlq7+3jX+sHDPyGEAQBCCCGEkHcckT4w9TfRD8qzLb2qzfO6zL8H5fsQ0eZtj3yWbfvkVZ8Rr8rt2rz+ULwdFNitUjS6IYut6NfFie2wtv6Ap1xPl3aHEWQUvTvxfTiCHI31gTm5W/rvvD0kfyz40VUDQPZl+V3Aw9ED+URRQBUFRJi/+7eVJYxSzwHoByJuN1d0gYBWiHfmUrTm24qEfpid6g+ynt+VtetggAqCrpLBh3L11/RtA4/yQNsP++wevzIFjEZC2jYMz9uu97y7AaDfCKKfK/G2vca6swqyD1J1pf7blZv9fAQe/gkhDAAQQgghhNxzSLP0ykLVlcbDsvRBtJuSL4IQIo0h8gxqtYLI9ao8I891KXeeb8u4t/3c/eFOye3aRUM2bw/h/eyE94cP9mXdYQAZxXq/exzr7H8y6KoBBtuy+b5VYFv2/akHv74Vov/7lULrOjDqBq3vw6hqqLIbeFhXXdl/DaMqgVZBFGV3aNWtDkZZvtvmcDcA0B1itxUA/UHW7ffW6y0H7Z0J9v3XQYjHfaC9u85RCLRCwrC6doBumOK27P9O9n+7P2JbsWF2qzSNt9sFzDvVBRz4RwhhAIAQQggh5BODAN1BS0/f7wblOS6U6+ne+DCEkWcwg7ArjdcT3EWa6hL5PNdZ8SLXh2bZ6Gy5bLq5AEoHA/pDcr8+sV/15zp6SNy2HD/Sw97i5G1/fBcM6Ke+b1e+WfYf+/7/zN/eDX3UMwIsGNICHBeG63RBDKXnHDSNHv6HVgcDZLMd/rfdYd/Tv33n8Athvh1uaHeH2K7lQVde6B52CPPdrP9jP9DeHfBpGHorRGuhtRQMZb9d86nubJTo2M6JMPrr2Gf4375+Hhy2SQghDAAQQgghhHzgkNYdppQQMCwThuPqQIDnQZUlRJ6h7QMAZal3uPc9830AoCwhykL3xze1bgnYBgHkuwe1fs97f/jtKwD8brp7NyRPRhFaL4AKdVtA63p6jV43+A1/dzXe+ysITVOvo3QcfchvugF/snk7+X8740C92/e/zV4DfQa7P/z2Jep9W8C2+uBuGXt/qP3QasjvJdh0J0jSwtJtAv0KT/RtIu9uimjvHvJ56CeEMABACCGEEPIZggD9oDzDQGsqHQiwHRjdyjxVFjCKUgcAyhJGkely+L5cviggyhKQjT78d2vzYBgwmkYf5PpDXNtuM/itYwOWrfv5HacbguduhwG2ftcv77p6MF4/Ff/vHv4/FAi4s52gNU205p31hq2CIdV26N82Y90fWu8eXFu1IVMOAAAgAElEQVToLQB3fmZfCXA3m91277+zuvBH4L2NHtvtAf37H3pu7nufEEIYACCEEEII+YsHYdN8tyzesXUm3HUh3ApKNl22P4TqD/rFnZ75vly+z5h3GV6j2/Hedoc9mCaU63Zl7+Z2Qv52p7vrvj3423Z3c/753vj3M879ykml3h5Qu6DAOwfWVt3zmN4GVrY/8/3f8aO/5njAJ4QwAEAIIYQQ8g0EAkwTraUApcv0jUbC8Gu0VQ00XT98pQ//kOptEKBbCQghdCVAT5cZb/t+974VoJvI//awb7/t8ze/Ym/83T72nj4ocOd9HnIJIYQBAEIIIYSQxx0I6G99MMCUMGwbcGXXIy+74X/ynanuRtPoz71XHt8KE0ar0PbD3WxbZ8i7IAAss+uNt972z39rvfE80BNCCAMAhBBCCCHfdSAA0Id2QJfE23oQXuu63bo/pWcA9L3x29Vu/QG5CwYY3Xo8w3i73u1uf/zd3e79kEJCCCGEAQBCCCGEkC8cDADetghY1vaw3wcGjG5IHrr379bLG22rD/l3AwuG6IIB7+10Z2adEEIIAwCEEEIIId9QMOC9LH27HYz3x/v2Q9/7oXtCCCGEAQBCCCGEkEcUGCCEEEK+EmwgI4QQQgghhBBCGAAghBBCCCGEEELI9wBbAAgh5DPS9/m2H9uB/QCGYaBtWxhdqbDBkmFCCHWUOkoIIQwAEELIlzWlHzKk/ceVlFCtgmwkpJRQSkIptf0aIQSUUh+9N01TC7RlwxACpikghAkhBAzDeMfQ9gaX5pYQQh2ljhJCCAMAhBDyJ4zp3fseKSXatkXT1GhbQDYNAKBpaiiloJRCXddolUJVVajrClVVoamb7ntaKKW25lIIoQ2nEGiVeucebQvTtCCEAcdxYVomXNeDIQQ8z4MwBEzLhGEYEKYJU5gQpoBlWhCmNreC+8EJIdRR6ighhDAAQAghfzSrUkooKdHIBkoqSNUZ1bpGq1rUTQ0lJaqqgpQNyrKEbBpUdY2mrlHXNZqmRlmWqMoSZVmgrvT7Ujba+Cq1NasPIYSAaZoQwoTneXAcB47rwnFduK4Ly7LhOA5My4JtWXBcD67rwnZseF4Ax3X0503rDyaWpbCEEOoodZQQwgAAIYT8kIa17kxnkWcoyxJFnqOuK5RliaZuUJQ5ZCO1Ea1rVGWJutKfr6qyy1LVqKtqm7Equ68pihxSKtRVCRgGmrqGaZqQUsKyLDRNA8uyIKWEaVmQTQPTsqCkhOt6aNsWrufBNE0EQQjLtrRBtR24rgvTsuD5PlzXhe8HiJMEvh/ADwL4vg/PD2DbNmzbhmmasCwbQghYlgWjv2fJKyGEOkodJYQwAEAIId+zYZVSoiwKbDYp0vUaq+UC6/Ua69USeZ5js0lRFkVnYGsURQEpGxRF0RnXAk3doK4ryC6j1TQ16qpGXVdomgZNXUMqhaauYRiGNqidcTVN8w+9qnc/btk22raF4zgAAM/3YXaZLEMIuK4LYer3XddDEIQIwgBRFCMIQ4RhhCCK4HkePN+H47gI/ACO626/R3/cgdUZW0IIoY5SRwkhDAAQQsh3gzaZJdLVGsvlAvPZFNPpLW6urrBaLjCbTVHkOVarFZSUKIocbduiKHIo1aLIc92nWpXbflUA257WpmnQtqorhVXboVYt2neM87aEFMY7n+vfF4YuNzUMA4YwuiyTgG1rye6zUDoz5cD1vK1JDcIQQRC+k8HyfV+b2TBEGEVIkgGSwRBhFCKKYni+D9t2YFn8L4EQQh2ljhJCGAAghJBHTl3XyLMMy+Ucs9tbXFyc4+riHDfXV7i+usJiPsNiPkdVVciyjS5traptietbg9pCSbWdSq1aPZRKSbk1pv2tny79vmH9EPd9XgiBopt8vTW8QsCAoXtTTd3r2pe02o4Dx3Hh+z5s24brebBsG2FnZkfjMZLBEKPxBKPxGKPRBOPJBGEUI4zCrYFlSSshhDpKHSWEMABACCGP0rRm2Qbz2QzXlxc4PTnG6ckxzk6OcXV5gdl0inS9Qp7neiL1nQFWnat8Z3VVb1p7w/mQGX3o/Y99PaCzbe//zt4Q94OpDKMzscLUq666XlXds2rBNM1t2WoYRkgGQ4x3djAeTzDZ3cXu3j52dvcwHA4RJwNEUQzHdWHbNg0sIYQ6Sh0lhDAAQAghj4OmaVAWBZaLBW6uLnH85jVe/f4r3rx6hcvLc8xub7HZpKhKPZladVOmP9Vsfg0+ZKCllDCM5p0VWYZhAIYBU+h1V5Zt6axWECC+iDEcjTEaTzDZ2cXu3h729g8w2dnFZGcXg+EQcZzQwBJCqKPUUULId4T5f/3f/8//y8tACPkeUUqhqkps0hQ311c4Oz3B77/+D179/jvevH6Jm+trpOs1yqJA0/zRtD5G+gxbv1dbSQkpJZqmeTutO8uRZxnW6xXWqyVWywWWyyXWqyU2aYos26Asim3WrM+Mcdo1IdRR6ih1lBDCAAAhhHyTSCmRdyWr56fHeP3yd/z2639x/Polpjc32GQbNHX9Tgboe0b33UoopdA0NaqywmaTIsszrLsJ3qvlElm2wWa9RlWVqOu6M/MtTNOEYby7E5sQQh2ljlJHCSEMABBCyFc1rE1dI8szzKdTXJyf4c3rl/jt1//izeuXuL66QtaZ1i+ZqeozPx+69Z//YgZWKSgloaREVZYo8gJ5liFdr5Cu19ikKYoiR5ZlqOoKSioALYQwIUyTK68IoY5SR6mjhJBHCGcAEEK+C5RSXYlmjbIokGUZlosFri7OcfzmFV7+/hvOTo4xu71FkeeQTfNZTGs/SOqu+bzbP9p98MNfe2d91R8ey18cmPVnDazsSlv7a1fkGdI0xWI+w3w+xe31NRYLPdn7aPkEB0dHGI0niJMErusxi0UIdZQ6Sh0lhDAAQAgh/zy9sWvqGlWlyzDXqxXS9QrLxQK3tze4PD/DxfkZTo7f4Oa6y1g1f65c9a4Rbd9bJYXOqPY7p/t1UqZpdaWegNF9zjRNKKW290KI7ft1XUMIAakkDBgfXZl119i275ncv2r8e/Nf1zXKsuhKWldYLPTKr8VsisVijoPDI+wfHmE4HCIIIw63IoQ6Sh2ljhJCGAAghJB/DqUU6qpCURZI12ssFwudYZnNcHtzjentLebzGW6urzCfzTCb3mK9WqEsy4+a1j77JISAIQSEoY2qMIXe7QwDlm3DMADT1DJq2TYs09T3lgXbduA4DoQQsB0HbdvCsiwopWBZFpqmgWVZkFLCtCzUVQXD0IbVMAyUZYm2bVHkOZSUqOuqG8ald2o3TQMpJZSSkE0DKbtSVKX+VpZrO/RKqe3k7/5AMJtNMZ/PsJjPsFousX94iN29fSTJQO/JtvhfCiHUUeoodZQQwgAAIYR8Jtq2RV3XyPMMaWempjc3uL25xu2tvp/d3mK5XGCxmCNdrZDnGbIsQ13X2+FN96H3QAvYtgPLtuB6HkxhwvM8CLO77943DAO240IIA67rwXZsuK4L23bg+T4sy4bdGVltgA2Ie3o+W6UgldL3UqIsS0jZoCgK1FWFsixQVzWqqoSUEkWRo65qlGWJqipRFgXKskTT1G+NbKunV/fX7c9kt2R3nWTToK5qFEWBNF1js15jNp1iMZ9juVxgk6Y4ODzCaDxGGMWwbZsvUkKoo9RR6ighhAEAQgj5e0gpUeQ5Vqsl5tMpbq6vcHN9hfPzM21cuz7L5WKBbLNBkeeo6wp102wN60PGrc9YOY4DPwgRRREGozGCIEAUx3BdD2EYwbRMbVRtG7bjwLL0XmjHceC4DlzX7+5dmKYF27bemfrcl8AaQqBVansPAHVdQ0q5nRxdlaXO0BUFqqpCWeSdcc9R5Hk3YGqDbLPBZpOiLEtkm402v90KqrIsoKRCIxu0XVbqU0xs39uqVKF7gssC2WaD9XqF1XKBxXyOxXyOzUab1/2DIyRJAtfz+GIlhDpKHaWOEkIYACCEkD9P27YouxLV+XyGm6tLXF1e4uz0BFcX57i8OO9KKudbMycbCSmbTzZp/e8xDAOGEPB8H+OdHTx5+hy7e3sYT3YRRiGCIITjapNqmlZ3b+oslWPDcRxYls5gCdOEZVnbXte+V/Wh+6aRQNuibnSWraoqSNnorFTXo1tVFYoiR1noidObTYpNmmK1WiHLNlivltvVVL2RLfIMeZ7pTFepf6a8k9X62HVpumFfTdOgKkus12u97mq1RFHofdhNXaM+OMR4MoHreuxnJYQ6Sh2ljhJCGAAghJBPN6xN0yDLNljM57i9ucbl+RnOz05xcXaK87PTbY9qttmgLHSGRUr5l4Y59dOlhRBwXRfjyS6ePnuOp89f4PDoCZLBAEEQbktYDcPYrnEyTRNC6LVOpmVCGALCNN+ZZv1n6P8GPbwKkE0DALqHVSpIpftZizxHnudI0zWyzWa7eirLNtikKTabdNvbm65XWC6X2KRrbO5cr0819305a2+oy0JnsrJM/97eGCspMd7Zgef5nG5NCHWUOkodJYQwAEAIIR83bmVZYLVcYnZ7i4uLM1ycneHs9ATnZye4urjAfDbFer3W66i6TMzfmeLcZ66EoY1rkiTY3dvH0ZOnOHr6bFuWaZpvs1F3V1JtM1+fYR91b/hs2/7g3/N22nTTZaNKXd5aliiKHMWdrFa60hOoF3M92Gs2nWI2m2K1XCJdr1GVxbZk9mODvfrDhFK6FLauK9R1haosUZUFmrrRWS60GI0m8IOAu64JoY5SR6mjhBAGAAgh5MNUVYVsk2Ixn+Py4hznZ6c4Oz3B2ckxzs9OMZvedmWq2Scbrk+hL1u1XQdhFCOKYgRhhCiO4fsBPN+H47h/ORv1lx/TB35Xb2zb1obret0Oaj20SjYNlJJ62FVdIcs2WC2XmE9vMZ3e4uZaZwBnXf/varnAujOwVVX9YQL2h1BKoa1r5G2LaXuDuq67IVslyrJA0zR4/qLBeGcHYRhxsjUh1FHqKHWUEMIAACGEvGdayxLL5RK3N9e4OD/Fm1cvcXpyjJM3rzG9vcH09habTap7OrsMyucyh33JahhGiKIY8WCAIAi6idQWhDC/qGn9s4+9z3L1GbS72a0iz7E5PMJ8NsV8NsOTp89wfnqC6+srXF1e4Ob6alveWhQFmrr+5CxWnmX68CAl6qaBlE23XqtBVZXYPzhEFCc0r4RQR6mj1FFCCAMAhBCiKQtdqnp+forT4zd49fJ3HL9+hbPTY9xeX2PVraLqDeufKVG9azbvTpEGAEMImMKE4ziIkgQ7O7vY2z/AZGcXyWAA19OrqPpy1W+Zu8baNHUvrW3bcBwXQRghSQYYT3aws7uH3b19XF1e4PL8DBfd7aabAJ6lKeq63g6tesi89pOy53IGKaUeYlXpjGJd1duvi+KE660IoY5SR6mjhBAGAAghPzpVWWKxmOPi7BRvXr/Gy9/+i99//S8uzk9xc3O9NVJ/pky1N3BC6EFSwhAwTQHTsiAMAavL9PRrqKIownA0xpNnz/HsxU/YPzhAMhjC9wM9kOoRD2ISQsBxHNi2Dc/3kSQDjMZj7OzuaZO+u4vxZAdnJ8c468qD18sl8iJHU9cP9gT35rVtS6yWSyilp2LX3S5t1Soo1WK/bREnA5pXQqij1FHqKCGEAQBCyI9KXddYrZa4PD/D61cv8ev//H/4/df/4uz0BNPbW70aqZtK/amGtTerpjDhui4sW6+UsiwLnh/ANAXcbgK15wWwbQuD4QjjyQ4OnzzB4eET7B8cYjAcwvd15up7WMdkGAZs24ZpmnA9vY87ThIkSYLRaILBcITBaISTN69xdXm5zWLpNVrywSyWUgpVVWK1Umhb/bwahoG2M7d9SS0zWIRQR6mj1FFCCAMAhJAfkKZpsEnXuL66wsnxG/zeZaxOjt9genuDbLP5qGG6a8oMw4BpWTpD4/kIwhBhGHaDqEKEYQTP92E7DjzXe/u1vo84TjAYDjHZ2cFovIPBcIgoirc7qr+nfcxCCAghYFkWXNdFEASIkwEGwyHGkwniOMFwNMbZ6TGmNzdYLhfI8/yj/cJKKTR1jfV6tTWrSqp3JnsfADSvhFBHqaPUUUIIAwCEkB8JpRTyLMPNzTVO3rzGq5e/47f//g9OT44xvb3ZDkX6FNMqhNB9mo4D3w90NmYwxGg8xnA4wngyQTLQRtQPgm0/p2kK2LYD27Hhej58z0cQRQiDEH4QwHEcWLb93e5hNgwDjuvCtCw4jgs/CBDFenL3cDRCEIbw/RD25TkW8zk2afrRLOL75lWIt+u8TGHCskwI00QUxVxtRQh1lDpKHSWEMABACPneadsWZVlgPp/h/OQEr1/9jt9//R9cnp/dKVdtPmpa305uduD5PgaDAYbjCXb39rCzu4f9g0NMdnYxGo+RJANEcaKnUTs2DHSDnrqfYZomLMuCbTuwbAuWpUs8v1fTehfTNBGEISzLgu/7iKIYyWCAOBkgSRKEUYizk2Pc3FwjXa3RtuWD/az9eqs0XXfmVUCY+hoLU0AI3UscRtEPcX0JoY5SR6mjhBAGAAghPyx1XWO5WOD89ARv3rzCq99/w9nJCW6ur/WE6k/IWJmmCbMrvYzjBMPxGHt7B7r39OgJ9vYPsLd/gNF4jDjRq6h0lsoBoLNdSingTl9lb2L7SdXfU7nqxzAMA66ny3ldz0MQhtub7wdwXQ+24+LavMBquUBZlg9OEW/bFrJpkGUbXF1eAoahf4btwO3Khk3LhO8HP9R1JoQ6Sh2ljhJCGAAghPwwSCmRrle4vrrE6cmx3lHd9apu0vSju5MNw4Bp6nVTfhBiNJ5gZ3cXT54+w9GTpzh6+kxnrHZ3MRyMEMYRbNt5x5C+b7De//k/9H8MltVl8Ww4rgvP9xH4AYIwhOu6cGwbF5aF5WKOsigezDD2ZaybNMX05gaWaW2zY7q/2NMDxjyP/zAIoY5SR6mjhBAGAAgh3xNt2yLPMkynt9q0vn6JN69e4vbmGqvlAk3zcdNqdYYnGQwxmexow/rsGZ49f4GjJ8+wu7eH8XgHYRzBdb2P7p1m1uTD18S2bURRDMvU5byO5+qsk+dBdHuxZ9Nb5PnbFVf3mde6rrBaLiGEgB8E8Hwfrud1k8Gt7c8jhFBHqaPUUUIIAwCEkO+EsiywmM9wdnyM0+M3OH79CteXl1gs5tsVSR8zrUEQYrKzg/2DQzx9/gLPX/yMFz/9hL2uT3UwGML1PFiWRVP6d/+TsCz4QYDd3T3YlqVNrGPDsuzt9Z1Np8iyzUfNa9PUWC0XOD87hWVZCKMIQRjC8309SCyO2cdKCHWUOkodJYQwAEAI+R6oyhLz2QznZ6c4OX6Dl7/9itOTY8xmU70a6QHTKoSAaVkIwwg7O7s4evYMv/zrP/jpl1/w4qdfsLu3j9F4jDCMvutp018D0zThB4EeOtWVtNq2A8exYTuOPhzc4qPmVUqJqqqwXMxx7Xrw/UCXxPoBPD+A7eiVYzxsEEIdpY5SRwkhDAAQQh4xdbfO6PrqEsevX+Hlb7/i/PQEs9tbbNIU8oH+x75Xtc9YPX3+Av/53/8Hv/z7f+GnX37BweERksGgW0fFdUj/BEIIeJ6PycSEZeqhU0LoGwAIQ+Dm+goZsnt3XLdtCykliqLAdHoLx3MRxTHCOEYYRfA8rzPFLGElhDpKHaWOEkIYACCEPEqapsEmXePqUpvWVy9/w8nxa1xeXmC9Wn60X9U0TXi+j/FkgifPnuM///v/aOP6r//g6OlThFHMMtUvQL/rejAaQZgClmXpXdRC6EOHYeD25hqbTYr2ngxWP9E6zzLcXl8j6HeNJwOEUQzP9xHHCTOPhFBHqaPUUUIIAwCEkMeGUgrZZoObm2ucHr/B61cv8fL333B5cY7lYo66/rhpdVwXyWCIg8Mj/Ovf/8Ev//5f2rQ+e4Y4Tpit+sI4joNkMNweFO6usGpb/fYmXd+7gqwfZrXZpLi5uUZ0fIw4GWAwHCKKY7iuC9f1eBAhhDpKHaWOEkIYACCEPBbatkVR5Fgs5jg/PcXxm1f4/df/wdXFOaY3Nyg+svpICAHLshHHCfb29/Hi51/w08//wk+//IK9gwNEUUzT+pWwbRtxMnjnuZayQdutq2qaGsUD/chSSlRlicV8jsuLMySDBKPR2z3j/XAsQqij1FHqKHWUEMIAACHkEVDXNdarbk/18Ru8+v03nJ+e4vbmGlmefbxf1bIQxTF2dvfw7PkL/PzLv/Hi51+wf3CIJBnQ2Hwj5lUp1U2nblCVFcqyRN00UFKhLIt7M5NSSuR5htl0ivOzMwxHEwxHIwyGQ/h+ADMMmb0i1FHqKHWUOkoIYQCAEPKt844pOT3B8etXOHnzGtPbG6Tr9N4BR71ptSwLgR9gNBrj8MkT/Pyv/+DFz7/g4OgJBsMhHNflRf5GzGsyGEIpharSpjXLM2SbDaqyQCObe/tYlVKQTYM0XeP25hpnpycYjccYjSeI4wS248BxHF5kQh2ljlJHqaOEEAYACCHftHFtGqTrNa4vL3Dy5jXOz89wc33V9atWD/arCiHguC6GoxGOnj7Fz7/8G89/+hmHT55gNBrDdT1e4G8Ix3EwHI7QdEOpNukam/UaZVmiqipspLy3hFUphbqqsFwscHN1iauLXeztH2A82UEYRrBtm9krQh2ljlJHqaOEEAYACCHfKkop5EWO2fQWl5fnuLw4x/nZCRaLxUeHVQkh4DguBoMhdvcP8OzFT/jpl3/h6MlT7OzsIghDTjb+BrEdB4PhCIdHT5Cma6yWSyyXC2zSNaqyQtuWD660Kosc89kU52en2Nndw2RnF8PRCK7rMktJqKPUUeoodZQQwgAAIeRbpalrrJYL3Fxf4eriQk+qns9RFsW9E41702rZNsI4ws7uHl789DN++dd/8OzFT9g/OETIYVXfLIZhwO9WjB0eHmG1XGCxmGO1XCLPcz3Yqm0fmGZdY7VaYTad4urqEvvXV9jd20cUxbAdh9krQh2ljlJHqaOEEAYACCHfGnpidaFLEa+vcH11idn0Fps0fXBPdT+syvcDTCY7Xcbq33j6/AX2Dw4wHI3Yx/iNI4RAGMXY3T9AmqaYz2ZYzGfIso0uV86yj06zns9nuLq8wNXFOQ6PjjAaj+H5Pmzb5gUm1FHqKHWUOkoI+bs6w0tACPmc1HWNNF3rDMTlJa4uL7BcLFCW5b2mBdB7qj3Pw2RnBwdHT/DTz7/gxc8/48nTZxhPdtmv+kiwbRuDwRB7B7rs+OmzF9jZ3ev6UO/PQOnp1zXyLMNyscB8PsP09hbr9QpVVfHCEuoodZQ6Sh0lhDAAQAj5lmjbFnVVIV2vML29wWI2xWI+R5ZlaJr6wZJV23YQRXpV1S//0muqnr/4CTu7e/A8j6WLjwTDMOD5PsbjCQ4OjvD02XMcHj3ZZqAeKj2WUqLIMyxmU1xfXWJ6e4PVcomyyB889BBCHaWOUkepo4SQT4MtAISQz4aUElmWYTGf677Vy0sslwuURfHgwCrTNOH5PkaTCZ4+e95lPJ5jZ3cPQRiyX/WRYZom4jjB/sEB1usV5rOpLmHtVlr1+64/dPBppESe51gtl5hNp1gtFyiKArFSfB0Q6ih1lDpKHSWE/E1YAUAI+XzGtWmQZRss5nMs5nOsV0sUefZgz6oQArbjII5j7O0d4MnTZ3j67AX2Dg4RRTEsi3HKx0g/zXr/4BCHT55i7+AQcTKA6+ns1YcykW3bQjYN8jzDarnAfDbFbDrFJl2jrlm+Sqij1FHqKHWUEMIAACHkm0AppXcVpynm86kuXV3orMN9ZYeGYcA0Tbiuh2QwxMHhIY6ePsf+wQEGwxHXFj1iDMOAHwQYjcc4ODzE4dET7OztIYoe3kmtlIJsGmzSFMvlAsvFAqvVClVZPpj9JIQ6Sh2ljlJHCSEMABBCvhBt26IsC2zSNZaLBdarFYoiR1M39/asGoYBy7IRRRF29/axd3CIw6MjDEcTeB6HVT12TNNEFCcYT3axu7uHyWQHYRTBsu0Hd5DXTbMtX13MZ0hXK2w2G/avEuoodZQ6Sh0lhDAAQAj5FpBNg7IssVzostV0vUKeZZDqfrMhhIDjOIiSBOPJBAeHRxiORgjC8EFjQx4PnudhMBxid28fu3v7GI0n8P0AhhD3lq+2SqEqS6TpGvP5DIvFHFm24RRrQh2ljlJHqaOEEAYACCHfAo1skGcZ0jTFerXEpttZ3Cr1wcyVYRgQpgk/CDAcjremJk4GcByH06q/EwzDQBhGGI7HGE92MBgMt/uoHypfraoKm/Ua6XqF1XKJdLVGVRbMXhHqKHWUOkodJYQwAEAI+ZoopVDXNTabFKvlAmm6RrbZoKnrB/tWbduGHwRIBgmG4zGGoxGiKOaU4u/pPxkh4LgOBoMhJjs7GI7HSJIBbNt5eIiVkiiKAqvlEvP5DJtN+mAfNCHUUeoodZQ6SghhAIAQ8gWQUqIsCqTrNRaLBVbLFcqiQCMfLlvtd1aPRmOMxxMMR2O4nvePlK32K5PuW530I9G27Tu3fxrTtOAHAQbDEQaDIeIkged5EMK89/H1pdBZlmGTpkjTNcqyhFI0roQ6Sh2ljlJHCSF/Fe6FIYR8FiNUFAVWq6UuW92kKMsS7T0GsS9bdRwHYRQhGQwxGI4++8Cq3qTKpkEj5fbxGELAMk2YlgUhxA/RJ9ub1K1x7w2rYWyvgWEY/0jJsGma8P0AURxjMBwiimN4ngfT1L/zQ+a5bVs0TY1ss8F6tUS22aAscshGom1bljYT6ih1lDpKHSWEMABACPkahqiuKp21ms2wmM+RpSmqqoSU8t6+VVOY8H0fyWCA4WiEOI7het5nK1ttmgZ1XaHIc1RVpcseGz1J2zRNuJ4H13XhBwFs2/mu92QrpSClRNPUaOoGUjbb7J0wTVimBdMyYVk2TNP87Ea+L6grJ0QAACAASURBVF+NohjJYIggCOEHAUzLetCAykZCygZVVaEsCshGcoUVoY5SR6mj1FFCCAMAhJCvaYqyLMNqucBiPsN6vUKWZx9dW2U7um91a2bCcNvP+DlMa5Hn217axWLRmekKSilYtoUwjDAYjpAMBojjBEEYfpfmVSmFuqpQliXyPEOe56jKAkq1MAzAsmy4rgvP9+F5PhzH+eh6qb+CaVrbg4K+1jaEIe41rn2mrSxLFHmOosj1YUgxc0Woo9RR6ih1lBDCAAAh5KvQ1DWybIPlYoH5fIbVcoGyKKCUfNi42g6CIEScDJAkCYIghP0ZjGNvWpfLBaa3N7i+usTtzTVmt7fI8wxKKbiuh+FohPFkB/sHh9jd20eLFmEYfVfmVSmFsiyQrvVE8dVygdVqhSzbQDYNDCEQ+AGiJMFgMEAUJwjDCB7w2c2raZpwXQ+BH8Drsoa2Y8PI7jegqn07+bxpGnyBNltCqKPUUeooIYQBAEII+RC6v1CvrVotF9ikKfIsQ1kW95YYGoahsxiehyhJkCQJksEQrudD/M2slZ6iXWGzSTG9vcH52SnevHqJs9MT3F5fI03XQNvC9TwMR2McHB0hzzLUTd31s1oQQfBd9LLqrI+e/nx7c43b62tcXV1genuLTbpGVVUwTQtJkmBndw97B4fY3WsA6FJT4x/oZTWEAcu2YdsODCG0EX0gc2XAgGwaVFUJpRSapobi9GpCHaWOUkepo4QQBgAIIV8eKSWKIsd6vcJyucBiPkeaph8tWzUt3bcaxwkGwxGCMOymGf89w6iU0lmrxRzXV5d49duv+P23X3F6/Aaz2RRFkaNVLWzbRpwMsFzMUeQ5pJKwLRuO48C2bTiu++ifm7qqsF6tcH11ibPTExy/foWLszPcXF9htVqiaWpYlo04TrB/cNBl9SRMU+geVsu8d73UX8XsBpaZlrW91v1r4v3Xi2EYaKH7jE3L0kZWCJasEuoodZQ6Sh0lhDAAQAj5GiilUFUVsjTVWas8Q1Xq/sL7MldCCLiu1/WODjGaTBDFCWzn75dK9iuPFvM5ri4ucHpyjJM3r3FxfopNukEjG6AzQJtNiqosAACe73c9tANEUQzbcR61QWqaBlm2we3NDc5PT/Hy1//i9auXOD15g/l0ik22QataCCEQRhHWqyWUamFZNnw/gB/og4Rtq8+axVNKl6KaQugVVVJ+9Do3TYO6qvT3Sw6vItRR6ih1lDpKCGEAgBDyxenXC5VFgc0mxXq9QrrWJZHtR8pWLcvarq2Kohi+78M0/54cKaXQSIkiz7FaLnBzfYWrywtMb2+QrtNt+WP/OFqlMJ/PYDsuoijGYDDC3v4BhqMxPN/fZlUe42GiLEssl0tMb29wcvwGr17+juPXr3B1eYHNJkVd12iVgiEEiiKHkhKu5yFOYgxHIwyGepp4bzQ/h4k3+jVZpglDCNi2DcuyYOD+n23AgGVZsLrnQnSTtZm9ItRR6ih1lDpKCGEAgBDyhY1r2wJ1XSHPc+RZhqqq3lmN9EHjapmdaR1g0K2u8v3gswyNarve1TzPt0Y6z3Pd83jnMfU9t0VRYL1aYrlcboc7lWWp+yMfs3EtcqTrFa4uL3BxforL8zNcX11ivVptDXxfKtoqhZW5wnw+w/T2FsvlEmWRo6kbfM5pUdv92d1Ks6Zp9Hoz3P87Wuiva+r6ne/l9GpCHaWOUkepo4SQv4bgJSCE/FX6UtGyKFDkuR5a9cBwISEEhBCwbQe+HyCKE/h+ANd1P4sR0eWQCnVd653HZYGmqT/YR9sbobIssV5p45p1g7caef/k7W/9MNE/J8vlAvPZVA+uur3Ber364E5xKSWqqkSeZdhsUhS5PoDcnRz9OXgnc2UYsB3nkzNXfSkxM1eEOkodpY5SRwkhDAAQQr6WUUKLpq5RFIU2O1JCyocNj+O4iOIIcZwgjhP4QQDzM62M0qbmrUmybQfCEA8avVYpqFZBqVZndLrbo3w+2hZSaTOepSnS9RrLxQJ5lqFpPpxR1NegRV3XkI1EXddoZPPZs0Ntq69vn32qymqbubrvYNFC97dWZbU9aNzNuhFCHaWOUkepo4QQBgAIIV+IuqpQFAWKPENR5Ki6IUP30U8fNk0LfhDADwI49ucZFKWzItqsuq4L3w/gOI7ew3zPWizDMGDcGc5093E81syVktocNlJ2BwqdrVL3ZOP0iirA7K6faVowhc4Q4TOur+pXYfWHFMd1YHbPy4d+R/8x0zThuI5+27I++0otQqij1FHqKCGEAQBCCPkEkySlRNM0Xc+qNkb3lTz2hsN1XQRBANfz9JAox/5sRsSybLieh2Qw7CZj7yBOEti2vTVJdx+P6NYpxXGCeJDA9bztbuXHbo4MdKWixtts3n2G0rQsOK63LSN2HHdbZvxZTbVSaOoaAFCVFZqmufeQ0H+saRpUpT4QNXXNzBWhjlJHqaPUUUIIAwCEkC+NUkrvr84z3b9aFtupyA+ZKXTZItf1YJmfdw6pEAJBECBOEuzs7GIy2cFwNEIcJ3BdV/dKdgbasix4noc4SRDFCaIoRhxrkyvE4zSt2owLWLYNx3UQRhHCKILjejBN6w9GtDetruchivVAsTgZ6IxiZ14/9/NjWhbQtrBtazuw7KHMlWVZsG39PaZlffbHRAh1lDpKHSWE/EhwCwAh5C/Rdrurq6raTjt+aHCVLlkVcBwHQbcfWZcvWp8tS2SaJjzfx2g8wd7+AVarFYoih2z048qyDWSXLbEdF4PBAHv7h3j+4gUOj54gThJ43Sqtx5i5MgwDpjBh2zaiKMZwOMJ4soPb2xvkWbZdOdZnfkzLgu/5GA5G2Nndw2RnF8PRCGEUftaM4juHnaYBDAN13Xxy5qqu9ffIpuH+akIdpY5SR6mjhBAGAAghX9S0ti0a2bydXl2WKIrioxOPDSFgmiYsy4LjaNN6X1/pX8VxXCRJgv3DI2R5hqoq0bYtXNfFcrlEVZUAgCAMMZns4PlPP+PJ0+fY2dvDcDSG63p/KHN9VMa1y8gNhkNMdnfx5NlzpGkK2UjMZrcocr2vus8eDoZDHBwd4emz5zg8eoLxZIIwjGBZn9+4PpS5ev91w8wVoY5SR6mj1FFCCAMAhJBvxLi2qkVZlqiqcru3WjbNvcbVMAxYpgXHdREEIWzHheu6MM3P2yeqy1e1KVVKwbZthGGI0XiC2fQWRZHDMAyEYYS9/QM8efoMT549w/7+IaIoguu6j9ocCSG6UtQE+/uHqMoSdVXBdV1cnIdI1ynquoJl2QiCALt7+3j6/AVe/PwLDg6PMB5P4Hr+P2Le+8yVIcR2f3X/evrQawzAtj/aEIKZK0IdpY5SR6mjhBAGAAghXxrDMPREZKVXC+m1VRIPzRTqh0VZpgXLthAEASzbghDmZ39spmUhSmKoVsE0dT/reLKD9XqNPMsghIEgDDEYjDAcjTDZ2UXS9Wz2E5Ifs3F1HBdxnKDa0XuoDcNAGEUYjkZI12tUZQnLthFFESY7uzg4eoJnz19g7+AQcTKA4zj/yDXoM1dt28KyrHemV9+XueoznS0zV4Q6Sh2ljlJHCSEMABBCvjzb3cJNAymb7e7q+yYL92uihBBwXRee78OyLb1f+h8wIqZp6hLWwaDLXEUYjXeQZZvt9GTHcRGEAcIwQhCG24FNj7Vs9R1ht6yuh3fcGVkHcZJg/+AQmzRFVZU6cxWG2rhPdjDe2UGcDOB5unT3nzCu28yVYfypzJWUUh+WmLki1FHqKHWUOkoIYQCAEPIVzKtSaLqywkY2W3Nxn9EF3mYubMvWJrHfk/wP0JtXwzBg2w78IEBd19vhVaZlwbb147AdG7btfBemtce2bQRBCFOYekp3nGCzSVGWJZSU29VdYagnXAdBqCd82/Y/9pzoHePmn85c9dkuYZrMXBHqKHWUOkodJYQwAEAI+eLGtW2hpERd11CfsLtaGHpwVV+KqA3JP2sUdQbG1XutXRdSSSjVm2g96bk3Q9+jIbI7E2rbNnw/wGA4RNP1F+tp4trcW7YFy9I7vv/J69BnrvTr5u306oeQUuphW4axzY4SQh2ljlJHqaOEEAYACCFfEKUU6qbWmas7JYUfykIAQIt2uzfasu1/NENyl96UtqYJq223j63fY/2Y+1Q/1bwLIWA7ju4v7sqLDUPvEu+vz5e4Fv1rQ915Dto7z8m9j7/LdjFzRaij1FHqKHWUEMIAACHkC9O2LaSUqKsaTV2jripI9dYUfdBAGrps0TT1ACLrC5eJ/ggm9WN/uxDi3hLRL4GUSvesNg3qutpmru477BjoPt62+rGrh9ejEUIdpY5SR6mjhBAGAAgh/5hx1aurlFJQ8uOmwurKVR3H6YZZmbyYX8HEfr3XTIOmqVHX1bbc+WNmVPcYO13Js83MFaGOUkepo9RRQsjfgApACPnTKClRVRWqukaR5yjKYjsU6iHDZAgB23ZgWXpY1I+cTfrhXjNKoa4r5HmOPMtQluWD+87vmmxDGHAcB6YpAL5eCHWUOkodpY4SQhgAIIR8OaSSaOoaZVHogVBSdoOh1L0GRJiiM6wWHNeFZf3zw6vIt0PT6ENOlqbIsg2qrtz5IdMqzG7dmefDth2dwRImDzuEOkodpY5SRwkhDAAQQr4Eemq1QlVVOhORZdvy1YdMiJ6WLOB6Pmzb3u6upgn5/lFKv17yPMdmkyLPc1RlAdl85LAjBCzLguu68IMAlm3xsEOoo9RR6ih1lBDCAAAh5IubVyVRldXblUIfmUJsWTY8P4DjOPD9ALZtw7JsXswfACklyqJAul5huVhgtVwiz3M0snnwsNO/ZoIwguf78PyAmStCHaWOUkepo4QQBgAIIV/StDayQd1lroqiQF3XkPL+zNXd/dC27cC0TFg2TesP85pRCkVRYLFYYL1ebXtX+wFWHzSuQsBxHHiehyAIEIYRHMeBMJm5ItRR6ih1lDpKCGEAgBDyRVFKT7D+pGnC3d5qz/PgOA5c19uusSLf/0Gnrmuk6zWWiwXmsxk2mxR1Xd1vWg0DwtA7t8MwQhQnCMMInufxNUOoo9RR6ih1lBDCAAAh5Iua1jvDqsqyQFPXaPFw6apq9ZoiYZoQpoAQLD/8UYxrWRbYpGusV8tt76ps5IPG1XZsBEGIMIqQJAmCMNz2OxNCHaWOUkepo4QQBgAIIV+IfrCQUgqmZcHsygk/1FPYf8wyLdi2DbNbYUUD8mPQNA3yPMdyqbNWy8UcRZ5DPTC5WggB09SZzjhJEMYxPN+HZVnsWyXUUeoodZQ6SghhAIAQ8iVRSqGpawBAXVVout3VH8pEtG0LwzCglIJSCsI03w68It89UjbINilWyyVWywWKPEfT1GgfGHYmTBO+7yOKYySDIYajEcIgZL8zoY5SR6mj1FFCCAMAhJAvyXatkG2jbVvYjgPLsraf+9DXA4BlWbAdR79t21xd9UOYVokiz7FcLjGb3mK1XGKTpqirGlJ+OHMlhIApTDiOgyCMMBgMEAYhHM/l64VQR6mj1FHqKCGEAQBCyJekzzjILltVldXWhNyXuQJ0CWNd6WyXbJoHMxfk+6Cpa2RZhtVygeVijuVygaIo0Mjmo32rYRxjPJkgGQwRxYmeXM1yZ0IdpY5SR6mjhBAGAAghX44+cyVMvUfYcR2YpgkDxr2ZKwN6erXjOvr7TZOZqx/ggFPXNTapnlq9WCywSdcoywLqnqxV/9pwXBdhqIdWjUZjeL4P07R4UQl1lDpKHaWOEkIYACCEfGlDopTa7h7ue1db3J+FatF2mSu9sqjvXWXm6vtFSomiyLFarTC9vcV8OkW6XqOu6gezVpZpIQxCjMZjTHZ2MRiOEATBdkAaIdRR6ih1lDpKCPnrMBRICPlTGIaxzTAYhgHLtvVUYdyfheozV5Ztv/O9jzVz1RuvfjDX3fu71+nu/Y+GkhJlUWAxn2G5nGO9XiEv3g6u+hBCCN2zGkVIkgGGozGiOILjcm81oY5+bzr6qVr7I1c4UEcJIQwAEEK+CUN2N3PV1PUnZ66auv5D5upbNne9weof63Zvt9TvN7LZmrQ+ACC6DItlWp1J18OY3jfr33OAoC9bXa/XWMznmN3eYrVcoCyKezOW/YHG9TwMBkNMdnYxGk+2fasscybU0cepo383UPKjBgmoo4QQBgAIId8MQggYXSahz1x9VGy6zBUAGEJ8s5mI3phLKdE0NZq6QV3r8tyiKCCbBmVZQimJuqqgVAup5Haft9X1WDquA9FNYbZsW9+bFizbgmnqnd+mZUIIc7uX+XsxZ23boqpKZJsN1qsl0nSt11bVDw+tsiwLQRhiMBxiNB5jMBjADwJmrQh19JHp6LcWJKCOUkcJIQwAEEL+BkoptN3+6T5z1RuWD5kYANvMFQC03S7rbwkpJaTUh/qyLFAUBYo8R5ZtkK7XKMsSeZ6hLAoUhTZhOhCgoJS8Y+pNmKaAbTuwHRuO48LzfTiOA9f14HoePM+D67pwPV/fuy5cz4PjuHoQ2CM3tLpvtcBqucB8NsNiPscm20Aq+WDZqm3ZemjVYIjhaIw4GcB1XfatEuroI9FRQh0lhDAAQAj5Drkvc/V+H3z/MeDby1z167OapkFd1yjyDEVRIF2vkKYpVssF1qsV1qsVVqsl8izDZpOirmtkmw1apVAUBYRpoixyWJYNKRs4jgspJXzfBwwDQRDAtm34QbANAPhBgCAIEcUxoijGYDhEFMWI4gRhFD76QICUDcqiQJquka5XKPIcdVlty50/hCEEPN9HFMcYDkcYjScIowiWZfMfHKGOfks6+v6/YZaVU0cJIQwAEEK+b+5mrmTTbPdXP2xm5Hbn9dfMXPW9k3VdoSgK5FmGdL3CYrHQmZbpFItu1/JysUC6WiFN16iqCtlmAyl1K4Auz6xgCoG6rmFaFpq6hu04UFLCtm1txjwPpmnpe8vaVgMEQYg4SZAMhhiPJxjv7GA0GuuSzeEIURTDcV1YlvWoSjeVUqirGmm/tmquB1fVTX3vcy6EgGVacBwHYRht/3597Zi1ItTRr66j/e9RClAKRtvqQIBhoBUCME0dCGAwgDpKCGEAgBDy/XE3c2Va1nZ/9X0Y0DuvexPypTNX72f7s82m26s816WVi7lesTS7xXw2w2q5xHKp9y3neY6yKFA3NeqqhlJvDbiU6oPZuu01MrDd1W1ZNoSpyzMdx4FtO/CDAFGcYDQeYzgaYXdvH3v7B9jZ3cNksoPBcIgwiuB6Hmzb+aQe4a9N27YoigKbropis0lRlaUecPZQ36qt+1aHoxGSwQDxIIHjuhxaRaijX1tHpdQH/7qG0TQwmhqQEkK1aIWB1rbR2g5gWWgtSwcDCHWUEMIAACHk+6HPXBmGAdk0+v2PTK9WSqGuG6Btv2jmqj/4V2WJzSbFYj7DfDbDfD7DzdUVbq6vsFoucXN9hTRdY7VcIM8yZNkGVVV1h37d598PCOx/7kPcNVy9STeEgGEY3VYAHRRwXVe3AsQJJpMdjCcT7B0cYmd3DweHhxiPJxiMxgiDEGGsSzm/5aGBsmlQlUUXRFnqtVV5DvVAdlMPrrLh+YHuXU0GOmslTBpXQh39mjoqJdA0MKoSRp5DZBlEnkFUlQ4KCIHWcaDCEMoPoIIQresC33qw8htvY6COEkIYACCEfFMIIbZr7Wzb0W/D+Oj3mKbYrmz6EpkrXUZZdQf7Ja6vLnF5cY7p7S2uLi8wm95ienuD9WqFZbdeqR/w18hmu2brbjDhzwQe7j6Ouyat7u6FEHrIYLqGO5thNr1FnCS4vDjH7t4+zs92sbu3v60IiJMBkiRBEIZwXU+3B5jmdl7At2DyGtlgs0mxWi2x7mYn1HW1rcL4kGkVpgnf9zEYDDAcjzEYDuH7AUyL/0UR6uhX09H+8F8UEOka5mIOaz6HuVpBbFIYTYPWsqA8DypOIEcjfRsMoYIQsL+xvvO+bUFKGEq9bWEwDEAIfftG2hioo4QQBgAIId+Yj9LZJyEEZHdQ/tjX102NsizRSIm6rj6p3/XvHv6LIsd6tcLN9RWuLi9wevwG56enuLq62Gb+V8slqrJEVVVouv7K3mT9mQP/nw0M9NUEffavrirkWYb1conZ7S2ur64wGo8xHk8w2d3FeDzBaDLBcDTGaDRGHCcI43i7UcB2XNj2160OUEqhqiqsVqttK0W22UA28sGyVdu24XoegiBEkgwQxTFc12PWilBHv5aOKgUoCaMqIdI17NkU1sU5rKsr2FeXEMsFjKoCTAsqDCBHYzR7+6gPDmDsFZA7u5BRDDjOt3GxpYRR192t6oIAuoUBponWstHalr7vgwEAdZQQwgAAIYQAuq/dsmwYhgHHcWHZ9r0mo+2zLt3bVVmgrhv8A2frd35nWRZYLha4vrrE6fEbvHr5O45fv8L56Qmm01ts0jWyLINspDbfX2kwYR9oUErpFV9NrXs/u3aF66tLDC9HSAZDDAZDvdt5NEYyGCIZDDAYjpAkOhgQxwn8IIDnerBs+4sPfmqaBps0xXq1xHIx09sTihxSyQcHV9m2gzhOMJpMkAwGCKOYa6sIdfRr6mjbAnUDI89hLRawLs7hvHkN5/UrWOdnMFcrGGUBCBPK9yF3dtFcX0GslhBZptsUDlrIZPB1KwHaFqhriLKEyDYQmw2MLIMhGx3kME20tg0V6BaG1vehbButbev2hq7SgjpKCGEAgBBCoFdS9RmJj5mkuqpRFgXyPEeWbVAWOVSX/frcB+q6qpCu1ri5vsLx61f4/df/4vfffsXZyRvc3t4g22xQ1/W2xL/9J6MRf/KxN900cCkblN3cguViAc/zECcDBGGgs/9hhOF4jCQZYLKzi9F4jMnOLiY7OxgMRwjDfnig/QUfe431aoXZdIr5bIZ0vdqurfoQhmHA7KdWRxHiOMFgOILrupwmTqijX1VHFUTTwMxzmPMZrKsrOK9fwfn1v7BuriHSNYyq1iX0tgV1ewNzugexXMJcr2FUlS6zB75eEEApXcGwWsNcLWHOprp9Yb2CUZYwlELrulB+gGY4hBwMIIcjGGGkr8FXCAJQRwkhDAAQQr45+iF2juvAcVx4vq9X3hm4dyK+lBJKyW6q8Vr3NBY5mqb+7JPtpZTIixyLhc6en7x5jVcvf8Px61e4ub5CnmXvlPp/zuvyuX5eHwj4Q3vAegXbduB5HhzXRZIMEEYRxpMdTHZ2sX9wiIOjIxwdPcF4ZxeD4RBBEH6RIICUEul6/f+z9x7LkWTLttjae4dOrTOBqu6u7nPPeZePE9rjR/ALOOHo/Q9/5E05fkajGTnmgAOKc+85LaogU4uIDLEFBzsikEABJVGtypc1LApAiojMhLf7cve1sFotcHtzjcVijv3e2ie+a0yZc46oYS0Re/0+2m07xUBdKwLF0d8ojmoNpg2YLMCTGGK3g3tzDefyAs78Fs5iDpamtsAvbQD58Qgex+CHPXiW1uP2UBJsdg7VacN4/rtekPvHzw9I9pw2a7i3N3BubyDmcziLOcR2C5alYEpB+z5Urw8+GkNOpmBKQwLQnMNULg2/YhFNcZRAIBABQCAQfpewQlRO7VMvhFPbWT1Z0BYSx2OCw/6A3XaLzXqN4XAEz/OfrXtVdU/iwwHr1QpXFxd48/oXXL55g+VijiSJIYvik0f9q9360y8wBhgDVnaKcKId8JiWwMcKCZ6uBxQFR8bteoAjBDbrNcIwxOL2Ft1+H6vlAofDHnmWQWt7X854qQ795cK9MQZ5nmG73WBxe4v57Q0263U5aZE/ec2cc3ieh6jRQLvTRbc3QKPVgut6lLgSKI7+VnEUsMW9lGB5Dh4fwLcb2z0/7G3xXxT1SgJjDEwpsMJaBLJSOJAVOXiaIj/sIccTqFbbugMIAaMUWBmT6r17x7FHIT5LjI9lGdgxgXN7C/fmCu7r13CuLuFevIHYbCA2K6tfYAxM1IBqtSFevECepvY5XQfS8wC3tDX8Fbv/FEcJBAIRAAQC4XcHqzbM4fs+wjBEs9VCGIbW557zJ4trpRXS9IjtZm1HG5dLHGZ7RFHj2XyKtdbIsxxJHGOzXmO9WmIxv8V6vbIqynn+UQV4dU689NvmXEAI2xVyXa8urA0MHOFAKgkGVns1K2XH+bXS0MZaftmfq08iA9SJK4FkDHme22LgsMd+v8N+t0WWpVBS2oLCEXYH1BH1NXwJSCkR7w+1eOH85gab1RJpOZ781GsrHAd+EKDd7li7w07nV5tYIBAojj4ZbCypqbWdBiiJAJalYHlRK+izk9sbKcG0Bt9pOIUEkxI8Te1KwO0N5GQK1evBBKG1CYQdsTecw4QhjONCNxrlSL79Hh9afFf6CNVz7ndwbm/gXl7A/eUXeD//COfmGs78FmK7BY9ju/9vDIznQbRa4OnRTjM0IphWy9oZBiGMq2tBwC8NiqMEAoEIAAKB8LuFEDbhaDSaiKIGokYDnuchKX3uHxa2xhhopZClKXa7HVbLBdbrJXbbLTqdHlzPezYCoChsURzHdgpgu9nUHZQPTcwrey3GOVzHgXAceKXKvh8E8DwfYRSBMYYgCKC1huu6yPMcQghkWQqtNNI0hVISaZpCFgWKokCeZ1BSQcriXkH/MURA/ZpqDaZUuSZQIM9zGAMIIRA1GgijCM2mdQp4zg7h24lrgf1+h8X8FjfXl1itFogrnYV3iFY5joOo0UC320N/MECn20MYhtS1IlAc/Q3jaBkIazV84ziAcAD+dGeeATBagxUFuInBbhRYloEfDnBub6B6fehW2xb5rgvjeTBcwHguTBBAN5pQ7Q50u21v22hCNZv1Hv5bz1uRFKVVIU/tCoLVK7iGe3UF9/UvcC9ew724gFivwHc78CyzawllXDKc258xBh01oPoD+9XrQcsC0H5tF/jlCQCKowQCgQgAAoHwu01cbWe5We4bLRLxaAAAIABJREFUttptBEEAwQUUk0/urxZ5gfiwx3Ixx/z2FuvVCv3BEEEYwvtMu6jKUksrDVlIpMcjsixFlmVQSr7X1q8q+rkQcB0HruvBDwKEYYio0UAQhmg0mmg0bbIeRhE8z4fv+2Bld10rBaVscZ9lmf1KUyRxjOPxiDS1o7txfMAxSZClxzq5qxK8j9URqCYDjDFIYmC1nCOMIvT6AwxHYxyGu7K7KCFKz/HnhFIKSRxjtVri9uYa89sbrJZLHI8JlJTvfK09z+oY9AYD9PoDNNstBGH4Zb3NCQSKo++Oo4yVhb8L7brQQQDdiGxn3rVj+qxcfXqKBGDG2D38JIHYrKGjyBb/wrmbAPADOwHQiKCDCGowgOp07LRAp2sL8VYLJggsIeE4tnNfrhzcrSjEEIc9xMoW/87tDdzrSzhXV7brv9lY9X9ZAErdTQyUsQjsCH44WP2C7RYsTYHCugQwY/BrSMRSHCUQCEQAEAiE3zU45/D9AK1WC51uD51OF81WC7vtthbYeyyxlLJAkiTY73bYrFdYr5aIDwe0O91SAOvzilNjDAwMtLHPX53H+x5XCDsiX3X3m01b6Hd7fURRA91+H81mC+12G61SeM+O3HqWAGC2CyOltRPMshRFbu388szu7B8Oh/q6t5s11qtVOba/Q5alkIW8Z0f4sUSA1Qmwz3nY77DdbBDHByRJAlkUUFp9ETXrosix225xe32F68tLLG5vER/2KIrinZ7VQjh3AoaDIQajEdrtTm2LRiBQHP1t4iiMsYW5V9rjtWxXXg1H0Is5+PEIppQd+3/4t12eI4oCXGuYwgoJGseBcT2AM3tUCqYkK4zvw3ieLfrbHcjxuOzC9yE7HehWG8Z1ANcDytjO8gKsyCEOB/D9HmK7gVivIJZLOMuFVfxfr8GT2OoRyLKgf+T1ZBVpkWdgRW71DIxdf/i1QHGUQCAQAUAgEH7XsL7VHprNVm0/1+50sZjPcUzL5PCRpEVrjSxNsd2ssZjfYrVcYLfdYjAc2s7XZ44sMsbAYPfyXddFEIQIqr1aIerCukqMqv1J13URRRFa7Q7anS6GpYL+cDRGp9tFrz9Ap9tFs9my0wDl4woh4DhO3YmxxbtN0JWU9ch/5eu8226wXq2wWMyxXMzL18CO8CZJbHUKihx5ltf6Ae+bXHj4+mqlIIsCeTl9oJSC0hpGm2e3O9RaY7/b4/bmGpcXb3B9fYn1eoUkSaCf+AxUr5Xv+2i32xgMhxhPpuj1BvVrSiBQHP3t4igAGBgY4UBHEVSvBzmeQN7eWKu/OLaCf9rqmjxKAgCAUndigowBLLlbLTAGYLZDbRwBcA6xmMOEEdTlhV0F6PagWi3oZstODXAOw5gt2GUBluVg6RFiv7dChZtNSQjsLEmRpmBK1l1/9vibAMMYjOCAcGA8H0YIGMbr5/vSoDhKIBCIACAQCH8ICKfsPPQH6A8G6PcHuG1dI0liqNLL/rFERyqJJEmwWa+xWMyx226QJAla7c5zZNQQjoDn+Wi0Wuj2euh2u9iuVyiKHCnKEVXGwLmA4zoIAivA1e31MRqPMZ5MMZ2d1dZ6rVYb7U4HUaMB3/cRBCGEI+A4VmBJCFGTClWiVgv1lV28auc/SRIc9jts1uuaAJjPb7FaLLBerbDb2q59HMdI4vjRyYD3EiCcQ5QCgJwLcM6+yPqqXTmIsVzMcXV5gYvXr3FzdYXddvvOnVX7mjlotFroD4YYT2cYjsZodzoIA0pcCRRHf+s4agAYMGghwEoCoJhOwXdbu0d/OABKQmxt5/wpEqAMFPcLWMbs70726lkOgHOwLAP2B/DdDsbzoNttGMeBbrbsdfsBmFZ3t9XW6o9lWX1klQWhUrXQ31PFvynPB44D4wdQzSZ0s2lXFTzPrhx8YRtAiqMEAoEIAAKB8IdBNTLf6fYwGI7QHw7Ranew3WxKG7rHx9hNOSK/Wa+xuL3F7e01pmfn6HZ7cJrNz6j9bUfEdT2EUYRut4fJdFbbKIExxPEBRV7UtklhFKHb62EwHGMynWIynWF2do7JdIZuv492u4MwjOB6LoRw6m7/w9HK04mC6rUBYB0CTkT7Wu1O3embTGfYbtZYLhc1IbBe2XHe7WaD9XqFw36Hw36PLMuQZymU0jUZUD3m6Tm4rocgsFoFrXYHzVYTnh9ACAdc8GcdCc2yFKvVEhdvfsEvP/2Iy4vX2KxX9c7qU9MGQggEgR17HgxHGI3HGI7HaLXacEi1mkBx9DePo/VzcA7t+ZCtDth4Ap4kdlc+ywCjwZS2toBPkAAPyQAD1Dv1NQlQ/e5kWkAUOYxwwOOD7cJ7PsAAIx5oABgDVuR20kAqSw482PG/R0a8fbEwrgsdRlD9gbUq7A/uiRV+aQcAiqMEAoEIAAKB8IdBVXA2mi30BgMMhiP0Si/6JI7r8fWH0FpbEav4gNVygZtrK3jU7VkV688RseKcw3EdNKIGur0+xlPbReecodlqY7fdoCgKMM4RRVE93j+ZzjCdnWF2do7ReIJOt4sgDOH7QU0sfG5CXT2OEHZCIWo00O31MBxPcNjvsNvtsFmtsF4v7ZrA/Bab9Rqr5QKH/R677QZ5ntuxUG2V/3U51m/FC3lJfPQxGk8sidHto9FowvM8CP58AoB5lmG5WOCXn37Ej//4B3765z9wdXlZFy3v2lnlQiCMIvQHQ0yms3JstU+iVQSKo7+TOGqnmbSto4WAbjSgzAhFIe+660oCjMG5uYbY7cGKHOahPeATRAB76nfVtEDpbsKK3BbgSVKP6te3r4r8h1/vK/px1/k3rgsThJCDIYrZDHIyRTGbQXW7MFFkrQi/YPef4iiBQCACgEAg/OEghEBUFp3dXq/2H3Zc50nbvUqsLoljrJZL3Fxd4vryAt1eD0EQgPM2HOfTQhNjDI7jIiyLe6M1OLeF8WA4wna7QZEXcFwHYRih0+1hOBphOBpjOBqh3x+i1WnDdb0vNkJphZsEgiCE63pWZLDbQ55niA8H7Pd7bDdrbDZrrBaLerx3uZjjsN9jv9shTVNkmd3v10qBlbugrXYHw9EY3716hbPzF+gPBmi1WtYC8JkcAPIsw3x+i9c//4Qf//Hv+PEf/4bXv/yMzXqJY3p8smCpCJogCOrznExnGAyGaLY//T0nECiOPn8cZYwDRlsiwHEgG01gOj39Y76zBhQ3ENsNWGFV9k0lvvopz11X6XdkwOl5Vb978n7vwWnxr6MG1GgEOZshf/U98u9e2SmAThc6CADH+WIEAMVRAoFABACBQPhDgjEGrxQh6vUG6PWHaLfbWC2DWoDuqeQ1y1KsV0tcXV6gPxii0WrVlnqNRvOTEpmquK6EtQCAC4FGo4nBcIQkjut9/ajRKJX9O+h0u2i17Z7/l7DKezzBthMBxhi45TpCo9lCfzhEEo8RxzF22w0263XtGrDZ2H/HhwOyNEWaplasyxg0ogYarRZmZ+cYT6Y4f/ESg+HIeov73md3hYwxSNMjVsslfv7pn/jH3/+Ov/+//zd+/Oe/YzG/RXyIId+nWO048P0A/cEA4+kU48kE3f4AgR9Q14pAcfR3FEdZJY5X2qvCdSFb7bsC2nHsnn4Q2H15z4PYbErF/cIW8KfFe1l8nx4/mAw4IQU+OX6V523tDR1b/A8GyL/5Fvl33yN/9QOK8xeQw5F1HfD8Dx7/f8QRkeIogUAgAoBAIPx5UXXYu70eev2+TUCDEI5jx1cfEzGy46s5DgerfBwEITzfhyMcMM4xGk/QarU/qQtv1wBcBOW/XddD1GigNxigyItafMr3fYRRhDAMS/9s/zcRTjpdEfA8D67rwveDUpiwh+FojPR4xG63xTFJsFotEe/3OB4TZFlWFwdBECBqNNAfDNHt9TEcjtBothBGEVz38wiAoihwTBLMb2/w5vUv+Oe//x3/+Le/46d//gM3V1fY77bI8+ydglVV18quXEwxnZ5hNJmi3W7D/UzvcgKB4ujzx1HAag2Yqvh2HKhWuyQABOC40EEIHUVwO124F68htlvw+GAV+pWshfhOtVDwESTA58KcVulCWLvBZgtqOERx/hL5998j+8tfkX/3CsXZOVSvDxMEwCOvmSWP76gJVsZtA3PnfEBxlEAgEAFAIBC+hsTV9wO0O93ai/i6eVEnM48mZcZAKYXj8YjlYgHOBVzPChdJJVFkOSazGVrtzif5WlckgFXEFwjD0FrzlcWy3cV34LhOPe7/e+mcVFMMnAdWKyBqQMoC/eEQeZbj7JhYh4D0iCzLIGUBYwDXdeF5luxottqfTWwYY2yBUeTYrNe4vbnG659/wi8//Yh//Pu/4fXPP2F+e2P3VfPsyS4lToiYZrOF4WiEyfQM07MzdLo9hFFEftUEiqO/0ziqq+Ifxv5XkgCGC2jXg4oiq5zf6UJ1u3Cur+Es5xC7nVXlz7NapK9kFKzYXyVu+A7NgE8t+OtivLresutvggCq3YEcjVG8eGnH/l99j+LltyjOz+3uvx+81fmvSIvT148zgIGV5MjTxT/FUQKBQAQAgUD4cwYS11pZ9fp99AdD9AdDrFcrpGn6pIq1LhWfk8RaIAnBrcq9lCjyAkWRYzydod3pfpK3Nee8Lqa1q6G1fzenWY7fV7f5PSZO1XlZXQMHnufDNAzasg0pJfI8g5SqdgUQQoAzDtf34DouXNe1doCfUPzb/WKJJD5gtVzi8uIN3rz+GT//+CN+/vGfuLx4g9VqgcNujzx/WqyqgigFqwbDEc5evMTZixcYjsbodDpwXY8SVwLhdxxHzUMrPyGgWy0rouf70FEE2enAHY3gjsZwlguI5RJivwPf78CktKsBSoHlpWp/kVvlflnU4oFlxfzousBjRzz4d110l91+O6ngwnjlvn+nCzmd2s7/q1fIv/kWxflLyPEEutOB8byaNHj4Wt9NapWxGZXuoHmy+Kc4SiAQiAAgEAh/Stgi20EURej1rKL+zfUVlosFjscEWilIKZ9OkIoCh8O+/N5AygLH4xF5liJOYsxm5+j2emg0mnC9j0tyHu7aP5bQ/RFe3yr5q46e7yMIQ9stMgbaaDCUhEFJbFTkxsdCSon0eMR2u8FifouL17/g9S8/4+cf/4k3r3/BYn6L9WpV+5S/a1wVsFaIQRiiPxhgMpvh7PwFzs5fYjgcIYoa5Ff9JXBCdBEojj5XHL1XGDMGE4ZQjgMThNDtDlR/CDmZQawWcBYL8MPBigNmKXgcgxWFXQ/IC2sfmKYQcWzJgELW0wH1mkBld1p9rB8c63/bqtyekxB21N9xYDxLTuhmE3I4ghyOULz8BsX5CxQvbOGvhkOoRhPwvHoi4dHrx/3CX8O8c++f4iiBQCACgEAg/KkhhEAYRugPBhiNJ5idnWOzXiGOD5CFTW6eSnBOk1elFIoixzFJkCQxttsN9tsdprOZ7XR0e/CDAI7jfHRx+2fpjpwSAlXSd0pufOp1KqWQ5xkOuz1WqwWuLy/x5vUvuLx4jZ9//BHX15dYzufY73fIS+2Bd3WsakFG30ev18d0dobvXv2A777/AdOzM7Q7XXi+T388z1n0V6rp1b9L0bP6SKA4+pxxlDHA96EdxxbaLbtbz7dbiP0efLcDTw7gxyPY8QieHsHjGDw+QOx24IcD+HYDHh/A93swKcHz3NoAlkKCTFcWf9V1P3h+xmB4ud/vendTCc0mdBhB9QeQvR6K8QRqPEYxO4ecTCGHQyv2F4ZW7f8d18nrvX+77a/fEff+CHH0X7+d0B/bb4j/5+cbehEIRAAQCIQ/R1Hqeh6arRYm0yl2uy3W6xX2+521q9MKsijem7wm+gClpFW4Px6x322x3W6w2aww3Wwwnc3Q6w/QaFql619Dsf+PRAp8fM1od4ilLBAfDthuNri9ucb11SUu37zGLz//hMuLN/WO6jFJIGXx5DjyKap91U6ni8nsDN+++h7fvvoeZ+cvMBgMaWf1OQt/rcGkBNSJT7vWdx1Rx7UdUde9IwQIFEefK46WXXflOtCNJli3C3VMwbIULD3aFYA8txMASQx2PMJZrcDiA9z53E4KLBdgeQax29nCP47BjLY6AoyBFQWMEGBS2qNS9vPMmO30+x5MGEH7AVSrZcmIbg+q14MaDCH7fajBCLLfh253rM2f59lzNwZgb8fRqu43xpb+5R/cHzqOUvH/2+Nfv50QCUAgAoBAIPw5ElfHsfur/eEQ50mC/W6LJI6RHo9QUuFw2MO8w96oSobM8QitFLIsQxLH2KzXWC0WWC0WWK+WNvEZjtDpdtFoNuGT9dEnF/55nuGYJNjvdlguF7i5usTlxQUuL17j8uINbq4usV6tcDjsUeT5k2rkTyWt7U4Hs7NzvPzmW/zwl7/im+9eYTY7R7NFftXPVvxLCVbkd13WJLHFlixKAsCKnxnfh240oMPwzuKMiACKox8QR+99TN4heAfhwIRO+Vlr3pFS2gCluB0rcrA8B9/vwJME+XoNsdtCrFfghxj8sAfPMrA4BpcFWJbaz3lRAGBWM8BxwbSy9oOcQ4cRjB/Yrn+jAd1qQ3U60O02VK8P3WxZUiCMoKMIqIiw6nqf+Dswj9f7f9g4SsU/kQAEAhEABALhWcE5h+f56Hb7yLMc8WGPOI6RxDGkVNBKITExpJRPJq/GGMhyH7Iohe7i+IDDfo/1aoXlcoHVconZufW6HwxH6Ha7iKLGR++1fq2ovMOTOMZuu8VqtcTi9hY315e4urzE5cVrzG9vsJjPcdjv627Vu9Sp79UAQsBxXLQ7HUymM7z89jv87V//I7793natWp02PLKrerbin2eZHavebSE2G4jNyo5Wp6m9mRC2KGo0bUHU6UK129CNhiUCSrE0AsXRp+Jo2SAvfe/Kf7+LCCiLa+O6JxaAJ8Z/WoMNh2BpBp4k4Ikt/NnxCHE4gGWZ1QqQBZBl4FIBRV7e965bX021GD+ADkPoqGE/61FUHhuWjKhIL8e5T3x9xuee4iiBQCACgEAgEHCqUjxElmX2Kz0izzMURQ5tNI5J8t69R601TFEgUQqykDgejzjsd9hu11gu5ljMbzE7O8fZixcYjScYDEdotzsIwvB3Zen3+6oXDYo8R5LE2Gw22KyWuL25wdXlGzuuenmJ25trLJcLHPY7JHGMoijeWWg89v57nl+OMM/w6oe/4F//43+L777/AS9efotev48gCOnNeI7iv1RU54c9xHoF5+YGzu0NnJtriPUaPD7UxZiOGtDNpt2HHgzsSPRgAN3pWmLA8+6KIwLF0Ufi6Pu64U+iEuh7QBCcivQx1QXL7NQKyzK7xpJlYFqBZZVrQGHvq9SdDIDjwAgB4/kwngft+zC+X37vwjgu4AiA8WcjuiiOEggEIgAIBALhYVBxHDSaLYwnExR5huPxiKISsCpHH7M0fW/yWo1XZlkKKa2d1eFwwH67w2q5xGo5x2q5wOz8HNPZOUbjCbq9HprNFoIwBOeclJHLIkAphfR4xG63xWq5wPz2BlcXF7i+usD11RVurq+wXi2x226RJDHyPIcqE9aPSVp930er3cHs/BzffPsK/+G/+Y949cO/4JvvXmEwHCEMI/oDeSYCgEkJfkzAdzs4iznc17/A+/knuK9/hthYYTWmNQxjdje60YDq9yG7fcjpDHI0ghqNIPtDOy7dbNpVAefBeDSB4uiXiqOcW/V9eDB+UH+u7XRLAVaN/jNmf24DmtW10Maq83EOw60GARwBI5w70uEZP8cURwkEAhEABAKB8A64rot2uwN1dg6pFLS2fvXGGDDGsF6vkB6PH9QVqXZa7a5ljixLsdttsd9tsZjPMb+9wc31NWazM4ynM/QHA/R6fbvXGgQQwrmnmP+1oNozTY9HxPEB69UKi/ktri8vcHnxBleXF7XN2GZj348sy+ri4kMT1lOV6m6vj+l0hm9ffY+//od/xQ//8je8/PY7DEdjRCT695ysTkkAHCG2GzhXV/B++hH+v/1/cK6uIHbbsoNa2qh5LoznQ7XacJtNyOtLqN4AcjKBHI0hx2PI4cjuTrfb1tYtCGxRRUQAxdFfI46WnzNTPb5yy6mDynYQZdHPUe8fMGbdAVg11l+uGTzjZ5biKIFAIAKAQCAQPjR59Tx0ut06geKMgzPbTXJct/a3VlK+dy+y6qCYooCuEtg0xW5rVbIXizluri4xnkwxnk4xHI3R7fXR7fbQaDYRRhE8z4Pren/qFYFq91fKAlmaIj4csNms6wT/8uINbq+vcH11ifVqidVyiTg+1J2qj0lYbc7O4bguwiBEt9fDZHaGV9//BX/569/w6ocfcP7yW0pan/9NvuuQHo8Qux2c5QLu5Rs4V1dw5rdWCFDJOyvAhMFwAb7fwfg+xHIB3elaIqA/sCTAaARVeqWrXg+qXA+wUwGOJQMIFEd/rTj62Oft0Y+goDhKIBAIRAAQCITfAxhj8DwfnW4PxhhwzsE4hxf48P0AQRhicXv7UcrIVQfLGIO4TGCTUn15fnON25tr9N4MMJ5M0O0NMByN0O310W530O50EDUa95JYxlidxFaJ1R8pwaoSeq01lJTI8xzHY4L4YDtV6/USy8UcN9f2tZnfXGM+v8V2vUZ8OCBN0w+2o3qYsFbdqihqoD8Y4Oz8Jb757hVe/fADvv3ue5y/eIneYEhJ65f42yonAFieW0/15RJiu4U47EsXgOyuc1r/PUqroF6KBurNxhIBzSZUrw85GEINSjJgbCcDVK8H1R9YdfUosusBJBpIcZTiKMVRAoFABACBQCA8leCEYQjG+jbZ4RxBEMD3AzRbLQR+gOVijs1mU46yflgSpbWuv4oiR56l2O922G42iBq2M9PudDEsba76wyF6vT463R5arTaiRoSo0YDjuPA8r1ZcZpzDEQKsTMw457+LpKt6PapjlbwXRQElrd93crSWYbvtplb6Xs7n9V7qYjHHfrfDfrdDnpViYuVr+LEJq+t5CMMI7U4Hw9EY5y9e4sXLb/DNd6/w8ptvMT07R6fbJaGqXwNKWZG0LLMWa1rZXerHPkNK2bUAxiCKAvx4hNntIJZLOLc3UK025HgC3e2imJ1BjkaQ4wnUcGQ91VstqydQ+afTVADFUYqjFEcJBAIRAAQCgfAw2QmCELxvk54gjBBGEdrtNlrtNl7/8jPC66vaJ/ljhJOqJDdNU+R5jvR4xH6/w3azRhRFuL68QKvdRqfbRafTQ6fbRavdQavdqkWuoqgBz/cRBiEc10EQRnBdF0EQwPMDeKUtlhDiV0ti631dKaG0gla6TFRth68oChRFgfSY4Jgk2O129rrXayyXC2w3ayzmt9huNlgtlzgc9ogPB+RZVltRfUzCWl2/EA7CKEKz1cJwNMJ4MsWLl99gOjvHN9+9wnQ2w3A0RrNFFlW/Ciqxs8oSjQuYqth6OAFwWgQZU+sIMFmApUfwJIZYreCsV1CtFpyba8j+AHIytRoBNRHQtesBUQM6DO2+NU0FUBylOEpxlEAgEAFAIBAIp8mr7wfo9uy4YxAEaDSaaLU7aHe66HZ7uLq8qJOt9JjYrswHjrNWX0opSFkgTVPEhz02mw1830fUaKDRaCJqNMrOlf0+jGwHy/d9NBpNBGGIRqOJRrOJZtMeo6gBv+y2Oa4DwQV4mcSefn0sqnNmjNXjp1rrUqm7QJ7lyNIjiqJAVnaa0uMRRZHjeDzablUcY7fb4bDfYbfbYrvZYLtZY7/fY7tZ45gkSJIYRV5AKVl3vD5WmEoIx75nzSZ6/QFG4wnOXrzA2flLnL14gel0htF4gk63hyAM4Tj0v5YvWfSbykbNdaGbLehOB7rVhglDmPgAJiWMUnjsU8kefAYhJZhS9j55boUF12vo1QpOqw1VEQGjMdRwaAmBigjo962NYLUe4DhEBFAcpThKcZRAIBABQCAQCNUuq1d6HHsIwhCtVhvdXq8eK72+usDN9TU2qyX2+33pfZ2/1+qqLmZgxzqVUpBFUXezDvsdXNeD63sIg7DeuRSOQKPRhHAcRGEEPwjQ6fYQNRroll2udqdTJtlt29EKI/i+D9d14boeuBBwXbdO8qprfex8qwTVaA2pJIw2kEpCSWmT1TzDMUkQH2KkqVWdrpLP9HhEkiRlx+qI9Gh/HscJkviAOI6RHA5IkhjHY+UZbsW+KnGwj0lYOef2NfNcNJsttDsdKw42meL85TeYnb3A7OwM48kUnW4XjUYTjuv+aQUWf2eVIOC41tqv1YIcDCDHE4j1EixNrUZAnlsS4B3v+b2pgGo9QEq7SpCm4IcDxHoFp3UNdXUB1R/a56pIgNEIcmBFA3WrZckA3yf3AIqjFEf/gHH0//jf/y9cXCyIw/tMSKnxt7+9xH/67/9GLwaBCAACgUAArM9xGEZwHBdhFKHRaqHdsfulw9cjDIYXtot1e4v1eoV4v687Nx8jslQpOSulwBhDnudgR45YHMCFTcpscmaTLdtxcdFoNuq9zChqoNvrIYoaaLZaaDRbiBoNO/YaWAGuIAgQRvZ6HMcFY/YatdbgnENrDcYYlNKljZeqx3OzLEOe2bHbY5IgKYWnDvtd6dW9RZZl2O93tiN3PEJKheMxhpKq7ErZTpaUElmWQiv9SV0qW1dyq0jtuPB8D41GE81WG8PRGJPpFLPzF5idnWM6O8N4MsFgOEKz2YLn+yRQ9SsTAMZ1YYIAqtdHcfYCYr8HP8ZgUgGMge934FkGoxRQdn/ZhxAB1XqAUvfXA9Zr6MXCTgVcXVrhwMkEcjxBMZ5ADYYn7gENmCAk9wCKoxRH/0Bx9L/8l/8V//W//p9E4n4m0jTHf/7P/wP+E70UBCIACAQC4aTgeNDFikK7y9rt9TAYjjAcjnB1eYHLiwsrbrVe3bNZ+piE7FThmTEGJSUYY8jS1CZbjFlrLc4hHGG7Na6LMAwRhCGazZZNsJtNhKEddY2iBsIwRKOWIkqqAAAgAElEQVTVQlT+zPM8+EEIUSbFxhgwzqHLrpG1lZK1cFSapnb8NEmQZ2mdtCZxjPhwsCrUcVx3s4zWyLIMAJBlGYwxyPOs7n6ZEyGqj01Yq06VcOyIahQ1rOjXYITReIzJdIbZ+Tmm0zOMJhP0+gN0ez34fvDlfMEJ73rDYBwHOgzB2m2o0Rj5Man3/o3nwbm5htnvwY9HMFkAVff3EYHAh0RA+SGyEwSlVoDJMksGbDYQ6xV0ownn+gqq34c7nlrBwNJBQPX7UN0udKsNHUZ3RACRRBRHKY7+buOo57kIQx+c09/pZ4ZnuC6VVwQiAAgEAuFRCCEQBCFc17N7pe0O+v0hhqMxRmPbGbm+uktgd9stjsfkg+2unkpiH0vcGGNgOUPKjuBCYL/bwXEdeJ4Pz/PqxNT3ffhBYBO8RqNO9FzPRxiG4KXqNS8f0xgDpTW0UiiKHEVuR2qzzCaueZ4jLUd0szQt91KPtquV57ZjpxSMAZQuu1HldZ928j4mUT1FlbB6nld26vroDwaYTKcYT2aYnZ1jUopSDQZDtNodBGFYj+sSfrM/Hhg/gGpVH25tfyYcqFYbbrMJZz6HWK/AkwT8eASU3fc3WtdEgMG7JwNO1wOYlECpE2B2W0sE3LZKImBoCYDRyE4GjMZQvT5UfwDVakM3G3c6AdRhpDhKcZTiKIFAIAKAQCB8nWCMwXEc8CiCV4pItdpt9Pp99AYD9IdD9AcjXF68xu3NNVaLhd1rzdJPTmDfl9AypSAZQ1FwpMcjOBcQgpf2Vg5cz46p+r4Px3URRQ2w0prLGAPP86C1huu6KIoCnPO665TnNhGtxnGllJBFUYpWSTt2KpVNUrV+dO/0U5PUtxLWEyuqTreLXq+P2fkLTKZTTGfnmJ6dYTSeoNfvo9lslQm6RyOivycSIAigGKwDgOdBhxF0uw3V6cKZ38K9voJYrSwRcEzAjkewQoKV3U5oDXNS8D9GApQfOvu50xqMle4BWWbXA7Zb6PncEgGDAWR/ADUeo5hM7UTAYGinAlptux7g+3dkAIHiKMVRAoFAIAKAQCB8fbjbm3RKNWmrNN3rDzAcjtAfDHB9dYmbqyssFnOsFnMkSYK0VHjWZQL7sWOb70pkq3FXQN5TqbbnWnaohN31BADXcwFj4DgulFJwHAdSSnDOoUp/dinViXiVhtYG2tjz1idJ6nNcx2NFgj1nUVp0hWi1WugNBhhPymR1NsPZ+UtMplP0BkO7wxtGEI5D4/6/WxIghBYOCt+HbjShej04ozGc22vI6QzOzQ3EcgFnuYDYbsB3O/D0CJblYEoCpU7Au4iAt8iAaiqgKICSCOC7nRUNbF5D3t7Cff0axWQKNR5DDkdWOLDfh+r2oKPIkgGuR+4BFEcpjhIIBAIRAAQC4WsFYwye70M4DvzS5qrdbte2ScPRGIv5LW6urrBZr7Ber5DEMZIkrvdDnzuJPT0CKAWxZJ3IVgkhYgAnI6vV7+v7niSkp49XJcjPnahW51bvpgoHjms9qKMwwmA0Qq83wPTsDNOZ/ZrMzjAcjmrRLupU/SGqPttVd10Y34dqtyH7AziTKcRqCWcxh3N7c0cELOYQmzXEdguWJGB5BlYUdsT/YRf3XWRAdVtjwJSCKArwNLXrAZs1dKMB5+YacjC0jgF961aghiPIwaCeVNDNlnUPcF0iAiiOUhwlEAgEIgAIBMLXiGqv1XFcRI0G2p2u7WKNxljM55hMr7CYz7G4vcF2u8F2s8HhsEcSx3bnM88glXrWJPZhQvswmT1NFk+9qd9KYN+RID9fTcjvbKg8D47j1J7d/cEQnW4Ps7MzDIYjTGfnGE8mtQd1s9WE7weUsP4RiYAggPF9uwrQ6YIPh5CTCfiLl5YIuLmxZMByAWd+C77ZwFmvwJIEPInr9QB8wHpA9fPaPaAkAliR2/WA+ACx3cKZ30Jd96A6HajhEHJgpwHkeAw1GEIOhtCdDlS7XRIZHrkHUBylOEogEAhEABAIhK8NjDG4rlvvWFaqyqPxGOPJBJvN2tpcrZZYLhfYbtY2gd3va+/n9HhEIQtIeV/h+VTp+bnxsNv1JZ7jsdeqSlir0VrP98ox4CYarRa63R463R7GkykGwxFG4wlG4xEGwxG6Pbuf6gdWkZqEqf7QfziA60I7DrTvQ7U7EL0D5HgCZzqzY/q3t3Buru1EwO0txHYDZ7kEP+zBkwQsz2v3gI/WCQDu1gPSFOyYgO92cKII6uYGTrdrLQOHd84BclSuCHR70K2WdQ/wSiKACiiKoxRHCQQCgQgAAoHw9YBzDq/svvhBgFarjU63hySOsZ2dYbfbYb1aYr1aYrNeY7NeY7tdY7fd4rDf43DYIz0ekaYppCys4JXS9c6oOelsfYmd0S+RpL41NssYHOFAOAKe5yMIw3rst1vaTY1GY/QHQ4zGE3R7PfT6fbQ73dqDmhSp/2QkAGOA58F4HqTvg7Vb0N0u+H6MYnpmNQFWy7upgMUcYrmEs15anYDD4cn1gA/SCSinArhSQJ7DHI/gpXuAuYmgutdQ3S7kZFqvB8jxGGo4sgRBuwMdNer1BpSfcwLFUYqjBAKBQAQAgUD4yhLYIAzRKj2vj8cj4sMe8eGA7WaDzWaD7WaF5WKB/W6LzXqN5Jhgv9siz3LE8aFWkNZaW0VprSALWatG6/LrdAT1t0xQq1HUU79tLqyaNhcCfpl4Ro1GbQXW7fbQ6w8wGA5rEbBOt4tur49Go4moYXdTKWH9Gv5v78A4DpQfQEcNsF4faji0wn3nL+BURMDNtSUC5rdwlssH7gEFWDURUI394+N0Aqr1ABz2dipgfmtXBDpdqw/Q66OYzuyqwGhsbQTb7XIqIITxfCICKI5SHCUQCAQiAAgEwteWwN4pXQdotmwCm2cZkiRBHB8Q7/fY7XbYrFfYbbfY73fYbjY4HhMc9nsURY74EENrhfhwgJRFvfeaZRmkLN5KZE9HUZ8zkT3tQt1LVDmHIwQY53Bdzwp7efYYhCE456XAlLXQCsII7XYbzVZp/9Xvo98fotPtot3potVuI4qi0n/aq19Hwlf1x2M76p4HHYZg7TZUrwc5nkBMZ1YnoLT0E6sl3KsriO0GYrUEj+NSJ6Cw4/1KffhUwIP1AEgJURQwSQJ+OEAsFhCLBXS7DefqAqo/hByP7ddoDNUfllMBpZWg59v1ACq4KI5SHCUQCAQiAAgEwtcDIYTdbS3tmBrNFjp5D3mW4ng8Ionjeo+1ErdKkhjHJKkT1SSJcdjvkSQx4sOh/n16PCLPcyuGVeQo8gJKW0EspdQHJ68Pu0KPjZ1yxp/0yHZdD0EYwnGtABXn3HadXA/NZhOeH6DVatUdq3a7g1a7jU6ni0arhUajgSAIrSp4+XoRvnIwdjcV4PnQrTZUtws1GNr1gNkZnMUcxdkLux4wv4VYr+16wH5v1wOy9PPWA7S2UwGyAEuP4McEZm1dC1S7A9XvW12AwQDFdGaJgMpBoNOFbjShvdJGkAowiqMURwkEAoEIAAKB8HWh6sTYJNZaX6l+3yafWY6s9LpO0xRFkeOYJMiyrE5YD/sddrsdDrsd9vsd4viAJI6Rpanthh0OOBwOyLIUeZZZQax3JK+1X/RJcmp/xuoEtfKFdl0XrufB9wP4vg8/CBCGIcIoQhCECMPI2k41GvA8D2EYIQgCBGGIMAwRNZsIgwiNpu1gBUEAPwgQ+EH9HDSeSng8E7BEgPE8mDAC63Rt8T2ZQKxWEJu1XQ+Y31rdgMUCYr2yX4c9WJqWooHybj3gYdH/BBlgSrcBSwRImDS1kwa7nZ1GuLY6Ac7VlSUnZmeQo1FpKziE6nSgm03rfuCUOgFEBlAcpThKIBAIRAAQCISvC1WHxhgD3w+gGxpKSmijIQsJACiKHEoqpJkVtkriGElsu1j7/Q6Hwx6HnU1gl4sFNusVbq6vsF6t6nHWU9uqh0mr4zgQwgpuVcJbp4rcfhDA8zwEQWiTzCBAEIT1/mkUNdBstmxi2mjADwJEUQOO6yKKovIxQ7iOA8/z4bj2yAWH47h1skoJK+EDK7+79YAggG53oPpD8MMecjqD2Gzg3N5YfYDF3P57tYKzXIAfDnc2grK4sxH8wKkAYwyg1N16QJ7b9YD4YIUKl0uoThvOzRVUbwA5mZQOAmPI4chOMLTbMEEIHQTkHkBxlOIogUAgEAFAIBC+RlSJW7XrCgAmuL+DqpSCUtLuraYpsixFWo69JkmC+LDHcrnAm9e/QAgHWhtkaYqiKJ5MXCvf6KjRQLfbR6PZRKfbhSOs8JbjCESNJlzXs6OlYYgoatTdqShqnHSuAoRhBMd14ThO+eWCcTvuyvndOGotcvW1ouokfkmxMcbs4z/H8WOe89f7owE8z9oIBgFYuwXV64ElCcRkCrFZWZ2AG+sc4F5dgm82cJZz270/HKzYX56/JRr40esBRQ6WpuDHxE4cLJfQnS7k9SVUf2BJgNHIrgZU7gHleoCdCnAsGUCgOEpxlEAgEIgAIBAIX28ye3q0SZ8Hz/MRRQ0oJaGUhpQF8ixHnqVYLOZwHBf77Q7L5QLCcd5ZlHHO4Tou2u0OJtMpzl68xHA0RrPZRBCEcD0PXpnY+n5QJ6i+78PzbUfLftmOlOt6MMbU3biH1/DVF/1VB1mpu6NWYCdq9U8SBVVBzrntXH/IEYCpCkvGqzf9XmFvGAMz5q3jo5fw2PvHcPe4J89T3bZ+TK1hOLdHIcCU+rxj+TjVtRrhQDeagB9AN5u1VoAcjeGslpCzGcT8Fu7NdUkELMH3lY1gDp5ldiqg2vd+BxFwetmnUwFMSpg8B09i6M0GYrkoz6VnC/9+v5wIsJMButuFHA6tTkCjYdcDSDSQ4ijFUQKBQCACgEAgECpU465Vh0trDdMw0EqBC4H1col2p4MoiuC67vuyY3i+j063i/MX3+CHf/krvvnuFVqtNvzAtyOtpeWU5/twHJucCkeAcw4hnHrvlZLSd0BrWyTmOXiegR2P4Glq99JlAZblgNF2tPzh/R4jAIy5K4YdxxaeD4+uBxgN47q2CHfd8n6OfRzBAaUBR9gjZ4B+hHCo3te3vgdgAOMI+/iOa7vo5fOgtDG7R2a8a7rgKbLDmLtzq4/cPnlFNtTkA6tfM6YUjOtBdzqQQsC4HlSzBdXpwVkuoAZDqx2wXUNsdzDxASxJ7ogAre3u/6esBzAGURTgSQKz25Y6AVfQzaYt/NsdFLNZKWY4u5sM6HShm+QeQHGUQCAQCEQAEAgEwls552lHC1CMlYrSHhzXtTurWr33MRhjCIIIvX4f5y9f4tvvXtnxVccFF8KOnTIOfrJjSp2ojyv+WVHYEfEkhthuwLdbe9wfwI8x+PEISAWm1b2iv54MeFAUm0eKcqb1/Z+XQnPVBIBxHFswl4X5XdEMMG1gOANT+q6IPi3ST6YFwHCyt14+FmN1wWqqSQPB75/7aQEvTqYUTq/tSQKgvH3Z8TeiJB2EY4kALt4mClT5+LIAAEu4yAIQHLrZvJsc8FwYPwDfh+D7HUwcWxIgz+uJgI9xD6imB6A1GAr7GJyDH2IY14FzewsdRXB/+Rm607GCgeMJipffoDg7RzE7g+52oRpNwHWJBKA4SiAQCEQAEAgEAuGJRJSXhZrWEEKAl8UYY+wtBWtWKlV7vm9VtJtNdLo9dLpdNFvte0rSlKB+ZvF/TCB2O4jlAs78Fu71NcTSqtTzw8EWp3lu1wGqPePTtYDTolgIW5Q6jj0KAUhpvy8kjOfWEwBMSWg/sN1w3weUBBy3niCAMfZ+1f2lvCu2H3brq2K8IhROyYaScDCcP+j8V2MCD7v+5c/ZIwQAzNu/v/vQlufO7z9vRWxUtylf+3ufd2PsYyoFJlW9/w9tYCphQRlCl4/JOAfLmb2tLOr344NtBMsrQbXuISVYzsGPR5jNBs5qCR2EcK6uIEcjODfXEN++At/vULz8FhiNoNsdGM8jEoDiKIFAIBABQCAQCIT7MMZASgkpJZRSyLMMWt/vXj52H1XaWzHGa+sqIexoKuGz3hBb+GUZ+OEAsVzAvXgD7+ef4L55A+fmCmKzBk8SsCyr7elY2T2+V/if7vY/RgA8JAKkhPH9kghw7V6761oiwPPqVYH6ftXjlgQAU+puX/90vP60gDkp8k1djD8owh9OE5TXcLe+4ILJwpIVRW6/z3N7jnlur+Hh90VuR+RlAeP5YEVxd22OAFMaRnAw+cQ1lK9rPV1Rki6skIAs7PtQnWtJkhg4tVBgdX/zDhLgMTIAxsBUZACTYEUOfuIgIDYbiN0OPEvBpCWBJOdQrTZNAlAcJRAIBCIACAQCgfCg2CjVr+tuE+fvLBpsgmo7V57vwfVcuJ4LzslD+rkIACbt6L/YbuHeXMP7+Sf4//53uL/8DGexAI8PJ8V/1fE3TxMKH/y+1APpJ+J/J+PxJ9XroyKA2tRN+Ldu90BE8FFy4LHzfkhi3BMsFIDRb9+u/jl/+wgDU4/+88ef7xQPz/ve1EH5I6XsRZf2gEyfTGE8omnwISTAo4RANU2gNXipDcHyHCzLAG1FDo3v2y/XgxaCXAIojhIIBAIRAAQCgUC4Q+VTLWUBrRXy3Ppem3dYzdkG6Nu3OVWeJnzyGwImlbWG223h3NzAffMa7s8/wb26At9t7yzonnIBOC1oHyMAPtbG75H3tO7jV1oCTzzGo79/uMP/2GfmrRF/3OvEf7AdIX9CN+B9z/moc8F7nuvhYz08PpN9Iys/J8hziGr6wxHQDescoLo96GbTEgHvKUQJFEcJBAKBCAACgUD4ilB1rjjj0NrA87z3jp8yzuD7AVzXg+u4EMK5t7NK+ERUInCyAMtS8P0OYr2Cc3sLsVpZ+7k0rQXmqmLQnBSG5vRYdZtPus71sbKre6xQPTma05+947xPH/O9R6XunfeXJlTuHb/sH9OThMCDwYhnIwKMlFYkcrGAe3UJOTuDnE4hh0Og2aI1AIqjBAKBQAQAgUAgEE7rI9u5KooCxhikxyOUerd6tdEGRZHf61yZcteVktfPLCRqEqC0/0ti8LS0/8utujx7pLh8+O8PPX5IkYmPvO1zn8MfBifkyVuEyxe63opQ4ccEYrO2ApG7PfgxsToJ2r+/6kCgOEogEAh/YtD/8QgEAuF9gbLcW2WcQSsFz/Pem3wyzuD5QelL7UKIUv2cklYCoS7MHzt+KeKhIoxYmlqnAqnAtH7W1QMCxVECgUAgAoBAIBD+4NBaQ1edKxhkWQb9vnFpYztXWmtoo2sPc0OFxufXcpVFnSNgPA86akAHIXQQwHguIAQMYziV/Xv47485Ev4knxvOrK2hEABjd3aLBIqjBAKB8BWBVgAIBALhPaj2VO3uqobjuo/6Vp+CcQ7P88uulQMuBLigztVnoy7+XRg/gG61oXp9yPEYYr0EzzLb7T0RAbw3Pnx6LJX56+Pp78s9dfMhInpf08sPPDm6/6WOn1342z9iq/rfaEA1mjBhCLiOdTt4l9MCgeIogUAgEAFAIBAIXxe0UtBGl+rVGnmWWv/qdxUdxtS3rxJc6lo9WyUB4wjoMIJqdyAnE/DDHjw9AozB8bzntwF8ovCvPe8/hAz4WAX9h/d91+OdPsZT5/uxxyc+16fEyGcd8cTURakPgGcgAeri3/OhOx3I8QRqOLQuAGEE4zq0/09xlEAgEIgAIBAIBMJJTVUWCNXRcVwwxt+ZiAoh4Pu2c+U4DgQXEORf/UxvCLMTAEEA1emgyKeAlLbICCKozhXEZg2eJCckgK7FA+8VyJX9ndZ2NFwpwHHssfpeCPv41dFx7JFzMClhOAOTyj7O6f0qW72Hz/eAzLhHCDwsvk8IBlYVS6eP9dg1nH7PBWAeuV39cw7ok3M/ff6HdoVawzAGps1bLXpT2hiah9fz8L71Y+P+7r3Rd2TKg69PJQHqVRHfh+r1UZy/QPHyGxRn51C9PnQYAsKh7j/FUQKBQCACgEAgEAh30EpBawMlJbTSyPMMWqsnk9BqrFVKda+4MLRV/mwEAISA8X3oZhOqLKqN50G32uU6wAr8cCidAXJAK7sSgIeF50mR+xgBUBX8hQQcYQt+IcCyDHAcsDSFcd2777MMxvPA8tz+XEoYR4BJBSO4PXJuC+Kq8/zoNMBJkQzcP3fY82ePEABGCDClYBzXKty7HliR2+/z/O7cfN+eq+/ba/B98DSF8ey1GMcFK3JLFKgT8oNz+/iPXcPpBMFj0wQnRX0lvsekBKQEkxJMKfucSluy48TK8ZMK/5Ikkv0+5PkLZP/yV+R/+RcU5y+gul2YMIJxiACgOEogEAhEABAIBALhNBGt1KvLJNR2rp7eXTXGgHMO13Ntx0oICMcB54JezOcC5zCuCyCCYvbfJgyhOl2I7QZ8fwA/xuDHIyCVLShPuv/3us1Vkcr5nTDcg873Y8QB09o+pi4LVmNs0X7a/T+dAgDengA4LZ4fju+Xt7Wdf2Y79lqXxTPs92+tFZTMAeOPjPObt38P8zbJUBbezJSdfqnuEQD15MGD164mUYwBODsVVKivvXotWZ6DZSn48Qh2PIIfE/A4Bjsy8DyzUwkfU/RXr2O56298H6rdhuoPUJyfI//2O+R/+SuKFy8hJ1OodgfaJ/s/iqOEPzsefrqI7iMQiAAgEAiE90JrVatXKyVRFHYn9anOVSV2pcuCqrK/Mu9TvCZ8EglgOIdxHJggAGt3oEZja/UmC7Ast+PlD1/7h6sAJ0XsXRfdKTv4zl3nvygAIWx3nTGwQtpiWdkVBNvhZ2BK245/NS6vy6JYaUDwu6Ox6vSsFCI8PdbZqzF3xX5VmFf2dTh5bG3sY1YTAY914B8W7Kw8J4ZaNPGOCKjWHO6u6d7qwWm3H2XnneHxjnpJjjCl6oJfrFdwViuI1dK+rtWag9L3ro99ROGvwxC61YIcDCEnExRnLyDPzurRf9kfQLc7dvyfuv8URwl/umLfGHY3PMUYWk4BlxlkhkMahkzxmgoQMGCMJkoIRAAQCAQC4QEY7nep7hq1T3euGONwXQ/CEWCcQ3AOLqhz9SVIADAGIwSU54GFEZQqx/21uuv0P1aQPlYU39uTf+RYdfeVBji7K5arouThWP7Dff2H5/Kw+HlidJ69tbaA+x32x4T83net5oSU4LwuwqGk/dSXBEBFEEA/rg3w1nk/Xv2ByQL8cIDYbuBeX4EfE0vOpCl4EoOdajYo9d5E/9QRQkeRLfyHI8jZGYrzc1v8z2YopjO7899sQochjOfXVoAEiqOEP37Rrw2HARAJiZYj0fNyvGAH/M//2//y5P0WYYT/6b/7H7HIPJoKIBABQCAQCIT7SajSCkopKGm7VlLKd1tXlcWQKvdbqzFX6lx9qcqCnRSDzjuLimd7Pq2fPr6PSHhXsf70B/Ht06imBcpdfHaqAfCxR87vVg10uXNdTi8w/cR0wsNTfGqXW2uw9Aix2YAndtSfb7dwbm/h3NzAWcwhtluwY1ISN+WawLuKf84BIaADawUpB0MUL1+iePES+TfflYX/GdRgAN1owngejBB3hT8V/xRHCf8/e28WI8manue9secWuWdWVe/nHI6HlEnaGnPVkNaIlAECFjSAYZsLIIrkyBbpC1sGZIE3hmRABngh+IIgLI9lgtIMxUVDmCJNmhc+nOEyY3MM2IRoQiLP6aWquruqconMiFxj/cMXf0RU1TldS1efPl3L+wCF6q7OqsqMzHz7+7/l/a6m3ANZ1V5BWYvRtUJ0zQCff/dLL/VzuusVHlSW8EIDcUo9IEwAEEII+UAgKoRcYVWsojqylupFwa6iqtB1ObuqKrJ1lZWrjykZcPTz6yJ/LvMZ8jfw3KYnfTaMi33+YLLhjFV+ZyYv0hRKFEFZzKG5Loz9PRjPnsLcfgxjZxvG82fQx2Oo8xnUIJAeA2l6+sE/u9apYUJUq0haLURbtxDdvoPwrXdkEuDuPdnq32xBmObxQz8P/tRRcqnJ2/ihALoioCspdEXAUgXKeoKGHuEnH/4RPv1s+5V/1+ff/RL+w0//KAZ+iReeMAFACCHkMAgViUCSCMRRjDiOkWTtyScZWOVfF0fbmBUFgpUrchWTKGd9fhFJAiXwoc1m0AcH8vC/vQ1zdwfG7jaMg31ok4k0/oujQ+PB0w7/2fYHUSpB1GzEvT6iW7cRvfUWwvtvIbx3D3FW9U9qNpAlNgh1lFzuw37u9mGqCap6grIWo6IlqOoxvnE5wk9//cuv7T789te+gO/8tv8MCbsACBMAhBBC8iAUOKxUCZEcVq9OaV9VVRW6ocu5VV075n5NyLUmjqEul9DcKYy957Lqv7Mtq/5Pd6E7Y2ieC2W9lr4D56n650aP5Yqs+m9sZlX/txHdf4Dw3n3p7t9oIi2V3khHBqGOktMRqQIBBSIFLFWgoiWoGxHqRgRbj/Hff+230V2vPvb7da+ywqNFDSoNAQkTAIQQQtI0lXOrIkGSxBBCFPusz/5eQNNUBq3k5hz0ggDqfAZ9PIK+twdz+zHMnW2YO9vQBwfQxmNoi7k8+J+36q+qSE0LolqVJn8bGwgfvIXwwdsIH7yF+PZtxN0eRM1Gapps86eOkkuICqBrBWhbIb5/8gif++OvX5r79qU/+Of4i5/623ySCBMAhBBCDhFCIDlnwKooitxfbRhQNQ26bhQrrAi5pm8Q2fI/ncI42If+/BnM7SewHj+E8fQp9OEAmutC8bOqvxDnr/qXSkjqDSTdnjT5e/AWwgdvZav9biFpdSAqFVb9qaPkkqIpKb65PsPPf/lXL+197FgBJoHFLgDCBAAhhNx0FEWRplVCIE3lTmpxDod5RZVBqqqoDFrJ9SVNgSSBulpBc8Ywnj+D+XRXVv4fP4a+/xz6aCSN/sJQVv1PmeE+VvXPjf7abcT9DYT3HyC6ew/hg7cR3b4tW/6bTaRWiQgKDoUAACAASURBVFV/6ii5rBIBBVul9aU+/APAN1SX+L8CCyqfMsIEACGE3PTzjQxShUghsvnVM1dXKQoUKNB1HZqmQVUZvJJriBBQwhDqTLb8G892Ye7uwHz0CMazXRj7e9Lob7E4NPoDzm7513UI04SoNxB3u4hu30F0735W9b+P6NZtJO22NPozTT4P1FFySUlSBR0zxL/86hcv/X39n979Ev7St/8tBEIFX2GECQBCCGH0ihQp0lQgRSr/fsrqKgBZoKpC0zRoWWsyA1dybYhjqOs1tKkDfTDI1vs9gbn9BMazXejDITR3CsX3ocRxUfU/9fB/1Oiv0UC8uYXw7j158L93H9Htu4i2tuR6v3KZLf/UUXKZn24AZS3Bu3/0C1fmPt8q+Xi0rELjGABhAoAQQsjRQPWsytXhB4qKlaqysZBcDwqjP2cM/flzmM+ewnz8CMbTXRjPn0KbTqHNPCh5y/851/ulunFo9Hfrljz8v/UOonv3EN2+I43+7Lo0+uP7iTpKLn0C4Fsa7pW6z72SjyerCp88wgQAIYQwaD1cV5Wm56sM5MGqwrZVcl3Ijf5cF/rgQM77P3kMc3cHxvYT6KMhtOkU6molW/6FON/hX9chLEu2/Pc3EN26hfDtb0B4/wHC+w8Qb24hadPojzpKHb0yUpEqeKe2wOff/bUrdb//8f/xa/i+7/pxeJHBMQDCBAAhhNz44DU3LsuDWLBFkNwgkgTqcglt4sDYew5jd6dY8Wc8fQrdGUOdeVCDoDD6O9PlP6/6l8tIOh15+L97D+FbbyO8/xaiu3cR9zdo9EcdJVeMthXiS3/wz6/mfTdDuEwAECYACCGEQFFk1So7hCjnCA+KihUPLuQqE4bQFnPoo6Fs+d9+DPPxI5jbT6APBvLwv1pBCYNTq/7pkfcSNE1W/e064l4f8cbm4Xq/e/cRbW0h6fZo9EcdpY5etYOFkuKvip0re/97ZoBn6zJiwXETwgQAIYTcaJI4RhLHiKNIulifUbk6FrCmrHKRK0je8j+dQh8cwHy6C2P7CayH7x8a/XnuMaO/M9v9FQWpYUCUKxDNpqz637mD8N4DhG+9LWf9NzaRtNps+aeOUkev2vObKvim+gw//ZUvX9nH8I/f/TV8/3f9ODwmAAgTAIQQcvNI0xRxHGO9XmOxmGM+nyPwfcRxfLqBFRTEWaArhGDlily1F75s+V+toDljGPt7MHe2s8r/Y+j7z+Xhfz47ZvSHsw7/mobUMJHYNSTtLuKtLYT3H8gVf/cfILp1B0mni6RRR2paNPqjjlJHr9jh/055jS9+5Veu/GOp6jG8yOCTSpgAIISQm4IQAnEUIQxDzOczHOzt4WBvDxNnjNlshjAMIJLkxOBViARJkiAMQ6xXK/jrNeIoPrfxFSFv8MUPJQyhzmbQxyMYz3ZhPt2F+egRjN1tGAf70BwH6nIpjf6SJDusnXL4z9f7WRaSRhNJt4fozl3Z8n//AaK79xBtbiFptyEqVcBg4E0dpY5eJVIAVT3B//a1L1yLxxMk7DwiTAAQQsiNII5jRFGIwPexmM8xm83gjEd49nQXjx++h2dPd+C5U0ShbF99YSCUphBCIIpCLBZzTJwxRsMBev0NGJaJUqkEwzCLndaEXKI3ANT1GtrUgT4YwHj2FOb2E5jbTw5b/t3psZb/kw7/RdVfVYv1fkmrhXgrW+/34G0563/njjT6azSk0R+r/tRR6uiVO/yrAH7+4W9cm8dU1hI+sYQJAEIIubbBS9aeGkUhloslVqsl3ImDycTBeDjEYHCAg73n2HnyGMPBAIvFHFEUnlqFEkIgDEJ4rouD/T08efwQ5UoFQeCj1e6gWq2iVK7ANGUAy93W5E2jBAHU+Qy6M5ZGf8+ewnz8CMbTXRjPn0KbTD7U8n+u9X6mCVGtIe73Ed+6Iw//77yD6M49RLduI+71Dqv+bPGmjlJHr552APikPccnJ6Nr85h+/OCP8Q+bf4m2E4QJAEIIuU7BapqmiKMIQRDIudSZB8914ThjjAYDjIYDTJwxhoMDTCcTDAcHWC4XCHz/xKrV8WA4wmI+w/7ec1hWCXEUYzQcYGNjC+1uF81WC7ZdR6VShWVZ0A2De67Jx09u9Oe60AcHMJ4/k1X/nW0Y20+gj4bQplPp8h9Hp7r8F4d/VUVqGEhLZSTNJuKNTWn09+Dt4y3/zRbScplVf+oodfSqvgYA9K0Av/h7v3ytHtdnH/4p/smnP4W9dQkqX0qECQBCCLnaAWuSJIiiEP56jfl8jpnnYuI4cMYjjEdDjIdDOM4YzngEz51i5nlYLpdy/jSOkCTnaw1MkgTr9RrOeAQhBObzGSbOGM9bT9Hrb6DX76PT7aHVbsOuN1Cr1WCVyrAsC5qmMYAlr584Pmb0Z+zuZIf/JzCePYM+HkGdeVCDAIjjsw/+gDT60w2IWg1xt4d4Y0Me+t/KDv9btxH3+hCNBlLTZNWfOkodvcKYqsDv/J//7Fo+tt/62hfwHd/2n0OwC4AwAUAIIVcPIYRsTw1DrJZLGUROHEzGYxmsjoYYj0eYjMeYTh3MPA/z2Qy+v0YURoiiEMkpZlUnBclxFGGdBcur5RLuZIJ6o4FOr4dWq4Nuv49Op4tur49mu41Wqw27Xke1WoOZBbCccSWv4QQnjf4Wc+ijIYznz2HsPIH5+BHM7SfQBwPozlhW/cPgfFX/3OXfNJE0moh7fVn1v/8WwrffkfP+W7eQNFtyvR+N/qij1NErz7fUZ9f68f3bdQ9/7DahK8wCECYACCHkSgSrMmCN4Ps+VsslPNeFO53AGY8wGg4wHAwwnYwxHo3guS5mnov1eoV15jadJHHxcy52zkoRZfuu4yjGer2C603hjEeo2XU0Wy10ul202l30+hvodHvo9npoNJtotdqoVKsolcvQdYMzruSjO/wHPtTZHMZgH8azZzAfP4T18D0Yu7vQhwNongtlvS6M/s48+CuKdPkvl5G02oi7PYT3HyB8+x2Eb72N6O49Gv1RR6mj1+l1kSq4X1nhf/7df3GtH+cvfPlX8Ve/+8cxCUyoTAIQJgAIIeTyBqxJkiDwffj+GvPZDLOZByerTI3HIwwP9uFOpxgODjCbzbCYz7BerxEGAeIkhkgSCCE+snVTSfbz4liuxFrOF/A8L3O2HsK2bXR6PTSbbWxsbqLT66HT7aHd7qLeaKBm2yiXK7KtVdeh65RucsHDfxhCnWeV/2fPYD58D9b778HY3YFxsH/Y8p8Z/eGsw/+Rlv+k1UJ067Zc7/fgbYQP3kJ05y7ifp9Gf9RR6ug1IUkVdMwQv/7VL96Ix/vDy3+Nz5vfiiRVQPUiTAAQQshlCkqSBEkcw/d9LJcLzDwX08kE0+kEo+EAzkhWq9zpNNtD7WExnyEIAoRBWFSpcmOrj/7slRYBbKKqiOMI69UKy+UCk4kFxxmjWq1hMNhHo9HAxuYtNFstdHt9dLpd1BtN1BtNVCoVVKpVmCZnXMnLHf4RRVDWK+gTB/rgAOaTR7Lt/8lj6IMDaLOZbPnP5rPPMvqDpkmX/3oDcbd3aPSXVf2jO3eQtDqy5Z8t2NRR6ui1kJGKnuDdP/qFG/OYP/cnX8dvf+8nsLOq8AVAmAAghJA3Td5WGkXhYRDoOHAnE+lCPRxgPBpi4jiYThy40wnm8zlWyyUCf40o/uirVOcNYJMkgaomMoBdr7FaLmGaFqbTCWzbxv7eHlrtNtqdLrrdHtrdbMa11Uaz2TqccTXNwvmakNMidyWKoC4WUD0Pxt4zafq3u3Puw/+HjP4qFenyv7mF6M5d2fJ//4Gs+m9sImk2Zcs/D1fUUerotUBVgG+0Zzfucf+vf/iL+J7v+Bz8hIlMwgQAIYS8EY5WqXx/jZnnwfNcTJ0xRqMRnPEIB3vPs3VUI9m+6nkIwxCB7yNJ4sKMKn2Di37zmVghBJLMXMtfrzGfeZg4DkbDAeqNJpqtFprNZjbb2ke310er3UG700W9XkfNtmGVSjAMk9Us8sLDP5IEahhAXS1l+//+PvTBAfThAOpiXhz+z5z313WkhoGkZiPu9xFv3kJ09y7Ct78B0e07iO7cQdzrI6nZgGny2lNHqaPXiDuVFX7+ms/9n/jYy2s8WtRAJwDCBAAhhHxsZxhZ8SlaPhcLzDwPrjfFeDjEeDTCxBlhOBhIgypnjOV8jvl8jigKEQQB0qzSddGANQ8IP+pgN78/x9Zr+T5WK2m4NR4NUa3WilVX/Y0NtNsd9DY20O500W530e50UKlWUa3WYBgGdMOAoigMYol87SYJlDCEtlhAXa2gei708RjqYgElik40+yte6aqK1DCQlspIGg1Z9c/n/e8/QHT3PuLNTSStNkS5zJZ/6ih19JpR02P8+h/+4o19/L/y+7+Ef/87P4dVTG0jTAAQQshrD1ijKEIURVgtFlgs5phOJvCygHU0HMjVU84YE8eB57pYzGdYLZcIw7DYOf0qwaqqqkUQmAe+F3W0Pk8ACxxWswLfx3q1wsxz4blTlMtljAYHaGSVrHank+3D3kCr3UGz1Ua9XkfVtmFZFgzDhKqqbG292W8iQCRAHAPZGIA2n0OJI/lxguFfUfVXVaSGCVGrIe50EW9syEN/fvi/dQdJt5e5/Fts+aeOUkevGZqS4tvK4xv/Pvqb6z/F/2j8OzQDJEwAEELI6yBJEsRRBD/wsVwssJjP5FyqO8VoIGdSR8MBptMJpo4jzagWcwS+X5hRJdk888sGrHmQKvdH6zBMo6gAxVkQfVognAe6ebB4tFp23vuS3zZ3444iFUEQYLEw4HkeKqMKhoMD1BtNdDpdtDqdwuiq25N7seuNJmo1W5pdWVbxmFjNusHkB3pNO3boVz548JcvZGn0VypB2HXEvb40+rsnV/xF9+4j2rqFpNmSRn+GwetLHaWOXrfXUKrgL9Rn+Edf+c0b/3763J98Hb/1vZ/Ak2UVOtcCEiYACCHk1UnTFHEcH3N2nnkenPEY04mD4eAAE8fBYH8vW/80wnK5xGI+RxgGcld0ZkZ10YBVVVW5IkrTYFoluUO6VIKqqAjDAPP5HHGSQFGUF/78POg1TUsGvFCQIkUURhdejXXU8OrYjGsWzB+dce10umh3u+j1+mh3uuh0e2i22mg0pfO1VSpB1w3ous5EwA08+EPVkBo6UtOEqFaRWhbSIACOVmLzJEFu9NdqSZf/+w8Q3n9QuPzH/Y2s6l+SP5tQR6mj14o4VfCgssIXvvIrfGNl/Pof/iI+nRkC8n9QwgQAIYS8QsAaRRHCIJDB6szDzPMKM6rxaIjpxMFoMIDnTjGZOFgtl1itlggD2Z76qjOpeZXKtEyYpgW7Xke93kCz1UKpXEYURphOHSRCIAh8RGF4srDqBirVqjSVskpI0xSBv8ZqtUQQBAiCoAhgX7YFNv+eOI6LmdzlYo6Z52E8GmJY3z9WzdrY3JLzrZ0OWq02Gs0WKtUqKpUqrFIpe9ycabz+h38Nqa4jtSwkrQ7ijU3ogwMkjSYgUqir1WESQFMhrBKEbWfz/rcQ3r0nW/7v3Ud0+w7ifh+iUpVVfyaSqKPU0WunoymAphHhX371i3xzfYBP1Bb4Y7cFQxG8GIQJAEIIeRmOGjUt53N4nofpxMmqVPnqqTGc8Qie62LmuVitlvB9H2EYQmTVnIsEq3lbqabr0FQNpXIZlmXJPdH1Onr9DTTbbbTaHeiaBtd1AQDudFpUuPLW2A8GwaqqwiqViiqSYZgIfB/udILZbIb5zJOPIQiOzdbmQfx5g/2j+7CjKMJqucRyPoczltesWrMx2N9HvdFAf2MTrXYb3ayilT/Oaq2GUrlM5+vrfjhUVaSmiaReh2pLB//wwdtQhIAolTJPgFgejkwTwq7Lyv/mFqKtWwjvPUB8+zaiW7el0V+lQqM/6ih19BrrqK6k+AHs8A32Ar5xOcL/pzR4IQgTAIQQch7yWcwwDLFeLbFYLOBOHDhZgCoNqYZwnBHc6RSe62K5mGO1Wn2oPfWiAauqqtA0Hbqho1wuo1yuyECu0UCv30ez1cHG5ia6vT7qjSaiKMSz3R240wlM0zqxbTXHMA3Uaja6/T7uP3gbjWYLSRJjPBphOnFkIO658FwXgb/Ger1GEidIkrioTF0ogM3dvf011usVLGuKqTNGpVrFwf4eGo0mun25+qrb7aHT66HRbKHZbKFm29yHfV1RFEDTZNt/uYK434ciBCBSpJYFY38P6nIJZb0GDB2iXEbSbCNptxFtbckkwOYtJL3eYcs/E0XUUerotdbRt6pL/PTv/y7fbC/gp7/+ZfzGt7+DUCgcAyBMABBCyEnBlRACcRTJVsvlAvOZB3c6xXg0lEZUoyGm2Rym53nwphOsVius1yvEUVy0p17UNVoGq7I91bIsWKUS7Hoddr2OTqeHdreLTqeL3sZmUXFqNlswLasINhUFxf04+ax1GA7Ydh2bt27jzt170HQNnutiMh7Lx+i6GA4OpCu152G1XGC1WiGKQkRRhCSOXzqAza+zks24Br40/jItE9PJBDXbxv7+HlqtNpqtFtqdDvobm8V8a6vd+dA+bF3nfxPXJQmQ6gbSSgUiiRHnLumNBpJer1gHKExTOv43m4jbbSTtDpJOF3G7LVv+TZPXkjpKHb3mOtoxQ/zK7/8S33SnUNZihILGp4QJAEII+VAwlSSJnNf011gsFph5LiaODATHoyHGwyEc5zCYW8xnWK/XCPw14iwAu0iVKjeRyltJDcOAVSqjXC6j0Wqh0WhKc6dOF51eD73+BjrdHjrdLux6A3YWvIlEIPDX0DQdiqJC18/+D19VNZQzo6h6vY6tW7dRbzSwytZQTR1ZqRuPhnDGY0ycMWaeC3c6xWzmydVbQQDf94tq1ss6Xx+tZkVRiPV6jeVyAXc6lW2t1SoazRYazR352DvS9brb76Pd7qDZ7qBSqaJaqxYBLMcDrnYCALoOeeSqI9V0CNOCVq8jbrehhBGUJAYUFaJchqjVIGo2knodolZDalps+aeOUkdvgI4qAH72z/93vvHOoKIlcEMTCrcBECYACCEEhdNyWFSpZsWaqfFoiPF4hNFwAHcywXg8wmI+w3w2g++vj62euogZ1dFgVdcNaLqGSqWKSqWCRquNZrNZzKX2+5vo9Hrodntotlqw6w3UanLvs24YSNMU/nqNJBHFfQrD4IU704/+/lQIRFFYOGGXy2XUGw3UGw2023LN1GZWucsDSccZY+qMMZk4xR7u5WKO5WIh93BfwPn6g/uwRfac5Puwp5MJypUKhoMBGo0Gev0NtLMAtrchg9lGs/mh65JfY3J1kwCKqgCGjrRSgZJtAVCSBKmWmQWWSkhLZQjLAnSdLf/UUeroDdHRFMCPvfNZ9P+Cj9+gAeCJlPUE7P8nTAAQQm40ebUkjiP46zWWyyXc6SRrTx3BGY8wHBzAnToYj0Zw3SnmnoflcindoLOZ1IuaUeXBqqppMHQdhmmhUqmgWq2h2ZauzRubmzJw7PeliVNWoalWay+s0KRpCigKVFWBqqhQVQW6dvphKE1TaLqOklXKKl06VE0rVkZZVgnlSkVWztpdLFdLzDwXM88rjLomEwfDgwO40wkcZ4zlfI7ZbIYoCi9s2nV0BVYcxwjDAOv1GovM+bpcqRRrsDrdnqxkZdfpaEWvlpld5TO83CBwNZMAqaoiMUwoSQIkCZQ0BdIUqaoCmopU02XFn14Q1FHq6I3T0UgoeLYu4y9+6m+jZwX4+09/D59+ts036BEqasKLQJgAIITcTI5WqdbrNZaLOTx3Ks2ostVTw8EA06kDZzQ65t4c+P6FdzrnwerRgDWfSS2Xyqg3mmhl7tMy8Oqhv7GBVruDdqeLRqOBaq126oxmmqZIhUCS5Oui5Mqo0ypXuat1FEVQVRWpOJwpze+zruvQdR2mZcFu1NFqt7FerbCY35IB7GQsDbzGIwz29+C6LsajIRbzGWaehzAMEfg+EpF8ZPuw5e+fwRnLllpZZZMrsLrdngz0s/neZruNer2BcrkC0zJlhZAbBK5WEiA73Ke6DgiB9PAFfHgbQh2ljt5YHVUAaEqKcWDiv+j/ANp3QtwrL/HPvvKrfMNCdgCYikCcUisJEwCEkBtAMRuZJFj7aywX0ozKc12Ms5lUZ5RVqtwpnNEIi8Uci8Ucge8f29980fbU3IVa1w2YpolqrYZypYJWq416oykrLllbaq/fR7PdkW2Ydh21mn0ul+Y8MM4rWIqiQM/2np90n9M0hWHosEql7PYySD36e/IAzzAMGIYB07RQqVTRaDbR7nTQ2+ijv7Epq36370hzr+EA08kEE2cMz51iPp9jvVrB99eIo/iY8/XLkH9PXnUMfNlu7LlTjIdD1BtNNJpNdHs9NJrtzOyqi063h3qjgWarXbQGG6Z5LfdhX+tEAMDZfuoodZQ6enIyRgFUCHihjn8VNvHpb/9b2Cj56FkBPv/ul27s+/cffvW38R99yw8jTqifhAkAQsg1D1jjWDpJr5Zy9dTUGcPzvMyIaVQYMuV7qOfzuTRjOrJ66mgl50IBq6bBNE2YpgXbtlGpVotVUxubm3I9U9Zy2Wg20Wi2UK1WUalWYZrWuasshyZQCeIoQhgGCIMAqUhPXGGlKAriOK9cKcXPSM+oduUGW6ZpoVaz0Wi0sOwvsLG5Wcy3jscjTLLd1NPJBJPJGIvZHPP5DP56LWdcj+zDfpkDwQcD2DAMsVwsMZvNssB5CNu2Mej3YdflPux2u4NOT7a51hsN1Ow6qtUqSuUyuwIIoY5SR6+RjspEQApfqHiyrOL5uoyf+c7vw09//cs38n3cXa+gqylSWgEQJgAIIdeRvMUxDEOsVssPmVGNhgOMhgNMHAfTaW68tPjIzag0TYdVsmBaFuqZoVK310ez1ZKBVKeL/sYmWp0Oms0manYdlWoVJasELWsXfdnfnQewKVJomgY1q8qc9jh0Q67IUlW5LkvTtHPvg84rP7phoFypwLbr6HR72Njcwnw+w2Q8xng8Kg4J08kEzniEWWaGFfg+1uvVsX3YF3a+jmWrrr9eY7VaYjqx4IxHqNl1HOw9R6PZQq+/gVa7jU5XVgnzg0KtJg8UhmnCyAyvCKGOUkepo1dbR/PRgCRV8K9KGzf6PW2qCY9ShAkAQsj14WiVKvB9LJcyYHWnk8KIyhmPMMhMlibOGMvFAovFQlZ4whBJHBdB04XbUzUNuibnPCuVCmp2Hc1WSzpOt9vo9TfQ628UDtTSjEpWqXLDKPWCRmaywpbPd0YIA7lb+qyqWypSiCQpfu9F5nLzapamaSiVy6jZNlqBnMPdnN06dL3O9mG7WavpzHPhulOslkusj+7DfsmDw9F92HLONZYB7HIJ13VlAFuzcbD3HK12B61Op3Dm7vb7aDZbaLXbsOtyRrhklaAbBscDCHWUOkodvSY6OovNG/3+ruoxnMACFwESJgAIIVc+YI2iCGEQFFWqmefJWcbREKPRENOJg+HgANPJBNPJBKvlAovFHHEUFYHdRYK1owGrputy57RVgm3bqNo2Wq02Ot1u0Zba7fWzylU7a520US6VoWbVn4+kWqIohVeVqqrQVPXEn6soCpA5Ohumecyo6qL35WgAa5oWymXpfC3NuDbhuVNMJg7c6VRWD7PKludOMZ1OsJjNsFqtEAR+cZjIA++XCWLjOIaiKNkKL1nNWizmcN0JRsMBavU6ms22PFT0+uj2esXz1O7IueFqVc4X5wcKdgUQ6ih1lDp6dXV0Ht3sY4Sh8OhPmAAghFxhpONyiCAIsJjLlUbudILpxJGGVEMZsE4cB5OJA8+dHjOjetUq1dGd05aVtac2GrDrdXQ6PbQ6HVmh6vULN2W7Xkej0USpXEapXC4CvI8SkSSIE2kOFcVZYJ6KEwM8ABCprPZoug5FkZWsV4+f5TWSM7vmYTUruy6LxVweJKYTONm6sHzWNQ9iV8sl1uuVbCe+gPP10ef30OzKx2q1gue5mDoOKtUqhgf7xRxxs91BLztgtDqHBmLVau3S78MmhDpKHaWOnsxNd8B3I5PVf8IEACHkapG3JcpKxAqLxUIGq9lMau5EPRmP4WUtkYvZrNg5ne9SfpUqVT4Pqus6SqUySqWSDG7qjWIuUjomZyuUOp1je5QNw3yp2dCL3EdVVZGmqdxhrWlQcErlCoCuyaobADm7qn/0Jk5yxrUMyyqhUqmi2Wqj3e5iPp9htuXCc12MRsNsJ/YY46y9dTpxjrUYX2RveH67YsY1a9P1fR/z+Qye66JcqWA4OCicr1ttWXHs9ftypVini1q9jlqtBqtUhmVdzn3YhFBHqaPU0RNe+wD+7mf+Ov7R7/3mjXzv+4lKASRMABBCLj/5PGIcRQjy9tT5rJiFHA4O4IxGmDhjjEZyFtJzXaxXq1eahTzKYTumDtMyUSqVUalW0Wi2irnUD1aqWm25lqpSqR5bPfW6Kx5CiMJxO4pkoJ4iPTWgk627KdTM4foiTt0vE1gbhlHsw67VbbkPe73G1u3bhyvFsn3Yw8EBvGz2dLGYYz6bIQwC+L4v53RfYcZVSXKX7xDrrO154shd3I1GA822DK7b3S56vT6a7TY6nW4x41quVGQ1ixsECHWUOkodvfQ6mqQKDlC5kRrwU//BfwJ/yoQ1YQKAEHLJA1ZZpQoQ+D4WC9memrsfj4b5jmRZtfLcKTzPg79ew/fXF3ZDzoOr/LOmaXLntGWhVCoV+5E73S5a7U5hRNXp9eSO5LpsXy1nAWse0Hxch0NVVYt96VpmhHVa5UpVZPusYcjZTE3XX3s15mjrb74Cq1qz0Wg00Wp30etvwN2aYDJxMMnMrsbjEdzpFBNnDHc6wWKxwGq5ROCvEWe7yV+mmnUsiM1mZMMwRJBVs9ypnHGtN5qoNxrodLtoNNvo9ftod+Q+7GaziUarjWq1din3YRNCg12xygAAIABJREFUHaWOXlUdfS2JnVTBMrmZR4l5rCMUKlT6ABAmAAghl428vTAMAiyXC+lAnbUwjoZDTMYjjEcjTCZjOKMRPM/FYj4/NuN4dC71ogFV3sJZqVRQygyY8rbGdqeHXl/ON3Z6PbRaHdi2jVq9jlKpBMMwP5Yq1QsDHCGQZsF6nFfsTpn6S5FVBuNYGl9lRl4fJ/mh2TAMWKUS7Lotnb43NuXqsWy3eL5rfDwaYjJxMHUczOczzGcewjB8pdVjR/dhR5GKMAyxmM/heR4sy8JwMIBt22h3u2g0muhtbKLVaqPbl5XKy7wPm1BHqaPU0aumo68LP7mZCdpZxCMUYQKAEHKJOGou5Ps+1qsV3OkU06msXIxHQwwHA0ycMSbOGNPJBIv5DMvVEv56jSiMiirVRYOu3EhK1w2YpolypZK1pzbRaLSwsbmFVrtdOFC3Otk8o22jWq3JdsxLYBB3NGA+7yosLZvFzYP31zVXe56Dg55VzgzDRKVSRb3eQKfbw3zmYbGYS5OroZxTHg0H8DIX7Plcupb7vo8g8BHH8bE55Yvsw44VBXEcYb1aFfuwx6MhqrUa2vt7qDeaxXxy3rJ8mfdhE+oodZQ6elV09Ltf0/UJxc2cg59FBhRW/wkTAISQyxKwRlGI9WqF5XIhHY0dB6PR4ezi1JGO1DPPw3zmYb1eI/D9okp1ETOqPLjL51IN04RllVCuVNBoNNBotqRpUbdbrF6SLYtd1BtN2LYNK6tSHQ363jRF8J6miKL4zHbO/DlIkuT4979B8pbhPKAuVyqw6zZ835f7sLduYzp1Ctfr4WBQ7CnP55rzYDOO5E7zV5pxVeTP8NdrLOYLWK6L6WSCaq2Gwf4eGs0WOr3eifuwazUbpVKpmF8mhDpKHaWOnq6jr+WaQHYA/Hm7h09ORjdGI/683cMy1sE0NGECgBDyxoPWKJLBwHzmYZrNCg4O9jEaDjHY34M7lTuo5/MZ5nNpWhT4AYRILrxzOq/MyOBIh2EaKJcrqFQqaLbluqJut4d2p4tuv49efwPtdgfNVqs4zFmWBcM0L+VhLr9PQgioqnJmC20+u6ppGpCmb7RyddLjkWvCdJimJZ2vm9IwbGNjC9PMvXw6dTAaSMfr0XBQtLwWM66v4F5+tJpVHLT8bB/2dIpKZYCDg71j+7CL1uaunGlutlqw7TqsUuncFUVCqKPU0Zuqo6+LKFXwP3zqM/j8u1+6MTrxM//u9yFyVeiKoGgSJgAIIW8waA1DLJcLeK6L4eAA+3vPsff8GfaeP8PwYB/j8QiL2QyLxaJoRcxnUi9SWckDMjWbkTRNC5VqFZVyBa1OB/VGE1u3bqHZbKG/uYV2p4N2u3Osndu0LOi6fqnbuZMkQSISpPmfT6nYpGmKFEcqV9njuojD98cVxJpZS71VKqFWt9HudLDY3MTcm2F6ZwLPnUpHc2eMyXgMxxnDc1147hTLxQK+v0YYhK/kfJ0fDOJI7sNer5Yf2ofdaLaweesWOt0etm7dRn9zE/3+JhrNFqq1KiyrRLNAQh2ljlJHT9DR10UsVKxvmA+AE1pQwfZ/wgQAIeRNBq1RhNV6Bc91MTjYx+72E+zuPMHT3R3sP3+O6XSCxXyOwPcv1HZ4NFg9akZlWiasUgnVShU1u45Wu41mq328Ytvrodlso9FsFoZumqZfqvbU817nc10fZG2iudP1GzLdetnnNZ9xtawSqtUaWq0OOr0eFvM5NrZuYea5GA0HcrXZxMmczieYTiZYrZZYLhbFarOLVrPyjyRJoIZhsQ975rmoVKpwnDG6vX4ROK9XK2zdugMhukhtoFRiEoBQR6mj1NEX6ehre04BLG9YAmAUmJz/J0wAEELeHEIIWbVaLOA4Yzx/9hRPHj/Ck8cP8Xx3F647wWq5fKWd00erVLqmF2ZUtZqNZquFVqeDVquDbr+PTqeLbrabOG/TrtXsYzunr9KhIBUpkjhBmrVZpqmcYz05GMqub5oWba5XJTjP76uRPVfS+VoeSFbLJTY2b8Fzp9lO6sGxOdeJ42CxmGMxnyMMA0RhhDiOLmR29aJ92KvVCsvlEjPPlUZri7mcJY6T4vlQFLATgFBHqaPU0Rfo6OtCVVI4gXWj9GIZ6zBVtv8TJgAIIW8osEriGL6/xmI+gzMaYf/5Mzzd2cbz3V2Mx6PMcCh6pfZUTZeVJssqoVaroVavo9VqF/um250uutm+6UPX9hrKlUphRnVVXdvzVVXF9VOUoiX1hdcMigzw9SPO21coeD0awOb7sC2rhJpdR6PZQrfXw8bmFrZu3cHEGWGUGV7lu8+njgPP87BczLFerxEGfrEP+2WNvI7uwxZJgiiK5P71IEAQ+EiSBJqmolQuw7QseTjS9De26oxQR6mj1NHLqqOv7XEC8CIDn/2ev4Hf+OoXr71e/MhnfhjajNV/wgQAIeQNBq5xEiMIAsznc0wmYwwGBxgc7GM6nWC9Wr100Ho0aNF1A4aZVTDsOmy7XhiwbWzdQjczZJM7iBuw6w2UKxWUS+WiSnWVD2JFK2U+45skSEWK9JTrmV8/RVHkCi5dh6qoSDMjq6vI0X3YpXIZdr2OZquF3kYfG9MpPNeVa7CyINYZj7Id2RMsFnMsF/NX3oedm12tswoi0hSaqqFULsuZ6ezDtErQsjZcQqij1FHq6Mfw2JQUT1cVfO77/1P8/O/+i2utF/t+GSrb/wkTAISQN4UQAkmcIAzluqrFfA53KoMF318XrYPnDVgLMypdh1Uqo1TKKhaNBnr9DTTbbfQ3Nov1U612G/VGE5VKdvgyTWiadi0d2ZMkPnatTruOWlbxUTKnaOWKVa5Oe2yGYRT7sGs1G/VGE/56jY3NTcxnc4xHw8zoaoTRcAjXzdpaj+zDlq/NQ/O08wax+VxrGASYzTyYloXmYICtW7exWsrd69VaDUKYTAAQ6ih1lDr6MaIqKf7Ea157vVhw/R9hAoAQ8qY4+h++SBLEsXT+jaIIcRxDJOdrE8zXGamaBsuyYFkWqtVaYUbV6fbQ7sgW1U63h26vj0azhWarhUq1Kvex6zKYuW5t1/kMpUjFh675SYGdokAaVqkqDMOEpl2/FXX5awa6Dk3XUS5XULPrCPw1uv2+XJ82kfuv5ZzrsDC/WizmmE4mF96HXexoD+XrfblcFIe1MAxlMJzNy3IMgFBHqaPU0Y/zuQa+/7t+HL/7R79wLfXi737mryOeqdC4/o8wAUAIedMoigJVkcGnpmpyVlSV1ZIXBQLHZxNNmJaFUqkEu95AvV5Hu9tFuy33TXd7MlhttTtoNJqoNxqoVOTqqbxKdd0PWnLPskByDkdm5ch+aEUBDEM/ddb1qnOsrbWUO1+30etvYObdgue5mIzHmE4dOKMRptMJhoMDzGczTJwxFosF1qsVfH99bufrNE0hUiEPaIKBGKGOUkepoy+ro6+LWWTgh//yj+CXf/+Xrt3z9DipQ+XhnzABQAh5k8HqUXMp07JQq9mo2Taq1RrK5QqSWFa0jlZDZdVBg6ZrKJXKKJXL0nCq0ZQBaquN/uYWOl3pQt1ud1Cr12HbNqxSCaZpXcsq1WmHTWTXT1FOX2OVHxRURQbzuqZn1/5mvB7zg4xhmiiVy6jZNjrdLvobG5jP5nCnDlzXxfBg/9g+bHc6xcxzz70PW1VVGLqOUqmUtUvnxn/UBUIdpY5SR1+ko/iYkgECwM6qgt/4xDfjs+//6bV6fkaBxfZ/wgQAIeTNIoNW2XJas220Ox1sbG7B81yEYQhN0+D7a2maBlll0HUDlmWhVC6j3mii0Wyiv7GJZrOFXn9DVqsygyq7LqtUlmVdCzOqiwauQkgDKyHSMyvTqqoCeRCXzXhex1ne8xyodF1HqVQ+3Ifd7WK5WGBjc6toZR0Ph5hMHIxHw2P7sOXKtRBxFEOIpLjuiqpC13RUqlXUbButtvy59XodliXbqBVuASDUUeoodfSYjiLwP577DiAQKn6u+23XLgEQChWEMAFACHnjQYKmysDVrjfQ7nRx5+49xHEEXTcwdWwslwvEsTReMgwDVqmMWq0G266j1emg2+2ht7GJdqcj1081mrDrdZRKZbnHOFs9dRMPVHnVJBEJUsgZ4eLrpwRtmqYW8515i/pNvH4n7cNutlpyH/bGFlxviqnjfGgf9tEANo4jRFFcVMfKlQoajSY2b93G1q3baLU7qFZrKJXL0HT9Rh0UCHWUOkodPY+OYn/v47vPAMaBhR/5zA/jl37vl6/F8/AT3/eDSGfUS8IEACHkMgSuWdtqtVpDt9dDihSKqqJm1zEaDrBaLhEGATRdh2EYqNk2ajUbzVYLnW4PrU4HrVYH9XodtXodlmVlpkt0UQcAkYrCeE62o4tzBWuyCq3Kip+i3vjX6Yn7sNd9LDbnH9qH7YxGmHkuZjMP/nqNMAyRpil0Q0e1WkO708Xtu/dw9959bN2+g2a7g1KpBIMJAEIdpY5SRz+kox9nAgCQqwH/9ayBP2/38MnJ6Mpf/3FoQaTsLCNMABBCLgG5AVWlIoMqVdVgmhaarRb6G5vw1+uikmWYBiqVamZS1YBdrx8zozIMg63TLyB3lU+RQjnHBKCiqtBUDaqqXIodzZeN8+3DHsNzJ5jNZlguFgjDAGmaQtO0LAHQQbfXR7fXR6fTlS3WpRK0rNJKCHWUOkodPdRR/MHvffz3URH4iXc+i69N/pcrf72XMZN5hAkAQsglQVEU6Lqe/wWapkknattGf2MTcRQjEQlUVZWmaZaFSrmCcqWCUrkMXTdudHvq6RFriiQR2YowUbjPn/p8QCmMropd3ryuJ752T9yHveVhtVjA82QHgO+vIYSAoqgol8uo1mpoNJuoN5qo1WooVyqFsRoh1FHqKHX0uI6+kfsGwBcq/tqnfxS/9bUvXNlrPC5XOP9PmAAghFzO4FU6JmuwrBKqtRqiKEaatV6qqgZdlwGCYRjQs4CBnE2SCKRIkQpxanCf/5sC2boKRYHKoPVMTtqHHQY+VqsVwiBAGAYQQlYBDcMoVq5ZpRLbrQl1lDpKHT1DR9/Y+wrAwC/hb/yVH8IXv/IrV/La/r3v/msIZkwAECYACCGXMHjNKyWariNNS0XLJXC4V/kmrZ56VUQqkMQxgEP36tP2zhfXOpvT5Cz6y/OifdhxEiOJk2KOWFXka1zXtML0j9eaUEepo+RkHX2TpAC2l1WMyxV016srdz3nsYFYqFAVjqIQJgAIIZcweD3agno0kDr6mZwjYDly7UQ+u3rk45QnQQaumWGVyoPCKx/EDJjFc5CTr1LjtSXUUeooOVtH3zTLWMdP/Hv/MX7zq1dvFGARGwBffuQawbQqIdc4gM2rJzwoXQwhBJIkRpIkR9yr0zOve46makiF4IX8CF7Lcve6XnzcxF3qhDpKHSUXfS2/8QOHkuLZqoy/+Vd+6Mpdv1msQQGr/+T6wA4AQgg5gTxGTRLZvipEcq5AS9W0rIIlK1eEEEIdpY7edBQlxZ/NbXzvd3xO/h2ApsoXiAZR+DxqSlpUKDUlLYrvmpoWB3FdSYufqSH/s/x6mn2fpgBACk1JYcchlrqJH9j5N+iuFwCATz/bPvM+/8x3fj+WkV78PkKYACCEkGseucZxAiFSRFEs51bPWEeVpsdNrs5sdSWEEOoodfQmJAAAJKmCVXIkoXNWPihVACXNPp94o+JP6pFkQ35zVQEUyMTAnzS/C2jJf1NuyR+ZZrc5mqgA5K+NUwUaD/+ECQBCCLlBsasQEEkCnDMAVZTMuVr+hW3DhBDqKHWUfCARcP4bp8c/n/Vayz+nh78lSV/6t178/hJyBaAHACGEvCiIyAJVkQoIIRAnMUQiq1gnBbCKohT/lpsusWpFCKGOUkcJIYQJAEIIucTkrtVJHGezq4dfPy3YVVVVrqfT1MJ9mZUrQgh1lDpKCCFMABBCyCUlTVOkyKpXIkUcxUiEOHV/9dE2VUVRobBxkBBCHaWOEkIIEwCEEHK5yQNQIVIIIaCqKrRz7FJWVRWGaULTNGi6Dk29HDuYCSGEOkoIIYRqSgghLyB3oRapAJAiiiPEcXx6oKtIn2EhBFRN4/wqIYQ6Sh0lhBAmAAgh5KqQz7BqqgZFVbNFQiff1tANGIYBVVFktUvXOLtKCKGOUkcJIYQJAEIIucyIfHUVgCgKiz+/qBKVfy3JHK7zOVZWrQgh1FHqKCGEMAFACCGXHEVRoGoahBDQdaNoRX1RJSr/mq7r0LNqlabrnFslhFBHqaOEEMIEACGEXHaEEIijCAAQhgGSc1Su4jhGkiRQVDXbdy14IQkh1FHqKCGEMAFACCGXWiBVFZquIxUCumFA0zQAZ1euNE1DKgQrV4QQ6ih1lBBCmAAghJCrgBACSeZYHYXSvTpN0zMrV3GcAIqCJI5ZuSKEUEepo4QQwgQAIYRceoFUVaiahjRNoesaNE0rTKk+yNHKlWEaAMDKFSGEOkodJYQQJgAIIeQqkCQJ4ihCmqZZRer0ypUCRc6uxjEUVq4IIYQ6SgghTAAQQsjlR8n3T2fzqpqmQdf1MytXpmXBMEyoqlp85v5qQgh1lDpKCCFMABBCyCVFCIEkEYjjCCJNEQTBmZWrFCmSOEaSxFBVFSIVxb8RQgh1lDpKCCFMABBCyCVEVq4UQFGke3VWtcr/7YW3V1QYhgHTKkHTNBiGATWbdyWEEOoodZQQQpgAIISQS4isXCWIIzl/Gvi+3F99QuUqJ04SiGzPNbLbsXJFCKGOUkcJIYQJAEIIuaTk1aY0TZGIBJquQ1GVU4NQVVVgGAZKpRJ03YBuGFAVzq4SQqij1FFCCGECgBBCLi1CCAiRza4mCYIgQBInpwa6aQqkQiDOZldzWLkihFBHqaOEEMIEACGEXFJkIJpmQWwK/RwzqIqqwDBN6VqtadA0nbOrhBDqKHWUEEKYACCEkMtMXrmKokjOrgaBnF09hVSkSJIkW3EFKArOnHUlhBDqKHWUEEKYACCEkDcpjqoKpClURUWSxDBMA6qqnj67qqkwTStzrpbVK1Xj7CohhDpKHSWEECYACCHk0iKSBCKVs6tptr86SeIzvy9JYgaqhBBCHSWEECYACCHkqqBk5lP5Z0M3oOD0gFRVVei6fvih6dBUzq4SQqij1FFCCGECgBBCLi35Duo4ipAKgSgKkeLkttU8OBXi+G1EKngxCSHUUeooIYQwAUAIIZdWHDUNQqTQNA1pCqiqBuDkVVRpmkJRFOiGDk3ToSgKNF0vvo8QQqij1FFCCGECgBBCLiEiSZCmKaIoQiISucdaiBPbUBVFgRACSZwUFS4hBFLByhUhhDpKHSWEECYACCHk0qJk7tWA3GOtZjOsp1WuVFWFbuhQFRWqmn1orFwRQqij1FFCCGECgBBCLi1CJBAic68WAlEUn7q6SlFkgJvPvOa3FWfsvCaEEOoodZQQQpgAIISQNx68yrbT5Ejweer+akWFrhtQVAWapkFRDt2vCSGEOkodJYQQJgAIIeSSkaapnDtFiiSJkaYCQiSFQdWJ34f0mFu1AiVrfyWEEOoodZQQQpgAIISQS0vedlqspErT0ytXqiZ3VmtaMbPKyhUhhDpKHSWEkMuCzktACCEfJhUp0hRIEoE0D1gVpZhR/SBHK1qqqkkDK007NdAlhBDqKHX0MhCGEdbroDBqJBfD90NEUcwLQZgAIISQq4hIEiAzpBJCnFm5kjurNWiaBk3XoGSBLiGEUEepo5eZH/zB78P3fM+3gpf61YhjgU9+8i7w3/JaECYACCHkagWtQkCkAnEcfyg4PalypaoqVEWFpqnQVAauhBDqKHX0avA93/utvAiE3BDY50MIIR8gD0zTNEWKFHESIxUCaYqT21YVBYqqQFFVaJoOTdfZSkkIoY5SRwkh5FLBDgBCCHlBICpSAZEkSOIYIhEQp7St5l9XoBTGVaqqQgErV4QQ6ih1lLwK//Xf+Tn8zu/83zBNHWmawjB0/L9//E94YQi5IEyrEkLICYFoksjW1SiOkMTxiYFr3qKqaRpUVYOmqlkVi0ErIYQ6Sh0lr3b4/zpqtRJMU4dlGVAU4Du/4yd5cQhhAoAQQj46RJIgDAOslkv46zXiOIZIxanmVXK/NaBqGmdXCSHUUeooeUXefff/Qa1WPvY1RVEQBBH+q//yZ3mBCGECgBBCXp00TeH7PjzXhedOsV6tEAYBUiHO/F5N0wojKwathBDqKHWUXIxFfwu6rr34AKMqGI89XiRCmAAghJBXJwh8TCcTjIYDTKcTzGYeojiSK6xOCXbTNIUQQlasVJXmVYQQ6ih1lFyQ2nD/FM8IwLJMXiRCmAAghJBXIwwCTB0H+3vPsL/3DKPBAIv5HFEUnW5elabS8EpI06vc0ZoQQqij1FFywSRArQwhXrw14pu+6T4vECFMABBCyMWJogizmYfBwQGe7e7g2dNdOOMR1usV4lMC1zx4FYlAFEWI4hhJHLN1lRBCHaWOklfgq1/7Odh2GWEYIY6T4uNTn/oE/pu/90O8QIRcAK4BJIQQAHEcY7mYY3hwgJ3tx9h58hj7z5/DdV05t3pK0JoHrkkcIwwCrFerbN41BGxeW0IIdZQ6Si7K7//Bz+K/+wf/FM+eDWFZJr75m9/CT/7UZ3lhCGECgBBCLoYQAuvVCqPRELu729jdfoLtJ48Pq1ZxfObPSNMUiUjg+z4Wizk8z8VyuUCj0YBpWbzIhBDqKHX0jfFvdgb4pvsbV/b+//1/8GMAAP9Hfwyln/o7V/65IORNwhEAQsiNRjpVr+E4Yzzd2caTRw/x8P33MBoOMJt5iKPo3D8njmIslwu4kwnGoxGc8QiLxRxJkvBCE0Koo9RRHjxfkdIX/imfA0JeEXYAEEJuNLlZ1bPdHexuP8GTRw+x9/wpxqPRuVpWjwauSRIj8NeYTMYYDg4wONhHo9GEaVqo1mqcZSWEUEepozyAEkKYACCEkDcVtE4mDvaeP8Pu9hM8ev897Dx5DGckW1aTJDl34AoASZJgtVph4jh4/nQXnW4Xtl1HuVKBaZpsYSWEUEepo4QQwgQAIYR83ORO1cPBAXa2n+DRw/ewu7MNZzzCfDZDHJ2+r/pFCCEQhSFmnoeD/T00Wy3U7Dps24ZlWWi22tB1yi4hhDpKHSWEECYACCHkY6Fwqh4MsPPkMbYfP5Ru1XvP4bpThGHw0kFrTpIkWK9WmDhjPN3dKQLXSrWKUqnMFlZCCHWUOkoIIUwAEELIx8FRp+qnO9vY2X6Ch++/h4P9PXjuFFEYXjhoBTITq1hWxUbDAWy7jnqjAbveQKVShWEYsEolPhGEEOoodZQQQpgAIISQ10WaplivjzhVP36Ih+/9GYYH+3DGY/i+jziOX2pe9UW/I0kShGEIdzrFwf4e7HodzWYLNdtGqVyGputsYSWEUEepo4QQwgQAIYS8LoLAx8QZYXf7CXaePMaj99/D82dPMTg4wGq1RHJG0KqqKlRVbk8VQiBN0xfePk1TJHGM1XIJZzyCXa+j0Wyh3migVquhVCqjUq0WP4sQQqij1FFCCGECgBBCPqqg1fcxcRzsPTvuVD0eDrFcLpDE8Yktq4qiQFVV6LoB0zIBAHEUI4rCEx2uhRBIkhjz+QyDg31Uq7WihbVarUE3dJRKZT4xhBDqKHWUEEKYACCEkI+KMHeU3tvDzvZjvP/en72UU7WqqtkO6iqq1RoAYL1eY7GYI/D9oor1QfIWVs91MTjYR8220Wy2UKlWYVklaJoOwzD4BBFCqKPUUUIIYQKAEEJelTiOsZjPMBweYHfnCR69/z6e7mxjf+85vHM4VauqCsMw0Wg20e31UW80oKoq3OkUmqbBS6cIggBJknzoez/YwlqpVtFstWHXpaO1WbJg23W2sBJCqKPUUUIIYQKAEEJeBSEEVsslRsMBdne28fjh+3jy6H3s7z3HzHMRnbNiVW800Otv4P5bb6Pb60NRgOFgAFVVEccx4iQ5sXolhDjmZl2r2bBtG7WajVK5AsuyYFklrrQihFBHqaOEEMIEACGEXITCqXo8wtOdbTx+/z08efQQB3t7mE4c+Ov1qU7ViqJANwxUqlV0+308ePsdfOKT34hefxOKAjSaLVmVWq0QBD5Ekpw4x5okCcIgwHQyQaUiW1jrjSaqto1KuQK9Y9DNmhBCHaWOEkIIEwCEEHIRCqfqnW1sP3mMJ48fYe/5U4zHI6xXq/MFrZUq+hsbuHP3Ht565xvwzif+LWxu3QYAWFYJ69UKq9USYSDXXgW+f3ILa5JgvVrBGY9QrlTQaDRRs21UK1VYpRLsep3VK0IIdZQ6SgghTAAQQshLBa1HnKp3th/j8cP3/3/27jvKsrO88/337H3C3udUzjmnbgmBkBBBIJIMBowEiGAcxuCAjVm2lz3DLK+Zuevaa9Z47jhcp+sA2BiMscEBDBZIBkRGEhKSkAB1V07dXbm6wjk7nR3uH6eqJGF1dQsUurp/n7X6n25VqWrXWb96z/M+7/OyMDfL2toqjlM676LVNE1s26axqYm29k4Gh0cZHBqhq7uHlrZ2kr3J1KVSke3tLXZ3d3AftRP2eO2w+y2su7s7By2sVTU1lSutamrIZDPYdl4/PBFRjipHRURUABARuRD7k6qXzpxmfq5yR/WphXk21tco7uwSlsuH3lFtmiaWbVNf30BnVzdDI6P09Q/Q1dNLc0srhUIVSZLQ3NJKqVikuLtDqVikVCwR+D7OIfdaR1GE73l706zP7N1rXVc5x2pZpNMZTbMWEeWoclRE5CljvufX3/tbegwicikol8vs7myzvHyGuZlpJk6eZHZ6itOnT7F1dpMgCM47rCpnWdQ3NNLR2cXA0DBDI2P0Dw7R1t5BdU0tmUwGwzAwTIMUKcphGd/zcF0Hz3Urk6wP2RlLkoQk3t/dSsjlcuTzBWw7j2VbZDJZTbMWEeWIWmnfAAAgAElEQVSoclRERAUAEZFziaKIUqnIyvIyc7MzTIyfYGriJKcXF9jaOktwjiumHr1ozWZz1NXX09rWxsDgCMNjYwwMjdDR2UVdfQPZbBaotLcaholhpEiShDAM8TyXUqmI67oEQQDn2L2qLF5j4iQmBRimSTabw87b5O08dt4mnU7rHKuIKEeVoyIiKgCIiHy/OI5xHYe1lRXmZ2eYmhhnavwkpxcX2dhYu6BJ1dlsjqrqalrb2ukfHGJ4dIz+oWG6e3ppbGwim8v9h4WuYZqkUinCcpkg8HEdt7J75VX+f4ftkpEkxFHl3zOZDLZtY9k2+UKBXM7CNE39YEVEOaocFRFRAUBE5JH1X4LnuaytrbI4N8v01ARTE+Mszs+yurqCUypd0KTqQlUVLa2t9Pb1MzQyyuDwKD29/TS3tJCzrMf9WMMwMIy9xev+7lVxt7J75fvEcXToOdk42VvYpiCTyWLn85U21rxNNpvV7pWIKEeVoyIiKgCIiOyrXFO1wanFeWamJpg4+TBzM9OsrS5TLBYPHVa1P6k6n8/T3NxCV08vw2PHGB4do7evn5bWNmw7f84FZCqV2mszhTAs7y1ePRynhO+5lA/Zvdr/muK40sJqptNYlo1lWeTzhb1zrBpkJSLKUeWoiIgKACIiBL7P2bObnF5cYHZ6mvET32N+boaV5SV2d3Yol4NDd47S6TSWbdPQ0Eh3by9DI2OVRWv/IK3t7eQLhfMOkqosftMHu1dBEOD7Hk7Jwfc9ogtpYY0TSB5pYbXtPLadVwuriChHlaMiIioAiIiUy2W2t7ZYPnOKmekppiZOMjM9xdLp0+xsb/3Ak6r7BgYPJlWn0xd2U6phGAeL1ziOKwtXp4TneXstrPGhC+gkToCk8nnS6YMW1ny+QEYtrCKiHFWOioioACAil6soiigWd1k5c4a52WmmJ8eZHB9n6fQpzp7dPFgsnjP49iZGP3pS9cixYwwMDdPZ1U1tXf0Tahvdb4E1jBQJyd4Olo/rlPA9nyAIznmndeXvkoMW1nQmg2Xb5CyLQlU1OSunadYiohxVjoqIqAAgIpefOI5xSiVWl5eYnZlmemqSifETLJ05xcZ6ZVJ1FJ17aJRhGGQyWaprqmlr72BgcJjhscod1d09vTQ0NP6HSdUX4vt3r8IoxHUcfM8l8IPKAK3ztLBGcUwqBYZhYts2+Xwey7bJ5nJqYRUR5ahyVETkh5bWIxCRoyJJElzXZX1tlcWFeeZnZ5iZmuDMqVOsr51/0ZpKpTDTaQpVVTS3tNLZ3UPfwCB9/YN0dvXQ0PiDLVr3ZbNZauvqaOvoxHFK7Gxv45RKe3da+8RR9Lh3aCdJQhRFuK7Dxvo6hUIV1TU1VNfUYufz5KzKGVYtXkVEOaocFRFRAUBELgu+77G1ucGZ06eYn51henKCxYV5NjfWcZwLuKYqnSafL9DQ2ERHZzeDQ8MH7apNTc3kctYP/TXmchYNDY24HV0Ud3fZ3dmhVCriex5RGJEkj99WG8cxURhSKu6yurKMZdtUV9dQKFRRKFSRSWfIFwpqYRUR5ahyVETkB6YjACJyJOxPqj61MM/s9BQTJx9mYX6W1eVldnd2CMPyBU2qbmxqoru3j+HRMQZHRunrH6Cl7cImVV+IR86xGkRRVFmMlop4rovnuYdep/WYK60MA9MwyFk5cjkLO5/HsizMtOq2IqIcVY6KiKgAICKXqP1J1UunF5mdnmJy4iQzU5OcOX2Kne1tyuXgvMOqclZlR6mzq4eBoWGGR4/RPzBIa1v7E5pUfSEq51hNzL3Fa7lcxnUcHKd00MJ62L3W8V4r636rrW3b5HLWwVCrJ2OBLSLKUeWoiIgKACIiF5VHT6qenZlmanKcyfGTLJ05zdbWWcrB+RetmUyW+oYG2js6GRgaZnTsOAODQ7R3dFFTV/eEJlVfcLiaJoZhEscRge/jeV5l98qtDLM67EqrJEmIo8q/G4ZBLpcjX1VFvlDAsmxdaSUiylHlqIiICgAicmn5/knVM5MTTE6cZPnMadbX1/A9jzAMz/nxB5Oqa2to6+hkYHCIkdHKNVUdXd3UNzT8UMOqDpNKpTBMk1TKIEkSwnIZ13UOzrGer4V1/89+K2wmk63caV0oqIVVRJSjylERERUAROTSsT+penVlmfm5yqCqqYmTLM7Ps7a6iuc6jzsJ+tELx0w2S3V1DW1tHXvnVY8xNDJKd08vjU1N5CzrKf0eDMMgbZqQgrBcJigHB2dYfd87tIV1f+EexwkkkLMsLNvCytmVidY5tbCKiHJUOSoiogKAiFwCPM9lY32NUwsLzExNMnHyYebnZllfW6VY3L2gSdWFQuWaqu7eXkaPHWdoZITevn4am1uwbftpaf80DAPTMEmloBwEuK5LqVjZvQr84NDF9/7iNZWqfE+WZWEXCpV7rdXCKiLKUeWoiIgKACJy1Pmex9mzmyzMzTE7PcX4ie+xuDD3hCZV2/k8jU1N9Pb1MzzyqEnVrW1P2qTqC7Hfegop4iQmLJfxfY/ifgtr+MRaWHO5HPlCFbZtY1m2WlhFRDmqHBURUQFARI6mIAjY3jrLqcUF5menmRw/wez0FEunTz+hSdWNjU10dnUzODzC8OgY/QNDtLW3U1VdvbeQfPrs76SRgigM8TwX13HwPBfP84ii6NCFeAIkceXfc5ZFzspRKBTIWRbZXE4trCKiHFWOioioACAiR0sYhuzubLN05jRzM9NMjp9kcvwky8tLbJ3dvKBF6/6k6rb2DgZHRhkZO07/4BDtHR1P+jVVT2Thut/CGicJYRjieR6OU8J1HIIgIEnOP82aVIpUKkUul8OyKmdYbTuvFlYRUY4qR0VEVAAQkaMjjmOKxV1Wl5eYmZo8GFa1dOY0mxvrBL7/xCZVDw0zsndHdWdXN3X1DWSz2Wfs+9tvPU2lDKI4OmhhdVyHwPcph2WSQxblkBws2tOZTGXRmi9g5/OaZi0iylHlqIiICgAicjQkSYLrOKwsL7EwN8PU5ATTUxMsLsyzsb6G57oXPKm6vb2T7p5eRkaPMTg8Qk9vHw2NjeRy1jP+fRqGgWkaGCmDKIrwfR/PqUyz3l+YH3qOdW+BD5VdOsu2ydt57HxeLawiylHlqHJUREQFABG5+Hmey/r6GosL80xPTTJx4mHm52ZYX1vDcUpEhyzoDMN4nEnVVzA4PPy0T6q+oNA103sLzIQoDAkCH6dUwnNdAj84GFZ1zsVrkkCq8nky+ztYhUKlhTWTUQuriHJUOaocFRFRAUBELk4Hk6rnZ5mZntybVD3P6uoyxd3dQxet+0OhKpOqm+ntH2RoZJTB4ZFnZFL1hdhvYTUMgyRJKJfLlR0sz6vsYJWDQ1tYk6TSwpokCcbeNGvLssnv3WmdVguriHJUOaocFRFRAUBELjaPnlQ9NzPN1Pg4szOTLJ85w+525Zqqcw2r2h8IZdk2DXuTqodGRxkZHaOvf/AZm1T9RBavqVSKOK5caeU4JTzHJQj8QxfrSZIQJwlJnGDsfR7btrH2rrPK5nIX5fcsIspR5aiIiAoAInKZ+o+TqseZnDjJ8tIS21tnCYLg0POq+3c51zU00tbewfDI2EUxqfpCF677LbcAYRRSDiqLV8dxKAfBwe7UOVavxHFMHMcYpkk6k8GyrMogK9smk8noHKuIclQ5qhwVEVEBQESeeeebVO3v3el82KI1k8lSU1tHe0cnQ8OjDI+N0bc3qbq2rv4ZnVT9RBav+wvMYK991fdcXM+lXD73rt3+gjaKK/dep4wUtmWTs3LY+QKWZZFO6xyriHJUOaocFRFRAUBEnkFPxqTqdCZDdW0N7R1d9PT1MXLsOAODw/T09lFf30AulzsSz6Iyzdo8eC5BEOCUiriOi+97h7awxnEMSUIUxRhm5fNYloVlVVpYc5alFlYR5ahyVDkqIvIYmnIiIk8rz3PZ2FjnzOlTzM3OMjM5weL8HJsbG7jnWbTuL/QKhSoaG5vo7OxiaKRyVrWzu4e6+npylnWknkcmm6Wuvh7PbWdne5vdne3KNGvPJSyX8TzvnIvXKIpwXYf11VUsy6Kmtpaq6hoKVVXYtk06XacWVhHlqHJUOSoickAdACLytHnyJlU30ds/yPDoGINDI/T29dPS0oqdzx+5ds1KC6uJaRrEcUw5CHAdl1KphOd7BMG5p1nvP6s4jiCpfC7LtitXWtl5LFstrCLKUeWoclRERAUAEXmaPXpS9ez01A89qXp4dIzh0TH6BwdpaWunUFV1ZHdpDMPA2JtmHcUR5XIZz3VwipUdrDiKDj3HWvlT+TzZbJZcrjLIKp8vqIVVRDmqHFWOioioACAiT59yufyYSdVT4yd/uEnVo8cYGTvGwNAwrW3tVFfXHPnF2cHide95eZ6H6zr4vk/g+0RRdJ4rrfamWacMcpZFPl8gX6jCsm2y2ax2r0SUo8pR5aiIiAoAIvLUiqKI4u4OK8vLzE5PMjVxkqnJ8SdlUnVHZxc1tXVkMpkj/5wePc06oXI9lee6lEpFfN+nXC4f7FKdS1LpX63sYOVy2HmbQqGKnJUjnU5r8SqiHFWOKkdFRAUAFQBE5KkRxzFOqcTK8hnmZ2eYmhhnZnqKU5fhpOoLURnOlcYwDKIoIopCXMfBdd29BX54zhZW2NvBihNSQC6XI58vVFpY7Tw5y9IgKxHlqHJUOSoiKgCoACAiT74kSXBdl/W1VRbm55iemmDi5MMszM2xvraK4zhEYXjoIi6dTlNVVU1zcwu9vf2MHruCweFRevr6aWxqwrLtS+65VXavTAzDIPB9wnKZUqlYud/a9w5tYd1/s7C/6M9kM1hWfm+YlU1GLawiylHlqHJURFQA0GMQkSeb73uc3VhncWGeqYkJJsdPsDg/x/raCsVi8bKcVH0h9r/3lJEiSZKDc6yOU8Jz3UNbWCt/lxDFEaRSpM00mWwWy7bIFwp7V1pl9OIUUY4qR5WjIqICgIjIkyMIAs5ubnJqYZ6ZqUmmJseZnZ5iZekMuzs7hOXLd1L1hS5eD1pYw5Ag8B8ZZuX5ROHhLawkCVEUkyQxmUwWy7LI5/NYlk0up2nWIspR5ahyVERUABAReRKUy2V2trdYOn2KudkZJidOMj0xzuryEjvb25TLwaGLLtM0yVkWdfUNtLV3MDJ2nOHRsUtqUvWFqEyzrizOozgiCAKcUhHXcfB9jziODx9kFT/yb5lslmw2R6FQhZ3Pa5q1iHJUOaocFREVAEREfjiPnlQ9PTXJ5PhJpicnWFk6w+bGOkHgX9Ck6tq6Ojo7uxgaHmFodPSSm1R9IR7ZvUoRxzFRFOH7Hq7j4HkeQRBcUAtrkiSYpollWeQsC9vOY9kW6XRGi1cR5ahyVDkqIioAiIg8cd8/qXp6cpyZqUkWF+bZ3NzAO881ValUau+aqlo6urro6etnZOw4/QNDl+Sk6gtdvBqmSSqVIooiwr1zrN5eC2sYlg/dvSJJ9na4wEilsPN2ZZBVPk8um8NMp/XCFVGOKkeVoyKiAoCIyIV7vEnV4ye+x8L8HOtra7hO6dBFq2EYlWuqampobm2lt2+A0WNXMDQySndvLw2Nl+ak6gtxMM3aNAnDMkEQUCoVcZ0SQRAcOs06SRLiJCFJYlKGgZlOY1s2ll35k8lmdaWViHJUOaocFREVAERELpzve2yur7EwP8fUxDiT4ydZnJ9nbXWFUunCJlXnC1U0NjXTPzDI8OgxBoaG6entp6mlFdvOX7ZtlpUWVnPvHGuKsBxS9n1c18VzXYIgII6jQz9HHMUkVFpYs9kclm1X7ra27cqkbLWwiihHlaPKURFRAUBE5HwC3+fs2U1OLS4wPTnB9NQEs9NTLC+dprize95J1aZp7l1T1UxXTw8jo8cYHBmlf2CQltZ28oXCZb+7Utm9Mg7OsZbLZVy3dHCO9bA3BvvnWJMkBlIYpoFl5bEsCzufx9qbZq3Fq4hyVDmqHBURFQBERM69aA0Ctre2OHPqFHMzU0yMn2BmcuIJT6puaGikvbOL4dFjDA6PMjA4TFtHB1VV1bpq6VGL13S6MsyqcqVVgFNycJ0Snu8Rn6+FNY4hiUkZJulMunKO1bLJFwpkszm1sIooR5WjylERUQFAROTxhWHI7s42K8tLzM5MMTl+kpmpSZaXTj+hSdV19fW0d3YxNDLK0PAoA0NDtHV0UlNTS1rDlQ5U7vU2MQ3zYPfK85y9YVbnb2FNsdfCmiQYhkkul8WyK4OsbKtyjlW7VyLKUeWoclREVAAQEXmMKIoolYqsLi8xNzvD9OQEU5PjnFqsTKr2n8Ck6vbOzsqwqrHjDAwN09XTS11dPdlsVg/6cRevBkbKIIpCwjDEdS68hTVJ4sogK1KYaZNczjq409qyLE2zFlGOKkeVoyKiAoCIyGMXQK7jsLa6wvzcDDOTE4yfPMHC3Cyb6+u4rnNBk6praiuTqvv6Bxk7fgWDwyN09/RR39hIzrL0oM8V2qaJmTYxDINyOSAMI1zHxXUdgsAnjqJD24XjvTuvU6TIWRaWbZG38+QLBXI5S7tXIspR5ahyVERUABARqfB9j/W1NebnZpmZmmDi5AkWFyrXVJVKxUOvU3r0pOqm5hb6BgYYHh07mFTd2NyCbdtaPJ138ZrGMCpnegM/oFwOcEolfM+jHJSJ43P/DEgSkjghAUzDIJvLUShUY9v5ypVWmYyev4hyVDmqHBURFQBE5HIX+D4bG+sszM8yOz3FxMkTzM/OsLJ8ht3dXaIwfAKTqnsZHhljcGSUvv4BWlrbNKn6Au0/y1Sq8qzCMMT3PJxSCc/zKIflygL1cRav+y2skJBKGaTNNNmcRb6QJ5/Pk7MsDQwTUY4qR5WjIqICgIhc1ovWIGBr6yynFheYm5lmanyc6akJVpeX2dneIQwPv6bKMAxylkVjYxMdnV0Mj44xNDJKvyZV/0AMwyCzd/d0uVwmCHx8vzLIyve9Q99EAMRxfHClVSabxbZsLNvGtm2yOU2zFlGOKkeVoyKiAoCIXJb2J1UvnTnN3Mw0EydPMDs9xdKZM2yf3SQIgvNOqs5mc9TXNzwyqXpkjP6BQU2q/mEWr6aJYZikUlSutPJ9iru7+J6H7/t7i9NDWliTBFIpUqTIWrnKJGu7MshK06xFlKPKUeWoiKgAICKXmf1J1StLS8zPzTA9Mc7M1ASL83Nsnd2sTE0+z7CqbDZHbV0dHZ1d9PUPMHLsisqk6u4eTar+IaRSKcy93askjimH5YMWVt/3KZfLJOfYvdq/03r/yivDMLBtm5xlkS8UNM1aRDmqHFWOiogKACJyOXnMpOrZaSYnxpk48TCnFuc5u7GB57oXNKm6uqaa1rZ2evv7K5Oqh0bo6umlvqFBk6p/SIZROX9KKlU5w+r7uK5z0MIaHnKlFTwyzRognU6Ts+yDM6xqYRVRjipHlaMiogKAiFwmDiZVz84wNTnO1PhJTi3Os7a6SskpnX9SdSZDoVBFS2sbvX0DDI8eY3BohO6+fhqbmrAsTap+Uhavprm3wEwIowjf8yiVKvdaB0Fw3hbWOIoP2liz2SzW3u6VbefVwiqiHFWOKkdFRAUAEbnUPWZS9cwUk+MnmZudYWV5iWLx/JOq0+k0+XyB5uYWunp6GRk7xtDwKL39AzS3tGLn89oVeZLst7AmCcRRtDfMKnjMNOvkkEFWkBBF0cFU7JxlYduVadaWZelcsYhyVDmqHBURFQBE5JJdtAYBZ89ucvrUIrPTU49Mql5ZZndnh3I5uKBJ1Q1NTXR2dTM8eozhsWP09Q/S2t5OoVClSdVPskoLq0lCcjDIynEcPNfB9zziQ3YZk6Ryn3Ucx5CCtJmuDLHK57HzebWwiihHlaPKURG5RKgcKSKPUS6X2d3ZZmV5icX5OWamJpmfm2FtdZWd7a1DF637C6hcLkdtXT3tHZ0MDI3QNzBIV3cPzS0t5PMFLVqfItlcZUK439lJcXeH3Z1tSsVdXMchLIfnbGFNkspi1ymV2Fhbo6qqmpraOqqqq8nnC+RyFoWqKi1eRZSjylHlqIgcceoAEJEDYRhSKu6ysrzM/Ow0UxPjzExNHkyq9n3/AidV19PZ1U1P/wBjx66gf3CIrq4eaurqNKn6KbTfelqZZp0QBAG+5+L5Pp7nnneadSrFweJ2/w2Inc9j5wvkrByZTEYPWUQ5qhxVjoqICgAictTFcYxTKrG6unwwrGr8xPc4tTDP2c3NC59UXVtDS2sbfQODjB2/koGhYTq7e6ivbyCXy+lBP8UMw3hk8ZoklMtlisXdx0yzPpdHt7AapoFhGFi2fbCAzWZz2nUUUY4qR5WjIqICgIgcZUmS4Hnu3qTq6cqk6omTnF5cYG11FecJTKpubassWodGRhkYGqa7t4+m5mYsy9aDfpoXr8neUKpyUMZ1nMogqwuZZh3HJHGMsT/N2rbJ5wtYtkUmm1ULq4hyVDmqHBWRI0ozAESEwPc5u7HBqYV5FuZmmZ2eYnFhntWVlcqi9UImVdt5mpqaae/oon9gkP7BIXp6+2hsaiaX0x3VT/fC1c5Xfh5Oscju9jbb21uUSiUC3yeMonMuXuM4Jgwr55fXVlfIFwpU19RSW1dHvlAgZ1m6dkxEOaocVY6KyBGlDgARLVrZ3Nw4mFQ9cfIEM1OTrK4ss7OzTVguH7po3b/u6NGTqkeOHaevf4CW1nYKhYJ2Op6hxatppjEMgyje370q4TgOvu8RheHh06z3drAMs/J5LMsin6/caW3Ztn6mIspR5ahyVERUABCRo6RcLrOzvcXy0hlmpqeYGD/B7Mw0K0tn2N7aOmhzPGeAmCa5XI66+ga6unsYGhljcHiE/oFB2to7qKqu0VnHZzLgTbNyjpUUYRhSLpcrw6z2zrEe1sKaJAlxkhDFEWnTJLPXwmrn8+TzBbK5nHavRJSjylHlqIioACAiR8H+pOrlpSVmpyeZnhxnenKC06cWOXt2k8D3z3tNVTZbWbR2dnXT2z/A2LHjDAwO09nZTU1tnaYdXxSL1zRm2iRJYsIwxHUcHNfBcz2CcnCwS3UuSZKQAgzTxLL2Fq4FTbMWUY4qR5WjIqICgIgcCY+ZVD0zw8z0JOMnHubM6VNsbqwTXMA1VZlMlpraWlrb2ukfHDq4pqqzu1uTqi8i++3FhmEQRxFRFOJ7PqVSCd/ziKLzt7AmCRhGinQ6U9m9suyD3SvtTIpyVDmqHFWOiogKACJykfr+SdXTkxNMnHyYpdOnWF1ZwXVdwkPONRqGgZlOU1VdTWt7+96k6jH6B4c0qfoiVfmZVRaYYRTieR6uU9prYfWJD5lMniQJSVw5x5oCsrnco86wWmQymmYtylHlqHJUOSoiKgCIyEUp8H0219cPplRPnDzBwvwsy0tLlErFQ4caHUyq3rumqrunl5GxYwyPjtLXP0BTSyu2rcnGF5tUKoVhGBimAQmV3Svfq1xp5bqUgzJJcsiVViQHbcyGaZLN5rDzNnk7j523SafT+pmLclQ5qhxVjoqICgAictEtWvcmVc/NTDNx8mFmp6dYXVlmd3fnvNdUmaZZuRapuYWOrm5Gj13B8MgYvX39tLS2kdek6ovWI9OsU8RRRFAO8FwXz63cax2G5UPPKpMkxFFlcZvL5bAsq3KvdaFALmephVWUo8pR5ahyVERUABCRi0W5XLmTeHnpTGXHavwEs9NTrCwvXfikasuivqGRru4ehkdGGRwapX9wiLb2dgpVVVq8XOyBb5qV3atUiigM8f3KGVbPdfCDw1tYAeKk0r4KCel0BtuuTLK283my2ax2r0Q5qhxVjipHRUQFABF5poVhSKlUZGVpibmZKaanJpieGOfU4gJnNzcueFJ1fUMDHV3d9A0MMjJ2nMGhIdo7OqmuqdUk4yMinU7vDbKKKZcDAt+nWNzFdVzK5XO3sO7/XRxFkFQ+Tzabq0y0ftQ5VhHlqHJUOaocFREVAETkGRLHMa7jsLqyzPzsDNNTk4yf+F7lmqrNjb0Jxhc+qXpgcIjRseMMDA3T3tlFfX0D2awWLEdFKpXCTKchBVEUEQQ+nudVWlhd9/wtrHuvqThOSKfT5CwLy7aw7bxaWEU5qhxVjipHRUQFABF5phxMql5fY3FulpnpSSZPnuD04gJrq6s4jnPopOpUKkU6kzmYVN0/OPTIpOqeXpqamslZlh70kVy87k2zDkOCIKBU3MV1HYK9FubztbAmJKRSKTLpDLa9d691Pk8mq2nWohxVjipHlaMiogKAiDztAt/n7OYmpxbmmZ2ZZnL8JPNzs6yuLFEsPvFJ1cOjxxgaGaW3b4CmlhYsS5Oqj+rC1TAMDCNFkiSEYUi5HOA6Dr7nEQTBBbSwxpCq7Gxalo1l2RQKVeRylqZZi3JUOaocVY6KyEUqrUcgcokuWoOA3d0dNtbXWF1ZZnFhjlML82xsrFMqls47qTqdTmPZNo1NTbS2dzA4PMrg0Ahd3T00NjVr0XrEmaZJvlBFY1MzpWKRnZ1tdra3cPZ2r4rFmKRcftzFaxxXzr3ubG+xsrxMdXUNNbV11NTWkrMsMpkM2VxOD1mUo8pR5ahyVERUABCRp1oURQS+z/bWFmurKyzMz7F05gwbG+vsbG9RLgfnP6+azVJbV097RyeDQ8P09g3Q2d1Dc0srdj6v9sRLQDabpbaujtb2DkqlIjvb2+zu7OKUSgR706wf73WSJAlRFOF5Hltbm6ysLFE7X09NbS1V1dXYto2ZTuscqyhHlaPKUeWoiKgAICJPpSRJCMtlXMdhd2eb9bVVVleWWVtZZntrC9/3z7tozWZz1O0tWrt7++gfHKavv5+W1lYKVdWk04qOS0UuZ9HQ0Ijb0UVxd5fdnR2KxV0C3ycsV1qbH2+HM0kSojDEKRZZX12lpraOpuZmGhobqa6p7GDZdl67m6IcVY4qR5WjIqICgIg8VSpthZ9hEr8AACAASURBVGUc12F7a4uNtTW2NjfZOruJ57mH3lG8v2itrqmhqbmFnt4+hoZH6e3rp6WtnRpdU3XJMQwDO5+nqbmZYrGycN3eOotTKuG6LnGx8np5vNdMFEWUw5BiscjG2hrLS2dobm2lvr6RQqGKTCar14soR5WjylHlqIioACAiT+XCNQzLeK6D4zqUSkW2984khuc7r5rJkC8UaGppobd/gP7BYbp7+2jv6KShoVHnES/VXwTpNNXVNbS3d+CUSuzsbFMqFimVioRhmcR1CcPwcT82CkN8z2V76yybGxtsrK/T2rpFqdRIvlDQICtRjipHlaPKURFRAUBEngpJkpDEMWEYEoYhvufhOHtXEkUxyTmuJdpftBYKVTS3tNDZ1U3fwCB9AwN09/TS0NSkReslLpvLUVtXT1t7O9tbZ9k6e5ZicRff8wjL4d6d1Y/fwloOQ1zXYWd7i63NTXZ2tvFcl3LgE+VyanUW5ahyVDmqHBURFQBE5KmSSqVIkSKVMjAMA9M0zrl7YBgGZjpNPl+gsamZjs5uBodGGBwaobunV5OqL6PXjGXbNDQ20dXdS6lUpLi7Q3F3t/LGZzcmLJf/w+J1/81SOSjjOCVcz8X3PHzPPXSnVEQ5KspR5aiIqAAgIk/SIsQwTTKZNLlcDsvKY9k2TqlEtHd2df8O43Q6g53P09jUTHdPL4PDI/QNDNKlSdWX3y+EdJqamlpa2trY3d1hZ3ubUqmI7/uEYYgTFx/3HGuSJCQkRFGM57oEQUAUVXa69ndL9cZHlKPKUeWoclREVAAQkSd70bq3E5XNZqmqrgyhqm9YZmtrk8D3MUyDOIpJpSCdyWDbeRqbm2nv6KKvv5/B4RF6+wdobm3TpOrLUCabpba2jo7OLkqlIqViEddxiKKQJIlxXZfw++61TqUqu6TpvTdKZtrEMLRQFeWoclQ5qhwVERUAROSpW7SmUpVzqGYay7apqamhobGZzq5ugsAnbaYPdiKMVIqcZdPQ2EhzSyvdvX309Q/Q3dNHa1s7tbWaVH25vobsfJ6GxkY6OrtwSiU8z6NcLhNHEbCJl0oRheHBjlQmkyWfz1MoVGHZNtlsDjOdJpUytGMlylHlqHJUOSoiKgCIyFOl0o6axrZt6uob9toIQ9KZDFVV1ezu7hL4HqaZpqq6mobGJlpa2+jq7qGltZW2jk7q6us1rOoyZpomVdU1tLS2VVpRfZ8oCjFNEzOd3rsH3SOO48r1V3ae2ro6mpqaaW3roL6+AcuyyGQzpAwtXkU5KspR5aiIqAAgIk+JVCpVaV3NWRSqqmmMIoDKYKKGRnZ2tgnDkEwmQz6fp7aunsam5r0/TdTU1pLLWXqQl7lMJkNNbR2t7R1EUbi3oE2Ts2zWVlcoFXeJooh0OkNVddXB7mdTczM1tXUUqqrJpDM69yzKUVGOKkdFRAUAEXlKF66mSTabhSTBMPaupqqqoqGhEd/ziOII0zDJWRbVNTVUVddQVVVFoaqKXM7SToNUpllbFvUNDSRxjGGYWLZNXV0day0t7GxvH7RD19TW0drWRntnFx2dXTQ0NmLbNpmMFq6iHBXlqHJURFQAEJGnfNGxP3QqZVR2smzbpqa2liiMDloOM5kM2ZyFbdtkczkymYwWrXLANE3y+QJJY3KwkK2urqa5tQ3HKRH4AYZhUFVdRV1dA/WNjTQ2NlGoqsay7b3zq3o9iXJUlKPKURG5aH6/PTy/kugxiFyakiQhjmOiMCSKI6IwOrh+qNLiapI205jpNIbOGMo5lMtlPNfdu9N6l1JxF8dxiKIIwzTIZnMUClVUV1eTLxSw8/nKACvT1MMT5aiIclRELiLqABC5hO23sRqGQTpJiDPxwbVD+/dX70+8FjmX/R1NM21Wdq9qagjLZaK4cg2aaVauS8tmc2RzWTKZrBatohwVUY6KyMX4e00dACKXl0cvXEWeiDiOiaKIOIoIo4gkjitvfIzKlWnG3psknVcV5aiIclRELk7qABC5zGjBKj+o/UVpkk6T2WuB3n9NaQdUlKMiylERUQFAREQuwTc/WqSKiChHReToUX+RiIiIiIiIiAoAIiIiIiIiIqICgIiIiIiIiIioACAiIiIiIiIiKgCIiIiIiIiIiAoAIiIiIiIiIqICgIiIiIiIiIioACAiIiIiIiIiKgCIiIiIiIiIqAAgIiIiIiIiIioAiIiIiIiIiIgKACIiIiIiIiKiAoCIiIiIiIiIqAAgIiIiIiIiIioAiIiIiIiIiIgKACIiIiIiIiKiAoCIiIiIiIiICgAiIiIiIiIiogKAiIiIiIiIiKgAICIiIiIiIiIqAIiIiIiIiIiICgAiIiIiIiIiogKAiIiIiIiIiKgAICIiIiIiIiIqAIiIiIiIiIioAKBHICIiIiIiIqICgIiIiIiIiIioACAiIiIiIiIiKgCIiIiIiIiIiAoAIiIiIiIiIqICgIiIiIiIiIioACAiIiIiIiIiKgCIiIiIiIiIiAoAIiIiIiIiIioAiIiIiIiIiIgKACIiIiIiIiKiAoCIiIiIiIiIqAAgIiIiIiIiIioAiIiIiIiIiIgKACIiIiIiIiKiAoCIiIiIiIiIqAAgIiIiIiIiogKAiIiIiIiIiKgAICIiIiIiIiIqAIiIiIiIiIiICgAiIiIiIiIi8sxJ6xGIiMilaHdnhzs+dxvf+OqXSafTvP5Nb+a6F1xPOq1ffSIiInJ5UgeAiIhcctbXVnn/n/8xH/rAX5JOp9ne2uJjH/kQy2dO6+GIiIjIZUvbICIicslIkoTFhXk++qG/5rsPPcBb3v5TPOeaa7n/3nv46pe+QKlU1EMSERERFQBERESOsjiO+c637+eD7/9zdnd2+LGbb+H4lc8iDEPObm5QXV1DbV29HpSIiIhctnQEQERELglf/eIX+K3/9l6SJOFtP/kzHH/WVaQzGXZ3drj37jvpHxqmsalZD0pEREQuW+oAEBGRI83zXD75jx/jbz7wF/zIj76WG1/9OrK57MG/L50+xcrKMjU1NWxtblJTW0vOsvTgRERE5LKTenh+JdFjEBGRoyjwff75Yx/lH//+I7z2pjdw/Q0v+w//jeM4fP62W7nv3m9SW1vH81/0Yq6+5nm0tnfQ1NxCoVDQgxQREREVAERERC5mD3/3O/y//8//5MqrnsPLb3wVZjqN53kkcYxl2xhG5aRbFEUsnznDdx68n8mJcXZ3tmloaGJgaJjh0TH6B4fo7RugqrpaD1VEREQuWToCICIiR9bk+AmiKOLKq55NyjD45p3f4L577qZcDhgYHOalr7yR2rp6TNOks7ubzu5uXrS9zfLSGRYX5lmYm+U7Dz5AHMe0tLbxnOdey7XPfwEDQyOk0/oVKSIiIioAiIiIXBScUgnTNMlksnzjq1/mM5/6BNff8HKampv5yh2f5+HvPsQvvOfXaGxqOviYmtpaamprGRoZxSmV2NneZmNjjamJcT7z6U/wL//491z3guv58Z9+Bz29faRSKT1oERERuSToCICIiBxZd339q/zJH/wfnFIJxynxy7/2n3nN62/GMEzW11b5/f/128zPz/KOn/8levr6z7mrnyQJURjiui6z01Pcduun8FyXd//ab/DCF9+AZdl62CIiIqICgIiIXNqSJMFxHJxSiVwuR1V19cHZ+mdaHMc8eP99fOehB3jutddx5VXPecy/+57H//y/fpOHv/sQL37pK7jmuhdQ39CAaZqHft7i7i53fO42vvalO3jVa1/P237qZ2jv6FQ3gIiIiKgAICIil+6b/7mZaW791Cc4vThPbV0Dr73pDTz76muOzPdQKpX49Cf+ic/fdivZXI5rr3shY8evoL6hAYByEOB5Hr7vk8lmyGZz2LZNHMd859sP8NlPf5LW9g5+7hffw+jxK85bPBARERFRAUBERI4c13X48z/6fb51zze56tlXMzU5gWGk+MVf+XXy+QI9vX1HYnJ+EARMjZ/kc7fdyv33fpOcZdHa1k65XMb3PTzXxfM8stksdj5PX/8gz37uNbS0trG4MM9nP/VJwijkHT//Szz3ec8nk8noxSEiIiIqAIiIyKVjY32Nd/2nH+dVr30919/wMtZXV/nbD76frbObVNfUctOb3sIb3/LjF82RgPPZ2d5mfm6G73z7ARbm54jjiOqaWmrr6ujo6KRUcpibmeK+e79JEATc9MY3c+Wzn8P62iq33/pplpfO8Kv/5Td57rXXHZnvWUREREQFABEROa97776T3/pv7+Xdv/obVNfUUlNTi+97lEpF7vzaV9je2uK9//3/prWt/Uh9X0EQUA4CAAzTwDRM0pkMcRwTBD5bZ8/y8b/7MLff+iluetNbuOEVN7K7u8O//tPHmZuZ5v/80Z/RPzikF4iIiIgcKeZ7fv29v6XHICIij+czn/oEs9OTbJ89y5//yR/Q2NTM0MgoNbW1RFHEdx/8NmPHr6Sjs+to/fIzTbLZLNlslkwmg5lOk0qlMAyDTCZLdU0NL3zxDTS3tvKhD/wlTU3N9A8OMXLsOHMzU3z6E//Mtc9/IXX19XqRiIiIyJGh/kURETmnuZlpGhqb2NraAmBl6QxhGAJQX99IHMesriyTJJdmM9mPvu4mXv/GN3P7Z/6NzY0N8vk8b/3J/0RtXR1/9Lv/i7XVVb1IRERERAUAERE5+k6fWqSjq5tCVYHA98nlchipyq+OmtpaqqtrWDp9msD3L9lncPMtb8U0DR769v0A1NbWcctbf4LlM2f413/+GK7r6IUiIiIiKgCIiMjRtrG+RkdnF80trQAUqqowjBQA+UKBuoYGzpxexPO9S/YZNLe0cP1LXsZ3H3yArbNnAWjr6OCVr34Nd3zudu65685LtgNCREREVAAQEZHLQBAEOKUSNTW1pM105ZeGYR78u2maNDQ0srG+hue6l+xzsCybF1x/A8XdXaYmTu49B4NnX30NA4ND3PZvn2RleUkvGBEREVEBQEREjqYkjqmuqeXOr32FBx+4j0w2i+d5j9ntrq2rZ2d7G8+7dDsAUqkUo8ev4EUveSlf+sLnOL24SJIkFKqqeOGLb2Budpb77rn7YDaCiIiIiAoAIiJypOQsi1/5z/8Vz/MYHjvG1dc8D8cpEcePFADsfB7XdQjL5Uv6WRQKBX70x26mqqqaL37+dkrFIgDdPb0Mj47xtS/fwe7Otl40IiIiclFL6xGIiMi5vPJVr+Ha57+QtJnmz/7o99ncWCdO4kcKALaN73lsbm5w5wc/gO/7FAoF7Hye2ro6MpksVVVV5Cz7MZ+3prYWz3UJgoAwLFMqFhk9dpz6hsaL9ln0Dw7xE+/4Wf70D36XL37udl73hjeRyWY5dvxKPvFP/8Dy0tJF/fWLiIiIqAAgIiLnlEqlqKur3HWfTpuE5fJjjgBYtk2SJHzo/X/B7MwU/QNDxElMFIZEUUwUhZhmGscpPebzFgqVWwXKYUgmnSYIAl7yslfwnl9/70X9LJ73/Bfxc7/4y/zh7/4O9Y2NvPilL6d/cAjbsrnr61/l2BVX6kUjIiIiKgCIiMjRZtt5wigkiR/pAMjlcphmmq99+Q7e8+vv5VnPuZoojAjDMmE5JIoj4jimHATn/LyGYfDgA/fx1S/dcVEXAAAymQw3vOJH2Nzc4MN/9T6ampoZu+JKjl95FZ/77L/xjl/4JQxDp+tEREREBQAREfkBlctlwrBMJpMlnX5morumtg7PdYmi6JE37ykDwzCI45hrrnsBtm0/oc+ZJAmu4/D52z9Da3v7kfhZZLNZXv/GNzM9McGtn/oEjc3NvPDFN/ClOz7H7Z/5NK/5sZtJpVJ60YqIiMhFR9sUIiIXueLuLp+/7Vb+7A9/j9tv/RTb21vPyNfR0NiIUyo9pgDA3hvddCbzhN70Bn7A8tIZHrz/Pj7yNx9gZWmJn33XLx+Zn4lt5/nJd/48lmXxlTu+QFVNDTe++rV86P1/weLCvF60IiIiogKAiIg8cbMzU3z8o3/Ldx96kPf/2Z/wkQ9+gOCQlvqnSt/AEL7vs7G+dvB3peIu5XJAEsfcc9c3cEqlc358HMesrixz/7338Ml//hh//+G/4Y7P3UZjYzPv/R+/xbOe89wj9XNp7+jkplveytTESRbn53j5j7way7b567/8/1hZXtILV0RERC46OgIgInKR293dAeCmN70F13H48F+/j5e87BU8++prntavo39wkNa2dr71zbsYGhnFcRzuvfsuWts7uOHlN/LlL3yOzY11XnfTG8lks4/5WN/z+dY9d3Hn175CKpWit2+A17z+ZoaGRxgYGqG6pubItc1nMhmOX3kV1bW1rK2uMDQyys23vJVP/uM/8C8f+yg/+c6fp7a2Ti9gERERUQFAREQu0N7U/Ww2y9DIKI1NzTzwrXue9gKAbed5zU1v4E9+73/zrOdcTX19IzPTk7z+Dbfw6tfdxMix4/zln/wh173gejq6uh7zscvLZ/jKFz/P81/0Em581Wto7+ykprYO0zSP9I/GKZVwHYdsNksqlWJoZJRXvvo13H7rp+no6ua1r38D2VxOr2ERERG5KOgIgIjIRS6dzmCaJmEYYpom9fUNbGysPyNfy42vfi03v/ltfOgDf8n83CyNjU18/vbPMDszRU9vH3EcPe6Mgrq6Ohoampg8eYL6xkbqGxqP9Jv/KIpYXJjjIx98P6aZpqevn1QqRTqd5uprnsd1L7qej33kQ0yMn3jMtYkiIiIiKgCIiMg55SyLdDqN57kA+L5P3s4/I19LNpvlXe/5NX7kR1/H5z77b/T2D5DNWbz3V36JX/vFn2VoZJSe3r7/8HG1dfXcfMtb2Dq7yZ//8R+ws719JH8WnueyMD/HZz71Cd77q7/M6soyt7zt7bS2tRNFEbs7OximyUte+gpa2tr48F+979C5CCIiIiJPJx0BEBG5yNm2TTqdwXMrBYDi7g519Q3P2NdjmibvfNe7CcMy991zNyPHjtPR2UUqleLKq55NGIWUikUs28ZzXVKGQT6fp72zize+9e383d98gA//9fv46Z/9Berq6i/6558kCdvbW0xNjPPg/fdx793fYGtri+deex3XveBFpAyD7z70bU4tLnBmcZHrXnQ9V171HF72ylfxwff9GQ/cdy8vfunL9UIWERERFQBERORw+XyBbC6L6zgkScLOzjb1jY3P6NdUW1fPO37hl/n8bbdy3z13Uyzu4vs+D3/3IWzbxjTT5AsFnFIJwzBo6+jgOc+9lqGRUd7+0+/kox/+ILZt8/affieFqqqL8rmXy2UW5+e45+5v8NAD93P61CL5QoHRY1fQ2d2N6zh8+Y7Ps7gwRxiGNDU1QyrFZz/9r3R0djM4PMKznn01f/vX7+PZV19DdU2NXswiIiKiAoCIiJybnc9TVVXN7u4uruviex71z2AHAEAqlaK5pYU3ve3tvPQVN7K9tYXjOmyur7OyvETCI+fePdfl2/d9i+8++G1ed/ObuOrq5/L6N76Zz376E9TU1vKGW9520QzKC8OQhblZ7v3mndx3zzeZn53ZG744xg0vv5FSqciphXnu+vpXiaKQ4dFjvOq1P8bQyBjtHZ38+2c+zT985EPMz85w9bXP40dfdxO/9zu/zRc/fzs33/JWvZhFREREBQARETm8AFBbV8f21hY7ewP2qqqrmZoY59v3f4vlpTOUgwDP8zi9uABAa3s7VVXVpDMZBgaH6Ojspn9oiOrqmid1+J5l2XR299DZ3QNAHMeE5fJj/ps4ibn5lrfyj3//ET7+0Q9TLpe5+prn4TglPv7Rv6WuroGX/8iryWQyT+tzTZKEKIoIAp/Jkye4+86v87Uv3cHy8hLV1dUMjx7j9W98M8XiLt/7zkPcfefXiKKIseNX8OM//Q6e/8LrKVRXY1s2S0tn+LM//D2+edc3eO611xEnMZsbGzQ2N/Oil7yUf/3nj/Pil76cxqZmvaBFREREBQARETn3m+y6+gYWF+aJwohUKsW3vnkX//LxfyBJYlpa26irq6e2ro6W1lYASsVdTi8uEIYhX7j9s5RKRYLA58d/8mf42V96D5ZlPyVfq2EYj7ubb7XZvPtXf4OGhkY+9Fd/SRxHPP+F1+N7Ln/+x39AJpvhpa/4EQzjqZ1NmyQJTqnE2toq3/n2/Xzjq1/m4e88hOOUaG1vZ/TYFbzy1a8hjhNOfO87/NM//B1xHHHsimfxq//lN3n+C6+nobEJgCAIOHNqkY9/9t+49V//hUKhitfd9Ebuv/ebfO1Ld/DSV97Im976E7z8xlfz7fu+xWc+/Ul+8md+7shffSgiIiIqAIiIyFPEMAwKhSrCcohl27R3dPLJf/o4DY2NvPNdv0xT8+G7ynEcs721xR3/fht3ff2r/MQ7fu4pKwAc+gsnnebHf/odZLNZPvzX7yNJEl70kpdSKpZ435/+Ea2t7Rx/1lVPyf87DEPWVleYnpzgvnvu5oH77sUpleju7eOGV7yS2rp6oihi4sTDTJ48gZlO093bxzvf9W6e94IX0dnV/ZjPt7gwx91f/xqfu+1Wdra3GTt+JUmScOfXvsK1z38hw2PH+M63H2B7a4uW1lae/6LruevrX+WGl99IX/+AXtQiIiKiAoCIiDy+nGURRSFxFHHzLW/l3m/exfErn0XDBQwDNAyDuvp68oU8+UKBVCr1jH0fpmnyprf9BLu7u9z2b/+KYZi87MZXcfbsBn/6h7/L//jt3zk4TvBkKJfLTJx8mPvuuZsHH7if1eUlGpqauOo5zyWby+GUSszNzLC7u1MZ8Dd2nBtf8zqOHb+Szu4estnsYz7f5sY6d9/5df79M59mY22Nto5OClVVnD61QGdXD+/+td/AdRw+86lP0tbRiWXbpDMZrnrONXz3oQe586tfpqOj86KZeSAiIiIqAIiIyEWmvqEB13FwPZdjVz6LgeER0un0BbXMl4OAEw9/j3vuupNXvfbHsHLWM/q9mKbJW97+UwSBzxc/fxsNjY284Za38YG/+BP+5gN/wa//1//+A98MEEURmxsbzM1OMz05zkMP3M/c7DSWZdPXP0BTc8v/z959h0dVZg8c/06fSc+k954ACYRA6F16b4JYUOwF17Juc3d/lnV11VXXXtaKCqIISO+9Q4AkECCk994mU5Kpvz8CozETCLrruuv7eR6fZ3fuzL137p1hcs573vPSqmsh8+QJDEYD4RGR9O2fRq8+KURERhEeEekyODeZjGQcO8qGtV9TXFhAct9UvLy8ybuYi4eHB/MW3kT64KFs+GY1B/fupldyCqPGXoePb8cyhwGBgfRJ6cv+PTsZOmIUsfEJ4kMtCIIgCIJIAAiCIAhdJST1QqVWk3suh7DwCNTqngXxhfl5bNmwjryLFxhz3QSmzZr7sxh99vTyYt7CG6koL2PPzm0sWryEhTfdygfvvMHGdatZeNOtPapUsFgsFOZf5ExWJhfOneXihfPU19VitVrx8vYmKiqGgYOGUFJcRMbxYxj0rURERTN+8lQGDRmOf2Agnl5eqNWabo934VwOH//zbc5knaZPSj8mTZvBof17qaooZ8bc65kxZz5Wi4XXXvobBRcvMnfhIlJS03Bzc3PuQ6FUkjZwEGeyMtm1fQuh4eH/kWkYgiAIgiD8sknOldQ4xGUQBEH4+fvis0/4avky7n/oMULDw68YINvtdvbt3snar75g2MjR3Hjr7fTqk/Kza0CXefIEf3/uaSZPn0Vq/wEc2r+Xo4cP8tjj/0e//gO6vEer1YrBoKe+tpbdO7ayd9d2KsvL8dVqCYuIIjQsnMCgYBRKBQV5FzmbdZqWlhZi4+IZO34So8eNJygkFLlc3u31u9wosLiogNVfrmDPjm30Sk5h8NDhlBQVcfTQfnolp/Do7/+Mv38A+/fu4oN33sDHR8vdD/wKD09P575tNhtGgwG5QoFarebY4UOs+/pLfv/EX1AqlVitVqIuVSZ8f7qBIAiCIAiCSAAIgiD8Atntdmqqq3jj5RcoLipgyvRZBIeEERQcjNzF8nkN9fU89+QfueuBh7h+0c09Ooa+tZXzOWewWC0EB4cSHhn1bw9KzWYzzz35J1pbdSy+/S50Oh0rPv2IXr2Tuev+jmDa4XCgb22loryM3PPnyDh2mLPZmXh6etE7pR+9k1NQqlQ0NTRw7mw25WWltLe3ExgURPrgoQwfNZb4xKRrugb7du/g6OGD+PpqGZA+GJvdzvHDB1Gp1cyev5BJU2fQ1NTIN19/yc6tm0kdMJDJ02c5R/3b29qpra2mMO8iZ7Iz8Q8IZNLUGbi5u/P1F5+TnXkKubzjvvkHBDJ1xiyGjhhFWETkf7RHgyAIgiAI/9vEFABBEIT/guA/50wWe3ftYNjI0Xh5+7Bz2xZUKhVzFywiykVX+cqKMiwWCwMHDaGupgaD0YBRr0ena8FqtTqfJ5VJ8fX1IzQ8nJ1bN/POay+DREJMbBwTpkxj1rwFaDRu/7b3plQqCQoJobysBLvdga9Wy8BBQzh66ABlpSUEBQeTcayja39e7nksFgsRkVHMuf4GVGo1jfX1HDm4n9qaaqRSGVHR0UybNYeUfv2JjU/o8bmbzWayM0+xZ8dWzmSextvHl+smTEYml3M64zgWi4WxEyYzaep0QsMjyL94gc8+/oDC/ItMnj6TtPTBqNVqbDYblRXlnDx+lLzcC6hUKpJ6J5NzJoud2zYzY8585lx/A8NGjsbN3R1zeztZp0+xbvVXHDqwl3kLb2LYyNHI5eLnWRAEQRAEkQAQBEH4xdG1NLNx7Wq2bFpHaFgEoaFhmIxGWnUtWCxWl6/x9fVDqVLxwl+fRCKR0GYyYbPZkEqlyOVyvH18MRoNGA0GAHx8fcm/mEttTTVKpZIjlRWczzlLq66V2++5/982daCupmNpPj//AKRSCVKplOiYOA7s3c37b72G1Walob6O0LAI0ocMe/tmUAAAIABJREFUQy5XoGtp5sihAzQ3NuLl7U1ir96MHjeemNh4omJir6mBoNVq5eL5c2zZ+A0njh0lIDCIsRMmI1fIyTqZQXFRAWOum8j4yVOJT0hCqVJx5OA+Pv7nO8hkMhbedCvRsXHI5XKsFgs7t2/h5PGjaLX+TJ81l7T0wURGRbNv904++ufbnM85Q9rAQcQlJDrPISw8gn790zh25BCvv/Q8xYUFzJq/AG9vH/HhFwRBEARBJAAEQRB+SepqaygrLWHmnPmo1BoK8y9SXlZKQEAg+lYdpzNOsPGb1ZhMJuRyGd4+viiVSmw2Gwf37sbHV4uHhwe+fv54enoilcmwWMxIkODl5U3v5BRMJiM52VkEBAaRktqfs1mZ+Pj6svKzj5FKpdxw863X3JnfbrfT3t7WZRTeZDJSVlLMhXM5bNu0gbraGm5ecqdzKkNgcDATpkwj+/QpQoNDGDRkOMVFBRw5uJ+K8jKCg0NIHzKMIcNHEhoegVbrh7uHR49WRLjM4XBQUVbKlys+5eDe3Wj9OgL2gKAgjh06SMbxIyT26sNv//QUKf364+Hpic1mY8eWTfzz7ddI6tWHKTNm46vVIpFIqKmuYs2XX1BaUsyNi5cwetx4AoKCnVMohgwfSXbmSQ7t20NUVAz+gYHf/hArFETHxhEYHEJYeASrv1xBWWkxt9/zACGhYeILIAiCIAjCv4zoASAIgvAzdzY7kzdfeZEx100kMjqGl//2FyRSKaFhERQX5hMZFcOpE8eYNnsuvXonY7XZqKupxmg04nA4kEgkSCQS7DYbVVUVtLe1XQrETZQUFTJz7nzGTZxCc1Mja778gtzzOSCRcMuSO5FIJCxf9hEeHh4k9U4mJi4eL29vIqOiATC3m6mtrUbfqqe0uIj6ulpqqqtobKh3HtvhcGC3253v53KgrnFzo1//AYybMJmQsDAcDgcOux0kHZUAOWey2LD2a6orKwkICmbE6LGMHT+R6Jg4VGo1CoXimubLOxwOzO3tNDY2sGrFZ2xat4ag4BAmTJ1OVHQs53POsHndWnz9/Fh8x90MG9FRpi+RSGjV6Vi3+iu+Wv4pY8ZPYOyEyajVaixmM6dPnmDd6lWEhoXzp6efdTYZ/L4L53J4+W9/IT6xF5OmzkCp6tpfwWazUVRQwKoVnxITn8B9Dz5CaHiE6AsgCIIgCMK/hKgAEARB+JlTqVTIZHKMRiPZp09itVj5eOVqPDw8+ei9tzhycD+9U/pSUVbK0kd+g9bPv0f7PXcmm3+8+CzBIWGoVCoqykppbm5k1rwFDB42wtnNPiGpF5knMygpLuLgvj20mUxYLGZsVhtyhRy5XIHGzQ0/P3+CQkLolZyCl5cXHp5eeHh4YjDoadW1YDZbsFoteHp6ERoejtbPH4O+ldqaGs6dzaamuhqjwYDWz4+09MEUFxZSVlrCy2+8R+qA9B/VkNBoNFBcWMjBfbvZvmUjapWaBTfdSkJiEiUlRXz20T9paW5mwU2Lu5Tf19XU8NWKT9m5bTPTZs9lyLCRKFVKWnU69u/ZxfGjh5g6cza3LLnrilUSSb37MOf6G/jgnTeIiomhb2pal+fIZDLiExNZtHgJX36+jLdfe5kHHvkNoWHhOByd8/WXEzuCIAiCIAgiASAIgvA/ws8/gKCQEE4eP4rZ3E58YhJ+/gEATJg6nX17dtG3fxpHDx9k1RefM2XGbHQtzbSZTDQ2NGCxmJ37kspkaLV+qFRqci/kYLPZ8PH1BWD3jm0AZBw7QnVVJROmTCMwKBhvH1/GjJ/Y6ZwMej0mkwl3Dw80Gg02mw29vhVzWztGk5E2k4n29nbn8Q36Vgx6AyZTR1VCSmp/WnU6Nq9fS1lJMQqlEm8fH6xWG1mnT6JSqUgfPIR9u7bT1Nj4g4N/m83G2exMDu/fy/Gjh5FKZYweN4H+A9IpLipg3eqvqKutoW//Acyev4Ck3smdXl9fV8s/336N7NOnmLtgEakD0pHL5ehbW9m84RsK8nJZfPs9TJgyDXd39yuei0QiYeyEyeSeP8c3q74kKDiEwKDgLs+z2+0EBYcwatx41ny5grdffYnBw0Y4mzdKLlVIyOVyNG5ueHh44uXtg5e3N0HBIaKB4L+RzWZD19JMc1MTDQ31GPR6DAY9DrvdWfEilcmQy+S4e3qgUqnx8vbG3z8AX62fuICCIAjCf5yYAiAIgvAzZ7fbyT59km++/oqWlibmLbyJUWOvAzqa2L3wzBPknstBIpVSXlpCbHwCupYWTCYTTY0NWC0WHHT8Uy+VytD6+aFSqTCbzehbWxk5ZhxhEZGs+eoLnv7bS5jNZr747GOsFgv9+g8gJDSMwKBgfHx9nfP0ze1mcs5kUVSYj761FZPJiEGvx9zejsVqRalUXvpPhcbNDYVCjkbjztHDB5BIJDz57Its37KR4sICFt2yhJi4eHy1WsxmM8s/+YDiwkIW3nwre3Zso7SkmBdefRP/gMBrumYF+RfZsXkjRw8fRKPR0H9AOr2SU6itqeb44UNUlJeRmjaQMRMmkpqW3iWAr6up4Z9vv8aZzNMsuGkxib16I5VKadXp+ObrLyktKeKeBx5m2MjRqNTqHp9bTXUVf/2/x53TLDw8PS8lG+rIy71AUUEe9XW16HQ6ykqKaWluQuPm1qkCQCaTIUGCWqPBw9MTL29vvLx9iIqOJaVfKmnpgwkJDbumvghC91p1Oo4dOci5s2coKSygubmJxoZ69Ho9RoMBu82GAwcSOhIAMrkMDw9PVCoVXt4++AcEEhoWRu+UfvRN7U9IaLhI1AiCIAgiASAIgiC4ZrVaaWpsxGxud47yWiwWcrIzeeOVFzmdcQKZXIZBr7/mfbu5uaFSa5BKpTz+1F8ZM24CVZUVfPP1Ss7nnKW2phoAL29vQkLDmTxtJiq1mg/ffROH3U6v5BR8fHzxDwxEq/XDy9sHlUqFQqlCrVajVCpRqdRknsrg7ddeYurMOdhsNnZt38Id9y5lwqSpKFUqoGOe/qmM47z+0vMMGjqclL6p/OPF55h/w40svuOeHpW819XWsn7NKnZu24xCoWDchEnExifiq9VSU1XF+2+/Tmx8PPNvuJn4xCR8fLVd9ltbU817b75K1umTLLnrPqJj45BIJDQ3NfH1ys+pKCvj8Sf/SkpqfxSXkiLXIu/iBX77q/tJHzKUvqkDOHJwLxfOnaOhvg5dSzMWi+UHfU5kMhlaP39i4xOYOGU6E6fOwD8gQEwV+IHM7e3s37uLr1cuJz/3Ao0NDbS1mX7QvuRyOVo/fwICgxg1bjyLb79LVAUIgiAIIgEgCIIgXJndbqeqopxlH77H1o3raG5qcpaH/6gfBIkETy8vBg0dwT1LHyI6Jg6bzYrRaKS0uIjc8zns3bUDpVLJHfcu5euVy3F392Dpo7/Fy8urY+RTJusy6uxwOCjMz+MfLzyLm7s7aemDWfb+Oyy+4x4W3LS4S3m/1Wrly8+XsfrL5dx1/68oKSpk/97d/PaPT5KWPshlMGu32zEZjezctoUvPvsYi8XMhElTSR0wEE8vb+c5GY1GXnzmSYYMH8GDv/4dVouVluaOcu6IyCjUGg1NjY188M4b5GRnccvtdxETF+9MCnz9xXJaWpp46rm/E5eQ9INH2K1WKxvWfs3fnv6zc5nGHxr0d3cvNRoNCb36cMc9DzBizFg0GjeRCOghh8NBWWkJ77/1Gju3bUHX0tylB8OP4R8YyD+XraRXn2RxsQVBEISflKg/EwRB+C9iNpvJOHaY5//yJPkXL/Q4GFQqVVgs5k7d+F0FPbqWFnZt20z26ZPc99CvmTF7HqFh4YSGhTN0xCgGDBrCYw/eS11tDcl9+3Fg725qa6oICAzsdp9VlRV89tH7tLWZGDh4CCuWfcj0OfNZtHgJMpms6w+TXM6cBYu4mHuelZ99wq133Ute7gU++/if+Gq1ztF46JiT3dTYQE52Fis+/YjKinJGjrmO0ePG4+Xt3WXfbm5uzLvhJj585w3q6+rIOpWBxWpFdimQj4lPAMDQ2sriO+4mOjauIxgsKWb9mlXI5QqeeeEfxMTF/+Bg2mAwcOTgPt54+QX0ra3X9FqpVIpCoUQqldLWZuo2KHU4HBiNRrJOZfDoA3cxedpM7rzvQXolp4hpAT0I/ktLinnp2afZvWNrjwJ/uVyOQqHEZrdhbm+/6vMt7Vf+LgqCIAiCSAAIgiD80oP/9nZ27djKi888SU11VbfPU6pU+AcEYrfZMBj0TJo2E63Wj9ZWHW0mEy3NzZzJPk19bW23+6irreGlZ59G19LMzbd9O0+9T0o/kvv2Y8/O7UyaOgO73U7+xVySeie7nNPc3NTIZx+9T97F8wwbOYZ9u3eS3Lcfdz/wK5fB/2Xu7u4sues+nnz8N+zbvZNR48azfs0qli/7kDvve5DgkFBamps4lXGcPTu2kXv+HAlJvVhw4y2EhIVf8Tr265/G+ElTKSkpYsac+cTExaNxc6O6qorS4iIA+vZPIzIqGolEQnVVJWtXrcTHV8s9Dz5M7KUkwQ/R3NTI+rVf894br9LU2HDFQN/L2wdfrRZfXy1e3j7o9a2UlRQzcPBQIqNjqKupprqqksL8PGqqq7oNKO12Ozu3b8HL24dHfv9HPD29RBLgCtrb21i3+iv27trebfDv46slLDyCoOAQvLy98fD0xNvb51Ljy3osFgtNjQ3oWlqcS2PabDZxcQVBEASRABAEQRCuzmazsXfXDl5/6flug3+FUklAYBBWi4Wx4ycSFBzCqi8+59Y77yEhsZfzedVVlTz1x99SX1eL3Wbj4oXzLoNHk8nIR++9hUql4qZb70CpUiGTyZg9byEvPPMEk6fNJDwiklMZxxk9bnyX+cytOh0f//MdThw7zPiJUzh/7iw+vr7c99BjqNWaq77nmLh4Hnz0tzz75J/Qav2YPH0mm75Zw9uvvsSoseM5fGAfBXm5hEVEsODGW0js3afHjdWmzpyN2WzutGxfYFAw/fp3XZov8+QJ2kwmHnjqMed0gB9C19LCmq9W8sn7b3cb/MtkMqJj40jum0psfAIBgUEEBAbhq9XS1NjI8mUfEh0bx+33PIBaraa6soKz2Vkc3L+H3du3utyvWq3huklTGDx8BI319UglUucSj0JXtTU1fP3FZy4Ddjd3d4YMG8m4iZNJSOpFeEQkWj//LtfSYrFQX1dLY0M9VRXlFBUWcP7sGTJPZVBdVYlMLhfXXxAEQRAJAEEQBMG1nDNZfPrhe5SVFHcb/N/9wEMMHjqcTevXUpifx9ARo/DzD2Dnlk2dEgCenl40NzYyaMhwystK8fHVkp+X67IioFWnY8WnHxMWHsnEqdMBGDBoCAqFkvKyUuITk9iyYR319XWdEgBNjQ18+O6bHNy3l3k33EhRfj5Gg4H7H36MiMioHr/vgYOHctNtt/PFp58we/4Crr9xMevXfMXKzz/B28eHmfOuJzomDjd392sKqBRKJYoeLi3Y2NBAWETEjwr+LRYLB/buYsWyD6mvq+v2ef3SBnDTrXcQGByCm5tbp20+vr4k903l8IG9zJx7PVHRMYRFRBIaHsHAwUMYMXosr734HCWXqhgAkvumMnv+QgYOHoqvVovJaKShvq6jMeM1rFzwS3L88EGX90ilUjNt1lzueeAhQsLCr1jBolAoCAkNIyQ0jOS+qVitVupqaygtLiI78xTu7h6EhoeLiy0IgiCIBIAgCILQWUtLM5vXf0N25imXI/XuHh784YlnmDpzNhqNG4FBwTz31J/YtmkDg4cO5+jhg8xfdLNzzfm62hoaGupRqVQ0NdSz+I57CAoO5uH77qSutqbL/ivKSlm7aiVJfZKdZfFGowGJBOISkpDL5dy/5GbCIiIJCg4hOiaWvIsXKMzPZ/Edd1NbXcWZ7NPc88DD9Os/wGXg9P1S68v/XyKRMHn6LGprati4bg23LLmLO+9/EKvFilqtvubA/4dQqdQ0NtZjt9t/cOl8cWE+H7//DpUV5S63h4SGMXrcBPbv2Ulrq46omNguz5FIJPQfkM6h/XvZu3Mbt911n/Nx/4BAJkyeRkhIKL9eeg8Wq4VJU2cwaeoMwiOjnJURao0Gg15PY2MDwSGhYhTahX17drl8PDgkhNvvvp/wa0hgOf/YkssJCQ0jOCSU1AEDkSBxrnwhCIIgCCIBIAiCIAAd87czM06wYe3XLjv9e3h68ujv/8zMOfOdAUV0bBz3/upR/u93jxITG0d7WxsH9u5m3sIbcTgcHDl0ADc3d4xGA/6BgST37Ud4ZBQvvPoWv3v4/i6jnw6Hg2OHD7Jv1w5mz1/Ijq2bUKnVJPVJxtvbhyV330d5WSlNjY3U1dZwKuM4vlo/HvrN76mtqWHl8mXMvX4Rib37UFlRjs1qxWr9tuN9fX0dLc0dXdZtViuNDfXodDoAZFIp5WWlNDc10dTQwNFDB5h/w014e/v8ZPcgPjGJDWvPUFJU+IOqAIxGAyuWfcy5M9kut0dERvHnZ55nxOixvPfmq6z8bBm3LJGT2LtPl2SJr1ZLatpAdm7dzC23391pu1wuJ3VAOht2HcBoMAB0mRIgk8nQaDToWprx9vHBzc1dfMm+p6qya5JGJpMREhb+o6pALidrejL9RRAEQRBEAkAQBOEXyKDXc+jAXpdzu+VyOdNnzWPilGldRhMHpA9m4pTp7Ny2mYSk3uzevpXAoGD0+la2rF9LSGgohfl5jB43nqCQUKCj/PyW2+/mnddeob29rdP+TCYj+3bvoLKinCMH9zN63ARnEB4SFt5t4701X36BUqni2JFDnDpxDIlEgs1uo6W5+VJgJUelUjlH1mVyGWr1t6Xv7h7ueHp64avVMmzkaAYPG4Hme6Xx/25RMbFIZVKOHj7YaQWCniotLmbzhrUut7m5uV0q0R+CVCrlliV3UVtdzeYN36DWaDqO/b2qgz4pfdm8YS3lZaVERce42Kc7bm7u2Gw22tvbaTOZcPfwcJ63QqlELlfQ1NAgEgAutJlMLgN3iUTyo6pABEEQBEEkAARBEIQramluYv/unS63RUbHMHHadPwDAl0GLAtuvIVN69YQGByMQa/n0w/fw2q1EhUTi5e3N2ezs0gdkI5CoXAGjqPHTWDPzu1kncross8TRw+ja2lh6szZDB0+skfnP3HqdAYNHeYMPqVSGZ5e33ahlysUuLu5I700kq1UKp0rDvxcuLt70KtPCtmnTzJ15mx8fHyv6fVbNnxD66WKhu+LS0hi9HUTnIG4h6cnt9/7AG+/+nc2rV/L3OsXERoe3inpEBUdQ3BwKIf373WZALhMJpPhq9VSUV6GxWzulCRSq9UYjQbMZjPKHvZC+KXQaLommKxWK7U11VSWl/2gKQCCIAiCIBIAgiAIwlWVlhZTXlbqMrhLSx9Mv9QB3b42LCKSqJhYTEYjixYvoamxAYVSiVbrx/JlHyKTyWior2PLxnUY9HosFgt5uedd9gGAjkZ2qQMGMnjoCOSXkgZXk5DU6992bcztZpqaGmhpbqat7duKBalUgqenFwGBQWjc3H70PHeFUkF0bBwH9+6mvrb2mhIAFouF3Tu2IpVKu/RvUKpU9Esb0KlBo0QiITwiktvveYB3Xn+FL5cvY/HtdxMQFAR0TAkpLSnGV6sl49gRbrz19qsGs56eXrS26jolAOQKBQ6HA5PJKBIA3xOXkEDOmawuj1dVlPPem69y2133ERufICoBBEEQBJEAEARBEP61LuTkuGz85+Orpf+A9CuOll8uW3Y4HB3ryWu1zsDZZDSSffokL1dX4eHRsQ+VWo2XlzfxiUkY9Hpampu67LO5qQmb/addz9xms9FYX091dSWV5eXUVFdRVVlBbXUVFosFi9WCw+5ApVLhHxBITXUVDocDtVpNdFw8w0aMIi198BW7tl/1HKxWJBJJj5cZvKwg7yLVVZUu76Gbmzu9+qR06cYvlUpJSOrNQ4/9gReffYoP3nmDu5c+jH9AAHm5F1jx6UcUFxagUql5/i9PkD5kKOmDh+Ljq3X5GdBq/WhqbMRisTirPSQSCTKZHJPR+JP2U/hvMGjoCNav+brL40ajkU3r1nIq4zipaQMZOfY6Bg4aQlBwiLhogiAIgkgACIIgCD+eq5FIAK2fP31T+1/19U2NDfRJ6dfpMaVKyYO//h2Oy0Hpd0bIJRIJFeVl1NVUu0wAFBbkYTa3o9H0rJGZw+HAaOgoNb8cBDscDhob6iksyKO6spK2tjaMBgP6Vh0Oh8OZuADQ61vRt7Yil8uRyWQEBgUTFRPL6HHjiY6JJSo2jsCgYGfZ9uWER2NDPefOZpNx7CgrP/uEjOPHWHTLbfj4+l7zPdC1NHP86GHiE5MIDbu2pdvOZmdisVhcbvP09Oz2HkqlUmLjE3j+lTf46xN/5NUXn2XhTbei07VQV1OD0WDAaDDw+cfvs/yTD1CpVCT27sPQEaMZMXosYeERaNzc0Kg1yBUK1Go1FrPZmQCAjioSs9ksvmTfM+a6CUTFxFJSVNhlW1ubiaKCfIoLC9iw9mukUile3j4k9upNQlJv4uITiIlPIDQsHJVKhVqtQa3R/KjkkyAIgiCIBIAgCMIvRFlJscvHPTw9CIu4+lzk9CHDuZh7nnETJqNUKTsFf3wvKLFarbQ0N2M0GJBKZchkMmy2zqP99bW1WNp7HjRWV1WybvUqWpqbsNk6VjGw2zu6/Wv9/AgICsZXqyU4JAyVi2XRgkJCcHf3IDgklMCgYNw9PHp03OCQUIJDQrlu4hSmzZrDy397hg1rVzFr3gK8r6GEv6mxkT07t2HQ65k0beY1L91WVlL8baLle1RqjbMBY3d8fLU8/beXeOf1l1m7aiXuHh6Y29ud2y8nVYxGI5knM8g8mcH7b71GaFg4/dIGkpo2kNj4eORyBSq1utOUCKlMht1mE43tvsfbx5f7fvUorzz/126nwzgcDmw2GzabjYb6Oo4crOPIwf3O7Vo/f+ITk0jq1YfUgelERccQFR37s+tvIQiCIIgEgCAIgvAz0tTU6PJxtVqDWw+64U+cOp1n/vwHKivKiI6NA6Chvp5jhw+gUCjR+vkhlcpobdVRW11NdXUlbSYTdbU1SF0kAJoaGzi4fw+z5i3oUdC4e/tWWpqbWHDjLSiVqkvnriY8MoqQsLCfpAt9rz4p3LP0Yd5/+3W2b97E1JmzexSI1VRXsX7NKlp1OpbcfR8p/fpf87Gbm5uQSmVA1yoAjUaDWqW+6j7cPTy471e/Jiwiiq+WL0Ovb73i8202G2WlJZSVlrBp3Rq8vL2JS0gkMakP0+fMIzIqGugo/HA4HCIB8D0KhYLxk6ZiMhn54tNPKMy/2OV7cDWNDfUcP1LP8SOHWPn5J0TFxDF63HUMGT6KfmkDxLQLQRAE4T9GtvTR3z4lLoMgCMLP04fvvOlc0/0yiURCQlJvps+ee9XXy+Vy9uzcin9AIBGXupfv3r6Vg/v2IpVJyT1/jpLiQpqbmtBo3OiXNoCRY8bRqmuhtqaGtjbT94IjJYUF+aQPHoaXt/dVj595MgMccMd9S0npl0p8YhKNDQ3UVFcSHRv/k5RGS6VSAgOD8Pb2Zs/ObTQ1NZKY1Mu58kB3tm1cT1VlJY89/n8MGjr8B53rtk3rKC7M7zINQCKREBufyIw585D1oK+AUqUiPjGRpqYmzmSexmq19Pgc2tvbqa6spDA/Dzc3d5J6J6NQKLDZrNjtdry8vUWJuovrHRufQFKvPqjUamqqq7p8D3vKbrfT2FBPduYpsk6fpL6ujtCwcLx9fH90g0pBEARBuFaiAkAQBOFnrLsAoaeN+JQqFSGh4dRUVzkfq6mqJDVtAPc//BgGgx7oGJX38PDE3cMTpVLJyePHkMu7BoVqtRovLy8yjh8hLCLiqse/buIU3njlBV74yxMsuuU2FEoVf3/uadrbTKjVaoaPGvuTXEeVWs2oseOx2ey8/drLWK1W5l6/qNO0CPi2tFsul9Pc1ISfnz9JvZN/8Ai5VCrD4XB9Xx0OO3aHvcf70mjc6NU7GV8/P0zlxms+F5PJyN5d20kfMpS+qWk4HB3nIUb/XXNzc2fQ0OEk9urN9TfczK4dWzm0fy+553Job2+75v3ZbDZKigr5avmn5J7P4fEnnyE+sZdIAgiCIAgiASAIgiBcCkLcu5bIOxwODHo9NpvtqiO3arWa2Lh4zuecpa2tDbVajdbfn4rysis2tNPrW50BouM7EaxKrWby9Fkc2r+HsRMmdVvKbG43s+Gbr9m/eycGg4H9e3Zx/MghrFYr0bFxmM3tlBQXM3zUT3ctVWo14ydPRevvz3NP/pGzWafpndzX2RiwuLCQ3PM5eHl7M2XGbAYOHsrnH7/PB2+/zpwFi/DValGp1NcUsLl7eLhM1tjtdowGA1aLFdQ9fw9jJ0wiLCKSjGOHOXLoABdyzmIw6LGYLZjN7Z3ulSulxUUcP3yIuISky5kIkQC4AqlUiq/WD1+tH/FJvbjj3qU0NtRxISeHnDNZnMk6TXFhAUajEZvNitVixWq1YLVar5iIOXb4IL9/ZCnvffKFc4lHQRAEQRAJAEEQhF+44JBQigsLujzeZjLRWF9/1eBBKpHi5u5Oe3sb5vZ2pBIp3j6+nMk8jdlsdrkGfFubCaPBQHt7W5eA0lerZea868k4foRVKz5j/KSpBAYF4+bu7gyM29va2bd7B1mnMrjnwYe5kHOWrMxTLLjxFjQaN1RqNf94/q/EXOpJ8JP+6MnlDBoyjA+Xr2LjN6vJzjxNzplsHA4HcfEJzF24iOLCArZuWs/0WXNZtHgJm9atZcfWTYwYM47RY8cTG5+A1s+/R4mAoOCQbpsAtrQ009BQf02N4RQKBX1S+tInpS+33nkv+tZWzmSd5mx2JtmZp6koK6G5qYnmpqYu0zcuJ4+OHz3EtFlz8PTyRqXq+OG0AAAgAElEQVRSiRHoHlIqlSiVStzd3YmIjGbi1OkAmM1maqurKC0tJv9iLufPnqEg7yJ1tTU0NtS7XAXC4XBw4VwOn3zwDo89/sR/VRKmva2NqqpKDJd6UYRHRnVKBOpaWigvK8XhsOPm5k5IWBhqtUZ8gARBEEQCQBAEQbia2PgEjh460OVxXUszBfkXr5oAaG3VcfTQAcIjo2jV6di/Zxe553M6Kgu6GS2uqa6msaEek7FrmXlEVDQBAYE8+vs/s/yTD1j52SeERUQSERWNWq3BbrdRXVnBuZyzXL/oFubMv4HT0bGcPnkChUKJRuPGhrVfk9QnmeS+qf+x66r18+fWO+91fc10OhrqO+Zs33DzbST1Tibr9EkyT2Vw+sRx4hKTGD9pKiNGj71qBUZ0bBwymdxlEGgw6Mm7cI7IqOgfHIR7eHoybORoho0cDUBxYQEXL5wn4/gRdmzZ1Gnqx2UlRUXodDrc3N1Rqb3Fl+xfkBgIj4wiPDKK4SPH4HA4qKut4eSJYxzev5cDe3dTW1Pt8rWb13/DrXfeS1BwyH/N+83Py+X1l56npKgQm93OLUvu5La77nNu37R+LZ9++B44HISEhbP00d8ycNAQ8UERBEEQCQBBEAThanr1Tnb5eGNjAzlnshkyfOQVg8emxkZKigoZMXocB/buorKigt7JKaQPGdbtknZF+XlUlpe57HyeeKkp2sBBQwgNDSPr9EnO55yhpKgQg16PRCJB6+fHDTffyriJk1EolWjc3FAolGxevxaTyYiXlzeP/O5PeHp5/SyvuaeXF7Fx8eScycJg0BMcEsqI0WNJTRtIUWEBWadO8NY//o5MJmPE6LFX3FdKv/6oVCqX1RR6XSsZx48xfPTYf9lqCNGxcUTHxpE2cBB1tTVs27Shy3Pa2kw0NTYQGBSE5idYheGXRiKREBgUzNQZsxk6fCSpA9J54+UXXC4p2Nqq4+SJY0ybOcf5mN1u5/CBfWSeykACpKSmMWT4iJ/NKHpVZQVnsjIx6Fux2+0cP3K4UwLgdMZxaqursdqsNDTUU1JUKBIAgiAIIgEgCIIg9CgBkJyCQqnEYjZ3etyg15N58gRVlRVXnMuvcXPDw9OL40cPU11ZwT1LH2boiFG4e3i4fL7RaCA78xQ11dUuA5u4hETkcgX7d+9k/95d4HCQ2LsPs+ffQH1dLWezM6mpruJM1mkKC/KIjIwmqU8yD/76d+RkZxIaHkG//gOIiYvvsn+bzUZe7gVyz+dQVlpCc1MjDoeD8IhIomPjSOmXRkBgoMvzzss9z5qvVtLe3kZEZBRTZ85BJpOTdeoExUVFVFaU4e7uTmRUDAMGDSEmLv6KZdf9B6azddMGNq//hsW334VCqcTTy4t+/dOIjYvnkw/eZdvmDVdNAAQGBdMrOYXjRw65DMSPHzlITvYU0ocM+5eW4re1mzCZTN1uNxgMyGRyNBpRmv3v5Kv1Y+ac+ehbdbz416e6bLdareTnXoCZnR974+UXyL1wDqlESmLvPsTFJxB+aRWP/ziHA4fDgcVi6fY75HA4UMjlSCQSMcVEEARBJAAEQRCEngoMCqZfahonTxzr8gf2yRPHOH7kELPmLej2D3Gtnx8Tpkxj+ScfMHXmXAYOHtLtyLvD4SAv9wJ7dm5z2eU8LiGJyKhoHA4Hb/zjRUqLi5BKpezesY209IOcOnGctjYTNpsNqVSK41Kg4OHhyaChw7n5tjvok9KvU+WBw+Ggvb2Ng/v28OkH71GQn+dsZnf5PV3+3z4+vkyaNoNFi28nJDSs03tesexjNq5bjUKhxOFwsGn9WvQ6HU1NjdisVqQymXMEXqVSM2HyNO576FGCgkNcBiix8Ync96tHeOGvT/Lum68y9/pFBAQGYXfYyb+YS3FhgbPs/kqkUikz5szn2OGDLrfnX8xlzVdfEB4ZRXBI6L8kWLJYLBw9eIDMkydcbpfJZLi7u+Pj64vV2tG0rqmhgbLSEi6cO0thQT7VlRVo/fyIio6ld3JfBg8fgVKpQu5iyUK73Y7FbHY2O5TLFbSZTOSez+HE0cPkX8xF4+ZGUp9kho8cQ2R0DAqFAofDgcloJD8vl+NHDpF/MZeWlmZ69U5m2MjRpKSmodFouv1s22w2TEYjxUUFnDpxjIL8PGprqpEgIT4xiV59kklLH4yff4DLXhc/FZVazcKbb+WV5//apTmg3Wajrq7WeR3N5nba2tqoqqrA3N6OXC6nvq4WnU6H0fjtMoRymRyFUolEIsFsNjuXhZTLFSgUCpefI6vVitnc3vEZkMpQKJVdrq3D4cDc3k5+Xi779+yiqCCftjYTQcEhDBoynMHDhmOxWrudPgQwffY8igo6lr5M7NWbvqlpLv+tsVqt6Ft1HDtyiJzsTCrLy2lt1eEfEEh0bByDhgynd0oKCoVSLFMpCIIgEgCCIAi/DD4+vkydOYfszFNd5pE3NzXy1YpPiY1PIKVff5eBkkbjxh33LuWGW25Do9agUnffcr6utoYvP19G7vlzLgPZ4aPGdIxCXgrczGYzFrOZVp3OWWquVmtw9/BAIoG2tjYMej1Gg4FN69aQffokD//2cSZMnuZMAlSUlfL2ay+zZcM6Z9JBoVA4pw3YbDasVgutOh2tOh0fvvsWO7Zs4pm/v0r64KHOQKe1VYfJaMRg1yOTyTh3Jtv5/i8fy9zejslkxKDX8/XKzykvK+H5f7yJf0CgyyB50NDhvPLW+7zy/DO89tLfcHf3wG63YbFYmT57HotuWdKje3jdxMks75PMhXM5LoOyTevWoHFz4+4HHiIkNOxHB/+H9u3ho/feQtfS4vI54ZFRaP38USpVvPHy86z5aiVNjQ3O7QqFAjc3d9rb252NBMMjo7hlyZ1MnDqDoOCQTp+13PPnePXFZzmfcwa5XMHocRM4lXGc/IsXnPfAarWwdtVK3NzdmT57HgtuvIXiwgKWffAeOWeynIkZhbKjuuSj995i8LAR3LP0YfoPHNQpgHc4HDTU13Hk4H4+ef8dzuecdZ63+lJFw95d24GOEfhps+aw8KbFxMYn/scCSaVShUKhdLk6gEKhAOBUxnHeePkFigrzaayvdyY5aqoquXvxDchk317zEaPH8fBvH8fXV8vfn3ua7Zs3IJFImTx9Jksf/a3L1TlWLPuQT95/F6vVQmpaOo/98QmiY2Kd241GAzlnsln2/rvs2bkNh8OBWq1BJpfRZjKx/JMP0fr5Ex4RSVtb98sgtplM6FqaMZmM1Nf5OZcavcxsNlNcmM+61V+xbvUqGhvqkUgkaDQaFAolpjaTM/nRp28qNy6+nVFjx+Gr9RPVBIIgCCIBIAiC8L9NqVKRlj6Y3sl9yc481WV75skMlr3/Lr/6zR86/TH//QDDx8f3isfRt7ayYtlHbPxmtcvtoeERDBk+Ai8v7y7TES4fY/joscTFJ6C6NFe5vc1EQX4eRw8eoL29jbLSEt545UUioqLpm5qGQa9nzaqVbN24nvb2NmQyGYm9+9C3Xxp+AQHfBrVmM+fOZpN1+iQGvZ7SkmKe/8v/8fq7HxEWEdnlXGw2W0flRNoAYuMSkF0atda3tnJg7y5Kigqx2+0U5F3kxLEjTJ0xu9vrEhkVzYuvvk3W6ZNUV1WiUCpJ6tWHqJjYHndu9/D04uYld/HCM0+gb211mQRY/eUKbDYbd9y7lKjomB/0WTEaDRzYs5u3/vF3SoqLXD5HIpGQNnAQMXHxtLWZ2Ll1M02NDUgkEtw9PJDJ5CiUio4ybxxYLGZsNhsVZaX844XnyDp9iqWP/IaYuHhnMFaYf5HMUxm06nRIJBK+WvGpM4ni7uGBXK7AoNcDFowGA6tWfMbpE8cpLirAarUilUpx9/BAoVA6Ew5Wq5XDB/bRUF/HU8/9nX5pA53HKy4s4MN332TjujXOz6JUKkWlVqNSqXA4OhJRl3sdLP/kQ06dOMZjf3yCYSNGXzWItNvtmEwm3N3/df0Rcs5kYTIZXSSa5M4GgFUV5dTX1WJpN3fpF2G1WrDbv01eVJSVYtDr8fDwZOfWzdTX1SGRSNi9Yxu33nGPywTA5vXfUF9Xi9Vq5fjRQ9RWVzn/zdC3trJ5w1o+eOdNKspKnce3O+y4qdzRaDQ01NfT2NDx35Xs2r6F6uoqLGYzRqOR/Iu5pKYNdCbhDh3Yy3tvvsaZzFPO48hkMpQqNXKFnPb2dudnIPv0SfIvXmDewhu5/6Ff46v1Ez8KgiAIIgEgCILwvy0mLo5ps+dSUlxES3NTl+07tm7C4XCw9NHfEpeQeM37r62pZsWyj/j84/ddjlCqVGpGjxtP2sBB3QZPU2fO5tHf/7lLN/PqqkpeffE51q9ZBUBJUSHbNq2nb2oaFeWlHD203xn0SSQSPDw8cfdwx2I2o3Fzc85Rj46NI/9i7qVAEspLS9i3eyc33XaHy2TE5Gkzuf+RxzolPmw2Gzgc1NZUYzQYaG3VUVZS3KMkzKChw3/w/VMoFIweO56MY0fYtG6Ny2tsMZtZvXI5jQ0NzF94I4OHj+hxY0CbzUbu+XNs27Sejd+spqqyotvnhoSFM/q6CQQGBWM2m7n+xsUUFeQRFBKKzWqlqrKChvo6mpubsFk7mrg11NU5p2rs2r6FyKho7rh3abdTSdRqDUNHjCItfRC+vlpkcjlNjY3s3LaJzJMZQEcnealUypDhIxkyfCRaP79LCYA2dm3bzOED+4CO6oItG9fTO7kvSpUKXUsLq774nM3rv8Hc3t6xLGLfVIaPGkNQcLBzCohe38qpE8c4tH8vBr2eC+dyePe1VwgNi+g2UXbZ+jWrOHc2m7T0waQPHoZ/QMCPGnkuKsjn3Tf+4fqPMIWc+MQkAEaMHovGzY3mxkb+/tzTtOp0yGQyvLx9uPXOewgI/HbFj/DIKELDw7FZv23UKZVKr3qecrmiy+fParVy4thhPnznTcpLS4COqo3rJk2hd3JfvLy9kUqlNNTXkZ15mkP79rhcYrLTZ14u75IodDgc5F28wBsvv9CpGmbwsBEMGzkaPz9/ZHI5ra06yktL2LppPfW1tRgNBr7+YjmpaQOZPnue+EEQBEEQCQBBEIT/bWq1hinTZ5GTncXWjeu6TAWwWq1s37KRhoZ6Zs69nvGTpvRopMxkMnL8yGHWfLWCQ/v3YnSx7J9EIqFXcgo33HIbPr5al/vRaNxYeNNtBAYFd9kWFBzC3AWL2L55I21tJqRSKdmZpwFobmqioqyscyBy9DAnjh52Bs4KhQIkEnA4MH8noDC3mykuKnB5vm7uHsQlJnapepDJZLi5u6NUqjAaDNisNtpMpp/kHvoFBHDzkjuprCgn49iRLiO80DHyvGfHVvIunGPQsBGMHD2O/gPTCQgMcllt0N7WRsbxoxw+sJeMY0e5eOG8y94N301kjJ84haHDRzqv7dwFN3Bg7x4yjh+hpLCAhoZ6rBYLDsB2KVB09/Cgva0Ni8WC1WLhxNHDzFmwqNsEQGR0DH948hnCwiOcJfdWq5Wg4GByz51zjoQHBAbxp6efIzo2rlNvgfiERGc/CYDMUxlYbVaUqCgqyOP40UPObVKpDJVKRXNTI0aDodO1tNvtKBRKZ/BZVFhAxtHDV00ArPzsE3LOZLFr2xbiE5MYMGgIQ4aNILlff2e5fk+0tZk4cfQIy5d96HIpTwAfXy0DBw8FOpamnDB5Gub2dt545UVadbqO75ebGxOnTHfZONNVRcm10rU0s33zRsrLSp2P3XjrEm698178AwI79eIoLizAw8ODdau/uubj2O12tmz4xjnFSKFUolQqefzJZ4hLSOr0GdC1tBAWHsGLf30Kh8NBW5uJLRvWiQSAIAiCSAAIgiD8MgQEBvHAI7+huqqSk8ePYrfbu/xxnXHsCLnnc1jz1QqGjRzD0OEjSUsf3CV4LC0uYt/uHRw5uJ+z2Vm0NDe5XPIPOpoQ/v7PTxEX331lgdVmRaF03XhMIpGgVqudAe93n+O4VGZ+mUKpJKSHjfA8PL0YNXa8y20ymQyZzPXPW6fj43AZiP87SKVSevVJ4cFf/46/PfUncs+f6zYJUFpSTFVlBbu2bcHdw6NjnfmISBQKpfP8jUYjleWl6PV6Wlt1mC+VTXfncun/osVL8L6UGNG1tPDaS8+ze/tWdC3NzsSSVCpFqVQhlXa9D7JLTenauxkBlsvlRERGERkV3eXxwOAQVGo1JpMRiUSCf0Cgc/T7u4JDQ/H08qKtzYREIqGluQmHveNa1dXWUFtd9W0SpL2N0ydPkHkqo8t+HA6HM4kBYDIaqP7Oa7tPjHU0sqyqrHB+31Ys+4iQ0DAGDBpCUu9kevXpQ3RMHIrvNRe02+0UFeRx8sQxDuzZzZmsUzQ1Nnb7/Zozf+FVp+f8uxkMevIuXkAmk2G1WlGqVNxx71K0fv5dPkNRMbEMHzWGHVs2ukwYXonNZiPr1EnkCgUWsxm1Wo2vr5aY2PguzSW9vL0ZNGQ4fgEBNNbXX5qykyt+CARBEEQCQBAE4ZdBIpEQFR3DP95+nz8+9hDHDh/qMtrrcDjQtbSQeTKDzJMZvPPay87AOiAgEJ2upccjhgqFgpi4BP72yhv0Tk654nMtZjN/f/ZpnnvpNQKDQ5wN2ywWCxXlZbz+8gvOc7Xb7QwdPhIArb8/0dGx1Nd2dEFXqVQ8+vs/M3jYcDw8vTqNttpsNtra2mhvM2E0GPD28e12BPpn+4MrlzNoyDBefvOf/OXPv+f0yRPdBu4Wi4XmpkaamxqBjjLyH0qhVJI2cBC/+/PTnUaRP/von6xa8Zkz6A8KDiEgMIiwiIhOr29pbu40gm13XDlxIpPLuv0MfzcBc6UeCp0SNd9JdkmkUiSSb1/n7uFBv/4DUX1nZYnu+AcGMmX6rGu6dg6HA6PRiNFopK62pksfDqlUSmBQMBo3N+pqa3r8/ZLL5QwfNYY77lv6L0kuffd8u3sfl1cA6PJ6iRS5XOF87eXVGfDrbj9mbDb7D/o3TKlSOe+n3W7HarN1e84WqwWrxercLr+G6gtBEARBJAAEQRD+J2j9/Hn+1bd4741X2bV9C5XlZV2qAVwF6JUV5T0+hp9/AMNHjeHO+5aSkNS7R6/JOHaE3z3yADPnLiAsPAKHw0F1VQVrv1rpDJokEgl9UvoxdeYcAMIjIrlu0hTyci/Q0tKMvrWVJ/7wa8ZcN5H0IUMJCg5FLpdjNrfT0txMaXERpSXFnDubzez5C7n3wUf+K+9hTFw8L7/5Hm+/9jL79+zq0T38oQKDghk3YTIPPPwYAUFBne/Z8aPfSfgoWfrIb5h9/Q3OxIvJZKS0uIgVn37sTAD8VF3YuztOSGg44ZGR1NXWAKDRaJg6YxYjxowjIDCoy0iyyWSksaGBpsYGIqKiXTbH6xpQ9/w92u12qqsqr+m9uXt4MGzkaH712O9RX2qY6Spp4zyGzYbFYnZ9naRSfLVaqqsqsdlstOpaKC8rJTQ8wpkY0Le2kn/xAlWVlc7lAr/Lw8uL1P4DyMnOdP578coLz3Lvgw8TFR3rXDnE3N5O5qkMdmzZeMWpJldKVAwbOdo5xafNZMJqsXLi2BFS0wY6E3oOh4Oy0hK2bdrgTIABpPTrL34ABEEQRAJAEAThl8fHx5cHf/07Bg4ewo4tmzhyaL9zFP3HcHN3J33wUMZPmsq4iZNdLo/XXbDmcDjIPJlB9ulTuHt4dIycGgzOwFalUtN/YDp33LvU2blfo3Fj6sw5mIxG1q/9mpKiQlp1OjZ+s5qN36zGw9OzozGcydSlg3r26VMuz8XhcFw1mLbZrD+LRM5jj/8fw0aOZs+ObRw7coiqivJ/WSJAqVLRLzWNuQtvZNK0mS472n/3/los5o6ma/V1+Pn5YzIZqaqsJDvzJGezMn82n/3o2FjGXDeRgryL6FpaqK+r49W//41DB/YSE5dAYFAQcpkco9GAwWCgVaejoryU8rJSZs9fyK133HPVY4wYPZbGhgZnkuFfRSaTEZ+YxPjJ05g1bwERkVGup81IpYSFR1BZXobNZqO5qYnlyz4iIbEXckXHn23RMXGkDhiIQi4ndUC6cynEVp2Od15/hdMnT+Dj44vJZKK6qoLjRw7TqmtxWXXh6enF5OmzyDyVQc6ZLOx2Ozu2bKSmqpLBw0YQGNzR26O6spID+3aT62I5y56+/4lTZ3Ds8EGOHjqAzWbDZrPx7BOPM2rceKKiY1EqlTQ3N5F16iSH9u91vtZX68eMOfPFP/6CIAgiASAIgvDL5O7uznUTp9Cv/wAunMvhxNFDHNi7h6LCfJfL9HVHeinYSEsfzOjrJtAnpR/hEZFdRlKvlji44eZbycu9QGlxEaZLjfXc3NwJCAwiMiqa1IHpDBsxiqiYuE5rugcFh3DzkrtIHzKMzFMZXDiXQ1VlOQ11dc7lwBQKBV7e3v/f3p3FSHZWBxz/3/1WVVdVL1XV+77OjGc8i2c8NrZZDILYJMYChRCJREThIUKKEilIvEVCeSAv5CGR8kIkJJS88BQRSExAgRCMAxg89oynZ6anl1l632u/ax6q6rprunvcNsTr+T3N9HK/u3XPnPOd73xomkYmm6N/cIhnf/8Pms7hkcee4NrVK1QqFQYGhxkeGTvwXE+cepDhkTE2NtbpyGQ5efrM2/YMY7E4H/nYJzh99iFuXJvmlUu/5uc/+2nUl+HNMEyTsw9d4IkPP8mjj3+Q4dHxpvu916c/+4e88tKvuLUwTxAEPP+TH/PCT39CSzJJtVI9cJbX9zyCQ9az15Ir/pHO86i9F+79ung8wac+81lUVeOfv/kNVpaX2NxY57nvfgeAlmQSVVX3nb+qqlwZv3SkMf/4T/+M8xc/wOzMda688jLXp68yd/PGka/tXul0K8dPnuLiBx7nwsVHGR2fpCWZvG+g/PQzz3L50kuUyyXK5RLf/pdvEYvFUbVaAD8+OcVXv/Z1RsbG+eQzn+bSr34ZJQF+8cLz/PJ/f0YsHsd1nKamoQclAFRV5cTJU3zpL7/MN/7x73npxV/geR6/+uXPufTrF4nF48DBDQcPS1i53sFJtt6+fv78r75CKpXmRz/8T8rlEgvzc9z65j9h2zEMs7Zl5N573TcwyOe/8EXOPHRefvELIYQkAIQQ4v2rsf4419nF2Ycu8JnPfZ71tVWuT1/lxvSrbG5usDA3S7VaxXVddE1D03UGBodJpVNMTNWamXX39JFubaW1rf3Ie9s3/UOiGzz9zKdp7+igXCo1/efdtExisTjJZCoqJb5XKp3m/MVHOXn6DIV8nmqlguM4+4ILRVEwTRM7Ftu3y8EnPvkM5y5cJAwCTMsie0j1wqOPf5CJqWN4rodhGGRyubf1GSqKQkcmS0cmy+lzD/G7z36Grc1N7t65xfzsTWauT1MsFFmYm8V1HTzfR9c01Pr2cNlcjng8Qa6zi5GxcSamjtPW3k5be/uh5eUN5y5c5Gt/9w/8x3e/w4s/f4GN9TW8enWEoqjE4nFGx8b52FOfZOnuXX7w3PdQFIXHP/QROjLZ6DhjE5NceOQxpl+9jK7rfPyQdfbd3T088eEno6UHh83optKtfOx3nua/fvB9AJ76vWeb+kHkOrv43B99gQ8++VF+/MMfMHN9moX5OVaWFvF8jzAIqVQq9XdTp7unlzMPXeDzf/LFIz2TbC7HEx9+kouPPkY+v0uxWKRYKHD1yivMz86wsb7OyvIS62tr+L6H79XWqWu6jqIoDA2PkkylGBoZpX9wiMGhYdo7MrS2tRGLxY/0c/2Jp58hmUrz/H//iJkb19naWMff8/MwNjFFMpVCVVUeePA0X/3br/PD5/6dF57/CavLyzj1JQNaMoVt25w6c45cZyff/96/EYQhZ86dp6e3LzqeZds88tgTjI6N1xJBz/8PN65Ns71dK8EP/IB43OfUmXOcPf8wVy+/wvVrV+vP51NN5//Rjz/F1SuvUKlUGJuYZOr4iT2/K3SOP3CKr/z13/DUM89Gu1fM3bwRvXumZdGabmN8coqTp89w4eIHGBodPfK2mEIIIV7n/x6vLqyEchuEEOK9Iaw3aAuCoPbnA2bolHqQr6rqkfYOv5dTrfLMxz/E4p3buK5LurWNb337Xw/s6C7e/HNsbGUHHPgc2dNUT1GU6Hm+0XF836+Nc0BzP0VV0TStdj71xI6qaWiaFo0dhiGe50XnqBvGgedx79dpuh5tE3gvb0+lgapph1akNM49DMN95x8SolC7R4qqotcD9Der8TwaP2McUsWw9+er8Vx+k/Eaz+beMfZeT+N98X2/6T5E70f9XBr39H73o3GcsHFfD3gfgiA49HkHQYDXqDpQFAzj4B1C7vfuNZ6ZWh9PCCHEb49UAAghxHtIo9P6mw06jjRGfdnA5sY6lm3T29+PeYQu7OKNPUetHmj/f49z5OUe+uFbKxpH6NB+1K+rDaUfOt5eb8U9angzCZa3arwjvy9HuKdHGfd+46iqeqTfB2/o3RNCCCEJACGEEG/TPxy6zpf+4su8/NKLAIxPHaOzs0tujBBCCCHEO5wsARBCCCGEEEIIId4HVLkFQgghhHgv2tsPQwghhBCyBEAIIYR4Vwa2TrWK5/u13QFcF03T0HUD3dAxDLOpUd/7UalUZGVpiXKphONUsewY7R0ddGSyb8va80YSIgzDpuaNQgghxFtJlgAIIYQQ7zJOtcrM9WtRh/wg8FFVDadaZWdnm1gsRq6rm1xn1xsKdhud2fd2kW80fPM8L/r7UQLXvV3/DdPE9318zyMIA1SlVoCoG8a+hnKN5MZhn290mfcDnyCod+NXFBSl1oDOsux951csFJi+eoX11VVGxsfp6x/AtmOHXofnebiug+/5tXF8v95cU6uNYdtRQ0PXdSmViuiaTiweb2qg1ziO4zi49a0tXdfFNExUTa03zLOJxWJvaYNBIYQQ719SASCEEOK36t4tyGI2ZXQAAAuQSURBVBofa8x8HrYlWCPAvN+Wb57rEhKiqhqmad73PIIgwHWcWhBaLwVvBJOarqFpelNX+kqlTBAE6Jp+YBfzaqVCpVrBMAxisXjTdTjVKtVqFT+oBYoKCrqhY9sxAPL5XcIgIB5PRMf2fZ9CIY/nurS0JLFse9+Y+d1dHKeKHYuTSLy2D7phmgwMDddm/z2fIPCj3R8SySRzMzdYW13FOGuQyeVeN2APw5BiocDOzjbVSgXDNKIgXdVq93pzcwNd0+nu7Y2u634qlTJ3b9+mUimT6+zCqVYJ9mz3VioWMU2TjkyGREuyKaC+tTBHqVhkcGSU1ta26HmWSyU2NtYpFgrR9nLa3vclDOkfHNqXNLBsm1QqxeKd28zNzERfd9B17O7ssLqyTKlUxLIsNK12fFVVUTUN3/PIdXZF51vI73L55UukUikmjh0nFosThiHlconlxUXyuzsYholpWdGzd8J69YbjYNs2ZnePJACEEEJIAkAIIcS7RxAEbG6ss7a6SiaTpSObRVVVwjBkZ3uLleUl0q1tZHOd+wK0/O4ud24tEE8kGBwe2Rewuq7L6vISa6sr+EGAZVmMjI0Tjyf2nYfneeR3d9jc2MBxHAzDiPYqD8OQsL7PuWmZ9PYNRIHXyvIyS3fv0D84RG9f/75rW1tdYW72Jn39A03nmN/dZX7uJq7j0pHN1pMc1IJ6yyYMQxbmZinkdxmfPE42l6slADyPO7cWWF1Z5sTJB8nZ+3dSWFle4vatecYmJqMEgO/7rK+tcmthHtu2SaVbsSwrmjmvVsr4gc/O9hY7O9u0ZzKvuz1cIZ9n+tXLFAsFRicmogRHEIQ4TpXlpUXmbs6QSrfSnskcKQHgOA53bi2wtbUJQGdnN6ZtoWs6nu+haxq3by1w59YCQ6Nj9Pb115I/Ycj21hZra6t09/Y1neP1a1cpFgr09vWTyWYxTAvDMAiDAM/38Tx337sThiErS4vcvrVAV08viqKwMD8HisLQ8GhTEqhaqTD96mW2NjcZHh2lt28AOxaL7l8YhriOg7rnfoZhSKGQb0pIua7L7YV5bt64Tq6rm97+AVqSyXo/gvr3BQFBEBCEAYHvwxG3SBRCCCEkASCEEOJtF4YhW1ubXLt6hXDyGG0dHa8lAHZ2uHFtmqGRUToy2X0BabVSYebGNTLZLEMjowcmFm5cm8aOxUil0szevIHnukweP0EsFm8KvO7evsXc7AzpdBsDQ7VZ3ka5dRAE9eDb31eNUK2UWV5aJJPNHXh9lUqFjfU1OjLZpvXc62urzM/eZGBomM6uLhRqx9R0HU3TcF2XaqXC9vY2vu/dc91Vdnd2cF23aW14g+977Gxv4/tB9LGtzQ0uv/wSmqoxMXWMeDwRVU00kh+rKysEYUDI0Vb5BWFAqVikWCxgGGatPF5V0TSVIEjgOg6KohAGwZHfBwWFIKyV63d29USJj4ZUKo2iqvzihedZXrxLNpc7tPojCAI21te4c2uB7p5eevv7m547gHXIO7myvMTVVy/T2tbO8QdOEoYwc+0qM9evYVk2Pb190bilUpHlpUUsyybX1U2ipaX5mhTl0D3u9z67IPDZ2d6mVCyiqRqlUolqpYKyZ5Y/DENWl5epVMqMjk8cmAASQgghJAEghBDiHUtBqZXq+15T5/XG2vLgkABSUZX6emlv3+d2d3e4Pn0VgPHJKdL1kvCbM9cxTJOx8cmofN51HRYX77C7s0Nrazv53V0K+fyBgaFu6ARBQCqdbv7cfYLmg7rJO04Vz/OwbfvwmXFFgfoyhIOCW9/37x9U7hm3XC5RyBfo6u6uBdF7Ak/DMIgnEtixWC0RccTu98lkiocefoT19TWKhQKbGxuEYYCCQkiIU62tX1dUNVoa8LrvQj3BUvv+StPSkMaSjEq5TBiGtWSJqjXdr8YMeeN77FgMwzBwHIdqtbpvrf/e49eqFwJWlpe48solEokWTp46Hb0nk8dPEIYhl19+iTAM6esfQNM0WpIpsrlONtbXWFtZxrIsLMve9w40lls0xlMVtenZGoZJV08vm5sbOE4VwzBoa2+v3TtFwfNcNtfX2drawDStAytZhBBCCEkACCGEeOcnAe6Zxd4bLJVLJZxqFV3Xo68LwxDXdVFVFcNsLoMu5PNcvvQSjlPl1INn6chkAZg4dhyA+flZVFVjZHQMy7bRNZ1EooU1VvADPwqIoTY77vs+juNw7cplDNPg7PmHm8bzPI/tzU0K+TymZUUVDI7jUC6XUFUNy7KiINZ13Wh2Pghea14HtbXzjYZ50fKDewJyRVHwXJeVpUWSySSx+Guz2pVKhe2tLUzLoiWZjD7e1tZBe0cHO9vbzM/eJNfZhaZrtaDaD9jYWKewu3vk2X+orW9HUYjHEximgVZvduf5Xm3d/foaLckknV1d2LHY0Y+rqCgoLMzP4vk+8Vgc3dBxXZed7S3WVlfoGxhkYvLYaz0QFAXTNLFsO0oKKIpCNtfJ2fMPMz97k+krl+nIZrEsu1ZNEoa49YZ7PT19xBMJtjY3mJudIZlM8eDZc009Fmw7xolTpwlDmL85g2VZ0br+cxcucufWAmurK2xvb9Pa1la7jnpSwalWac9koqUsUcIhfG27QU3T6B8YpLW1jZXlRZbu3mV1ZRlDN1BUFdd1CMOQ8cmp2tKIQ6oKhBBCCEkACCGEeEcH/wfNkjdyAvndHRYX79CabkPVXguu11ZXSKXT9PUPRt9TLpe4eeMalXKJYw+cIrOnhFzXdYbHxnBdh5WlRRItLfT29WOYJqNjE2iaRrVapVQq1gKyesLBcRzKpRLtHR30DQySTrdGxzRNi2QyFZWNm5ZZL2MPqVYrOI7D8OgoXfWGbY7jsL62SrGQJwzD2rXdvVObJVcVEokW0q1tKErtz+0dGaw9gZ6iqrQkW+ql5kk2NzbQtrejaoFSsYhhmJx88HSU+ABoSSY5e/5hVpeX2N3dwXGqmKaFoqoEvo+qaXR292DaFi3J1JG3mvM9j2KxgL/jRcF/PUODbcc4dfos6da2N7WF3uj4JIqiUK6UCUoBhCGmZXP8gVOk0q1NDfBUVSWb6ySZTDUlRHRdp7unl0w2R7lUipo2+r6PbhgYpolhpOu7IgQYhsnUsRMkEi0HNlg0DIMTJ0/VOvjrRvTemqbJyNg4g8MjVCoVXNeJKilUVSMWjzf1DTgo6dX4WCqdjipM9iaHGstDhBBCCEkACCGEeNcG/8lUirHxCTLZXFOJdDKVZmLqOC3JFmw7XttireoRBLVZ8da2dvr6B2hr74iOF/gB7ZkMnd095Dq79gVZsVic8aljbG1uYhpmNBPbkkwydfwByqUS5XIpChI1TcO2bZLJJCOjY/tmXTPZHPFEglh9lrpaqQX9YRgSj8fp6uohFo9HAbCmacQTCSzbru9eYJBubUVRa7PFpmlGfQdS6XStNH/PEgFd1+kfHKK7p682261plMtlaOyYkFNqVQ0HBNyJRILh0bFoZwTP81A1FdO00DQtWm6hadqRu8vvDVYbJfpq/Vre7PvQYFkWrW3tR/q+MAypVirkd3do7+g4MHA39pzr/a7n9eztzH8vTdPqjRfvX56v6waZbA7Ltu97r2WWXwghxDvi/2uvLqyEchuEEEL8poIgYGNtjbXVFdJtbU1bpTXK3/cGSI395lVVfVdvgba9tcn62hrJVIrOru59n/d9n9sL8+zu7tDb1980m/9e5rou62urlEsl+gYGX3fbxr3vUSGfp1qtkkqlDpy9fyfxfZ9KpYKqKliWLdv5CSGEkASAEEIIIYQQQggh3l6SphZCCCGEEEIIISQBIIQQQgghhBBCCEkACCGEEEIIIYQQQhIAQgghhBBCCCGEkASAEEIIIYQQQgghJAEghBBCCCGEEEIISQAIIYQQQgghhBBCEgBCCCGEEEIIIYSQBIAQQgghhBBCCPG+8n98HXZ+xinaEgAAAABJRU5ErkJggg==',
1: 'data:image/png;base64,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',
2: 'data:image/png;base64,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',
3: 'data:image/png;base64,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',
4: '',
5: '',
6: '',
7: '',
8: '',
9: '',
10: '',
11: '',
12: '',
13: '',
14: '',
15: '',
16: '',
17: '',
18: '',
19: '',
20: '',
21: '',
22: '',
23: '',
24: '',
25: '',
26: '',
27: '',
28: '',
29: '',
30: '',
31: '',
32: '',
33: '',
34: '',
35: '',
36: '',
37: '',
38: '',
39: '',
40: '',
41: '',

} }",
{"status":false}
],

[
"темы.реакции",
"// // // //

function ЗагрузитьИзображенияТем(мир)
{
    this.исполнить = function()
    {
        var и64 = МОД.модуль("темы.изображения").code64;
        var изображения = муром.atob(и64);
        if (!изображения.length)
        {
            return;
        }
        eval(изображения);
        var сохранённое = МР();
        var изо = мир.состояние["изображения"];
        for (var номер in изо)
        {
            var img = изо[номер];
            var src = сохранённое[номер];
            if (src)
            {
                img.src = src;
            }
        }
    };
}

// // // //

function НастроитьСохранениеИзображений(мир)
{
    this.исполнить = function()
    {
        var self = this;
        $("#темы-сохранить-изображения").click(function() {
            self.сохранить();
        });
    };
    this.сохранить = function()
    {
        var изо = мир.состояние["изображения"];
        var начало = "function МР() { return {\n";
        var конец = "\n} }";
        var содержимое = "";
        for (var номер in изо)
        {
            var данные = изо[номер].src;
            содержимое += форматСтроки("{0}: '{1}',\n", номер, данные);
        }
        содержимое = начало + содержимое + конец;
        var модуль = МОД.модуль("темы.изображения");
        модуль.code64 = муром.btoa(содержимое);
        
        МОД.сохранить();
    };
}

// // // //

function УстановитьЗагрузкуИзображений(мир)
{
    this.исполнить = function()
    {
        var ввод = document.getElementById("темы-загрузить-изображения");
        var self = this;
        ввод.onchange = function() {
            self.загрузить(ввод.files);
        };
    };
    this.свободныеПозиции = function()
    {
        var изо = мир.состояние["изображения"];
        var позиции = [];
        for (var номер = 0; номер < 42; ++номер)
        {
            if (изо[номер].src)
            {
                // How to check empty/undefined/null string in JavaScript?
                // https://stackoverflow.com/a/154068/3404710
            }
            else
            {
                позиции.push(номер);
            }
        }
        
        return позиции;
    };
    this.загрузить = function(файлы)
    {
        var позиции = this.свободныеПозиции();
        for (var номер = 0; номер < файлы.length; ++номер)
        {
            // Не загружаем при отсутствии свободных позиций.
            if (!позиции.length)
            {
                console.warn("Не хватает доступных позиций для загрузки изображений");
                return;
            }
            var файл = файлы[номер];
            var позиция = позиции.shift();
            this.загрузитьФайл(файл, позиция);
        }
    };
    this.загрузитьФайл = function(файл, позиция)
    {
        var чтец = new FileReader();
        var self = this;
        чтец.onload = function(событие)
        {
            var изо = мир.состояние["изображения"];
            var img = изо[позиция];
            img.src = событие.target.result;
        };
        чтец.readAsDataURL(файл);
    };
}

// // // //

function ПодготовитьПозицииИзображений(мир)
{
    this.исполнить = function()
    {
        var изо = {};
        var img = $("img");
        for (var номер = 0; номер < 42; ++номер)
        {
            изо[номер] = img[номер];
        }
        мир.состояние["изображения"] = изо;
    };
}

// // // //

function ДобавитьСетку(мир)
{
    this.исполнить = function()
    {
        function элемент(номер)
        {
            var html =
                `
<div>
    <div class="uk-card uk-card-default uk-card-small">
        <div class="uk-card-header uk-text-center">
                `
                + номер +
                `
        </div>
        <div class="uk-card-body">
            <img class="uk-height-small uk-width-small uk-align-center">
        </div>
    </div>
</div>
                `;
            return html;
        }
        var элементы = "";
        for (var номер = 1; номер <= 42; ++номер)
        {
            var эл = элемент(номер);
            элементы += эл;
        }
        var html =
            `
<div class="uk-grid-match uk-grid-small uk-padding-small uk-child-width-1-1 uk-child-width-1-2@m uk-child-width-1-3@l uk-child-width-1-4@xl uk-child-width-1-5@xxl" uk-grid uk-height-match="target: > div > .uk-card">
            `
            + элементы +
            `
</div>
            `;
        $("#темы-область-левая")
            .append(html)
            .css("overflow-y", "scroll")
            ;
    }
}

// // // //

function ДобавитьЭкранТем(мир)
{
    this.исполнить = function()
    {
        var html =
            `
<div id="темы-область-левая">
</div>

<div id="темы-область-центральная-верх">
    <div uk-form-custom>
        <a class="uk-icon-button uk-margin-small-bottom" uk-icon="upload" uk-tooltip="title: Загрузить изображения; delay: 500"">
            <input id="темы-загрузить-изображения" type="file" multiple accepts="image/*">
        </a>
    </div>
    <a id="темы-сохранить-изображения" class="uk-icon-button uk-margin-small-bottom" uk-icon="database" uk-tooltip="title: Сохранить изменения в этом браузере; delay: 500""></a>
</div>    
    
    
    
</div>

<div id="темы-область-центральная-низ">
</div>

<div id="темы-область-правая-верх">
    <iframe id="встройка">
        <p>ОШИБКА Ваш веб-браузер не поддерживает iframe</p>
        <p>ERROR Your web browser does not support iframes</p>
    </iframe>
</div>

<div id="темы-область-правая-низ">
</div>
            `;
        var css =
            `
#темы-область-левая
{
    position: fixed;
    top: 0;
    bottom: 0;
    left: 0;
    width: calc(50% - 2em);
}

#темы-область-центральная-верх
{
    position: fixed;
    top: 0;
    height: 50%;
    left: 50%;
    width: 4em;
    transform: translateX(-2em);
    text-align: center;
    border-left: 1px solid #ddd;
    border-right: 1px solid #ddd;
    padding-top: 1em;
}

#темы-область-центральная-низ
{
    position: fixed;
    bottom: 0;
    height: 50%;
    left: 50%;
    width: 4em;
    transform: translateX(-2em);
    text-align: center;
    border-left: 1px solid #ddd;
    border-right: 1px solid #ddd;
    padding-top: 1em;
}

#темы-область-правая-верх
{
    position: fixed;
    top: 0;
    height: 50%;
    right: 0;
    width: calc(50% - 2em - 1px);
}

#темы-область-правая-низ
{
    position: fixed;
    bottom: 0;
    height: 50%;
    right: 0;
    width: calc(50% - 2em - 1px);
}
            `;
        добавитьЭкран("темы", html, css);
    }
}",
{"status":true}
],

[
"темы.последовательность",
"0L/Rg9GB0Log0YLQtdC8CiAgICDQtNC+0LHQsNCy0LjRgtGMINGN0LrRgNCw0L0g0YLQtdC8CiAgICDQtNC+0LHQsNCy0LjRgtGMINGB0LXRgtC60YMKICAgINC/0L7QtNCz0L7RgtC+0LLQuNGC0Ywg0L/QvtC30LjRhtC40Lgg0LjQt9C+0LHRgNCw0LbQtdC90LjQuQogICAg0YPRgdGC0LDQvdC+0LLQuNGC0Ywg0LfQsNCz0YDRg9C30LrRgyDQuNC30L7QsdGA0LDQttC10L3QuNC5CiMgICAg0L3QsNGB0YLRgNC+0LjRgtGMINGB0L7RhdGA0LDQvdC10L3QuNC1INC40LfQvtCx0YDQsNC20LXQvdC40LkKICAgINC30LDQs9GA0YPQt9C40YLRjCDQuNC30L7QsdGA0LDQttC10L3QuNGPINGC0LXQvA==",
{"status":false}
],

];

Object.defineProperty(murom, "modules", {
    get: function()
    {
        return муром.модули;
    },
    set: function(значения)
    {
        муром.модули = значения;
    }
});

var загрузочныйМодуль = муром.модули[0];
var код = atob(загрузочныйМодуль[1]);
eval(код);

        </script>
    </body>
</html>