From a76c43c97ef56f7fcd1ad6c692ec4ebb9b284f88 Mon Sep 17 00:00:00 2001 From: Kyle Harter <99735799+kylemotion@users.noreply.github.com> Date: Mon, 10 Aug 2026 17:35:22 -0400 Subject: [PATCH] Initial commit --- .DS_Store | Bin 0 -> 6148 bytes .gitignore | 2 + .vscode/launch.json | 19 + LICENSE | 21 + README.md | 53 + data/.DS_Store | Bin 0 -> 6148 bytes data/km-layer-labels.json | 12 + jsconfig.json | 13 + jsdoc.json | 15 + package-lock.json | 324 ++ package.json | 15 + src/.DS_Store | Bin 0 -> 6148 bytes src/library/OS.jsx | 57 + src/library/colorPicker.js | 964 ++++++ src/library/filePath.jsx | 14 + src/library/km_helperFunctions.jsx | 383 +++ src/library/km_scriptUI_functions.jsx | 75 + src/library/km_systemFunctions.jsx | 70 + src/library/km_textAnimators.jsx | 73 + src/library/km_utilityFunctions.jsx | 316 ++ src/library/uiImage.jsx | 14 + src/scripts/km-comp-duration-from-layer.jsx | 71 + src/scripts/km-layer-labeler.jsx | 134 + src/scripts/km-layer-null-name-from-child.jsx | 66 + src/scripts/km-layer-props-copy-paste.jsx | 159 + src/scripts/km-recurse-cti-comp-center.jsx | 66 + .../km-trim-selected-comps-work_area.jsx | 60 + src/templates/_km-template-headless.jsx | 45 + src/templates/_km-templatename-scriptUI.jsx | 94 + src/types/JavaScript.d.ts | 2731 +++++++++++++++ src/types/PlugPlugExternalObject.d.ts | 91 + src/types/ScriptUI.d.ts | 3007 +++++++++++++++++ src/types/XMPScript.d.ts | 72 + src/types/global.d.ts | 152 + src/types/index.d.ts | 2933 ++++++++++++++++ 35 files changed, 12121 insertions(+) create mode 100644 .DS_Store create mode 100644 .gitignore create mode 100644 .vscode/launch.json create mode 100644 LICENSE create mode 100644 README.md create mode 100644 data/.DS_Store create mode 100644 data/km-layer-labels.json create mode 100644 jsconfig.json create mode 100644 jsdoc.json create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 src/.DS_Store create mode 100644 src/library/OS.jsx create mode 100644 src/library/colorPicker.js create mode 100644 src/library/filePath.jsx create mode 100644 src/library/km_helperFunctions.jsx create mode 100644 src/library/km_scriptUI_functions.jsx create mode 100644 src/library/km_systemFunctions.jsx create mode 100644 src/library/km_textAnimators.jsx create mode 100644 src/library/km_utilityFunctions.jsx create mode 100644 src/library/uiImage.jsx create mode 100644 src/scripts/km-comp-duration-from-layer.jsx create mode 100644 src/scripts/km-layer-labeler.jsx create mode 100644 src/scripts/km-layer-null-name-from-child.jsx create mode 100644 src/scripts/km-layer-props-copy-paste.jsx create mode 100644 src/scripts/km-recurse-cti-comp-center.jsx create mode 100644 src/scripts/km-trim-selected-comps-work_area.jsx create mode 100644 src/templates/_km-template-headless.jsx create mode 100644 src/templates/_km-templatename-scriptUI.jsx create mode 100644 src/types/JavaScript.d.ts create mode 100644 src/types/PlugPlugExternalObject.d.ts create mode 100644 src/types/ScriptUI.d.ts create mode 100644 src/types/XMPScript.d.ts create mode 100644 src/types/global.d.ts create mode 100644 src/types/index.d.ts diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..babc9b52ed37b8d90fd59ade8f2b630fbf62c15e GIT binary patch literal 6148 zcmeHK&2G~`5S~q3Y`0YS08)=DagExf0@R9&Nz)7Bgi%q|qF~1%wQ#&q>@n>vPr?>}0{|8_j>a-} ze-Q5Hts*sLxra#j81bOx_1JJ!iPQ$ofM#G38Q|Zp0qZb;2(r@myL9)w=o_+5Cx}^q zHtXA``1$^it7m0@_*ehvsIWJziY>y#d5Sca5N!$MT zfIq!rEDmmTKiG@<)2?%Whb5UGCH=8Th{8UG9KMc{kWJfcl7y+q^`yhLExYTi&1PGz ztp=fBSA-L}fSygxgXQ=#I&#^a7VwMch z#^dYA`51cd!n7A))df@O71&>*d2o^X%Y&Vd-#-iL)lfq=r@ZPdQN65B2V`|2ME!QG zm4&EA7oi!@3@j1@e1D+WIJydRiDK)(PFw*H4Kxcu-Qfx%Rp=_rC87s~$W%m`O4JpD z$aJ(*73V6heL<%tYN#h?pJ6ry?APD^d5F0nI>}fx3Kj`1!wk`~AP1q@Oec znt}g{0b+E#P8*k`&eqD}_*qM_y~W0b$K?`53U=x^779O#*RTmeALR<7t1y>{78LzQ NK+vE&&A>lp;3tT9r=I`- literal 0 HcmV?d00001 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..55f99ce --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +node_modules/ +docs/ \ No newline at end of file diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..fee2ebd --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,19 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + + { + "type": "extendscript-debug", + "request": "attach", + "name": "Attach to ExtendScript Engine" + }, + { + "type": "extendscript-debug", + "request": "launch", + "name": "Launch Script in ExtendScript Engine" + } + ] +} \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..643c273 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Kyle Harter + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..ca1a64b --- /dev/null +++ b/README.md @@ -0,0 +1,53 @@ +### Introduction to [script-name] + +Introducing [script-name] - an easy-to-use After Effects script that helps to [complete a specific task] + +Notable features include: + +- + +--- + +### Installing [script-name] + +[script-name]**.jsxbin** must be placed in the Scripts directory in the After Effects +folder. That folder will be named “Adobe After Effects [version]” which has been +replaced with “AE” below. + +Mac OS X + +`/Applications/AE/Scripts/ScriptUI Panels` + +Windows + +`\Program Files\AE\Support Files\Scripts\ScriptUI Panels` + +If After Effects was running when you installed the script, you’ll need to restart it. Also, you’ll need to allow After Effects to write files. + +To do that follow this path: `Preferences > General > Check-off “Allow Scripts to Write Files and Access Network” > Close Preferences` + +--- + +### Launching [script-name] + +When properly installed, you will find **[script-name].jsxbin** under the File > Scripts menu in After Effects. + +--- + +### [Insert Image of Script UI Panel if there is one] + +--- + +### How to use [script-name] + +- Step 1: +- Step 2: +- Step 3: + +Thank you so much for getting [script-name]! I hope you’ll save time using this tool, and use that time to make your best work. + +--- + +Feel free to write me, Kyle Harter, at **kylenmotion@gmail.com** if you run into any issues along the way. Thanks again!  + +- Kyle Harter \ No newline at end of file diff --git a/data/.DS_Store b/data/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz", + "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.27.2", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.2.tgz", + "integrity": "sha512-QYLs8299NA7WM/bZAdp+CviYYkVoYXlDW2rzliy3chxd1PQjej7JORuMJDJXJUb9g0TT+B99EwaVLKmX+sPXWw==", + "dev": true, + "dependencies": { + "@babel/types": "^7.27.1" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.1.tgz", + "integrity": "sha512-+EzkxvLNfiUeKMgy/3luqfsCWFRXLb7U6wNQTk60tovuckwB15B191tJWvpp4HjiQWdJkCxO3Wbvc6jlk3Xb2Q==", + "dev": true, + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@jsdoc/salty": { + "version": "0.2.9", + "resolved": "https://registry.npmjs.org/@jsdoc/salty/-/salty-0.2.9.tgz", + "integrity": "sha512-yYxMVH7Dqw6nO0d5NIV8OQWnitU8k6vXH8NtgqAfIa/IUqRMxRv/NUJJ08VEKbAakwxlgBl5PJdrU0dMPStsnw==", + "dev": true, + "dependencies": { + "lodash": "^4.17.21" + }, + "engines": { + "node": ">=v12.0.0" + } + }, + "node_modules/@types/linkify-it": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-5.0.0.tgz", + "integrity": "sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==", + "dev": true + }, + "node_modules/@types/markdown-it": { + "version": "14.1.2", + "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-14.1.2.tgz", + "integrity": "sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==", + "dev": true, + "dependencies": { + "@types/linkify-it": "^5", + "@types/mdurl": "^2" + } + }, + "node_modules/@types/mdurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-2.0.0.tgz", + "integrity": "sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==", + "dev": true + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, + "node_modules/bluebird": { + "version": "3.7.2", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz", + "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==", + "dev": true + }, + "node_modules/catharsis": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/catharsis/-/catharsis-0.9.0.tgz", + "integrity": "sha512-prMTQVpcns/tzFgFVkVp6ak6RykZyWb3gu8ckUpd6YkTlacOd3DXGJjIpD4Q6zJirizvaiAjSSHlOsA+6sNh2A==", + "dev": true, + "dependencies": { + "lodash": "^4.17.15" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/docdash": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/docdash/-/docdash-2.0.2.tgz", + "integrity": "sha512-3SDDheh9ddrwjzf6dPFe1a16M6ftstqTNjik2+1fx46l24H9dD2osT2q9y+nBEC1wWz4GIqA48JmicOLQ0R8xA==", + "dev": true, + "dependencies": { + "@jsdoc/salty": "^0.2.1" + } + }, + "node_modules/entities": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", + "dev": true, + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true + }, + "node_modules/js2xmlparser": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/js2xmlparser/-/js2xmlparser-4.0.2.tgz", + "integrity": "sha512-6n4D8gLlLf1n5mNLQPRfViYzu9RATblzPEtm1SthMX1Pjao0r9YI9nw7ZIfRxQMERS87mcswrg+r/OYrPRX6jA==", + "dev": true, + "dependencies": { + "xmlcreate": "^2.0.4" + } + }, + "node_modules/jsdoc": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-4.0.4.tgz", + "integrity": "sha512-zeFezwyXeG4syyYHbvh1A967IAqq/67yXtXvuL5wnqCkFZe8I0vKfm+EO+YEvLguo6w9CDUbrAXVtJSHh2E8rw==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.20.15", + "@jsdoc/salty": "^0.2.1", + "@types/markdown-it": "^14.1.1", + "bluebird": "^3.7.2", + "catharsis": "^0.9.0", + "escape-string-regexp": "^2.0.0", + "js2xmlparser": "^4.0.2", + "klaw": "^3.0.0", + "markdown-it": "^14.1.0", + "markdown-it-anchor": "^8.6.7", + "marked": "^4.0.10", + "mkdirp": "^1.0.4", + "requizzle": "^0.2.3", + "strip-json-comments": "^3.1.0", + "underscore": "~1.13.2" + }, + "bin": { + "jsdoc": "jsdoc.js" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/klaw": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/klaw/-/klaw-3.0.0.tgz", + "integrity": "sha512-0Fo5oir+O9jnXu5EefYbVK+mHMBeEVEy2cmctR1O1NECcCkPRreJKrS6Qt/j3KC2C148Dfo9i3pCmCMsdqGr0g==", + "dev": true, + "dependencies": { + "graceful-fs": "^4.1.9" + } + }, + "node_modules/linkify-it": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz", + "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==", + "dev": true, + "dependencies": { + "uc.micro": "^2.0.0" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "dev": true + }, + "node_modules/markdown-it": { + "version": "14.1.0", + "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-14.1.0.tgz", + "integrity": "sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==", + "dev": true, + "dependencies": { + "argparse": "^2.0.1", + "entities": "^4.4.0", + "linkify-it": "^5.0.0", + "mdurl": "^2.0.0", + "punycode.js": "^2.3.1", + "uc.micro": "^2.1.0" + }, + "bin": { + "markdown-it": "bin/markdown-it.mjs" + } + }, + "node_modules/markdown-it-anchor": { + "version": "8.6.7", + "resolved": "https://registry.npmjs.org/markdown-it-anchor/-/markdown-it-anchor-8.6.7.tgz", + "integrity": "sha512-FlCHFwNnutLgVTflOYHPW2pPcl2AACqVzExlkGQNsi4CJgqOHN7YTgDd4LuhgN1BFO3TS0vLAruV1Td6dwWPJA==", + "dev": true, + "peerDependencies": { + "@types/markdown-it": "*", + "markdown-it": "*" + } + }, + "node_modules/marked": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/marked/-/marked-4.3.0.tgz", + "integrity": "sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==", + "dev": true, + "bin": { + "marked": "bin/marked.js" + }, + "engines": { + "node": ">= 12" + } + }, + "node_modules/mdurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-2.0.0.tgz", + "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==", + "dev": true + }, + "node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true, + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/punycode.js": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode.js/-/punycode.js-2.3.1.tgz", + "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/requizzle": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/requizzle/-/requizzle-0.2.4.tgz", + "integrity": "sha512-JRrFk1D4OQ4SqovXOgdav+K8EAhSB/LJZqCz8tbX0KObcdeM15Ss59ozWMBWmmINMagCwmqn4ZNryUGpBsl6Jw==", + "dev": true, + "dependencies": { + "lodash": "^4.17.21" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/uc.micro": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-2.1.0.tgz", + "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==", + "dev": true + }, + "node_modules/underscore": { + "version": "1.13.7", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.7.tgz", + "integrity": "sha512-GMXzWtsc57XAtguZgaQViUOzs0KTkk8ojr3/xAxXLITqf/3EMwxC0inyETfDFjH/Krbhuep0HNbbjI9i/q3F3g==", + "dev": true + }, + "node_modules/xmlcreate": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/xmlcreate/-/xmlcreate-2.0.4.tgz", + "integrity": "sha512-nquOebG4sngPmGPICTS5EnxqhKbCmz5Ox5hsszI2T6U5qdrJizBc+0ilYSEjTSzU0yZcmvppztXe/5Al5fUwdg==", + "dev": true + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..7fac238 --- /dev/null +++ b/package.json @@ -0,0 +1,15 @@ +{ + "name": "ae-library-template", + "version": "1.0.0", + "description": "A utility library for ExtendScript / After Effects scripting", + "scripts": { + "docs": "jsdoc -c jsdoc.json" + }, + "keywords": [], + "author": "kyle harter", + "license": "MIT", + "devDependencies": { + "docdash": "^2.0.2", + "jsdoc": "^4.0.4" + } +} diff --git a/src/.DS_Store b/src/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..99d5606c185b5446b1fc425b42a2e140f1fd3a66 GIT binary patch literal 6148 zcmeHKF-ikL6#b(c5)~m9g5?y}LQ1s-ZA?i>OM1$GH?@&h@MS zm6>CoPH1@08MMQsz?KeiKpdDg2YByRDWV>Q*t?nin?x*iVkkOnwAxABH*euReij*V z5(HtCgczxfy4%<9_s?5ptj;f3{iDok6^&`2XFzQT?NOgjX^_)H)w?1itLN$BW8>z* z>B-F#Cu2R+SvfuClSvCu(WMw_BACbR2~Eql&{V?8>KeYCACIh0rOdImpP6}m8Vgee znubs}smps=&5vgFtY5zFUTqqmGWl7L${D%!E4;kKEIWWRo1?a5QEG8O91sV-9pLYS zMq%_FrWVbo1C_Y~06lb@K%4IpoTDB34pWO5K`5IFw5iHnF_cY5zji#|VQSH)lX902 zh;($1icVON=*7^M3nSTGzC&`mIAP)R12b34If+k+covnqJ vA8k{?vglAVi-+ literal 0 HcmV?d00001 diff --git a/src/library/OS.jsx b/src/library/OS.jsx new file mode 100644 index 0000000..1af56e9 --- /dev/null +++ b/src/library/OS.jsx @@ -0,0 +1,57 @@ +var OS = (function(){ + function isWindows() { + return $.os.indexOf("Windows") != -1; + }; + + function isMacOS(){ + return !isWindows(); + }; + + + function openUrl(url){ + if(isWindows()){ + openUrlWin(url); + } + else { + openUrlMac(url); + } + } + + + function openUrlMac(url){ + var command = 'open "'+url+'"'; + system.callSystem(command); + } + + function openUrlWin(url){ + var command = 'start ' + url; + executeWinCommandlineCommand(command); + } + + function executeWinCommandlineCommand(command){ + var quotedCommand = quoteForWindowsCmd(command); + var outerCommand = "cmd /c \""+quotedCommand+"\""; + system.callSystem(outerCommand); + } + + function quoteForWindowsCmd (string) { + // put a ^ before every META character that has a special meaning in CMD + var metaChars = ['^','(',')','%','!','"','<','>','&','|','\n']; + var prefix ="^" + for(var i=0; i< metaChars.length; i++){ + string = replaceAll(string, metaChars[i],prefix+metaChars[i]); + } + return string; + }; + + function replaceAll(string, search, replace){ + return string.split(search).join(replace); + }; + + return { + isWindows: isWindows, + isMacOS: isMacOS, + openUrl: openUrl + } + +}()) \ No newline at end of file diff --git a/src/library/colorPicker.js b/src/library/colorPicker.js new file mode 100644 index 0000000..dc0fc6e --- /dev/null +++ b/src/library/colorPicker.js @@ -0,0 +1,964 @@ + +/* + * ColorPicker v2.0 for Adobe scripting. + * 2016-5-11 -> 2016-7-24 + * + * By: smallpath + * Email: smallpath2013@gmail.com + * Github: github.com/Smallpath/AdobeColorPicker + * + * This is a rebuilt color picker for Adobe scripting. + * Support all Adobe softwares such as PS,AI,PR and so on. + * + * See usage on github.com/Smallpath/AdobeColorPicker + */ + +function colorPicker(inputColour,options){ + if(!(this instanceof colorPicker)) + return new colorPicker(inputColour,options) + + this.options = { + name : "Adobe Color Picker ", + version : "v2.0", + shouldUpdateCursor: false, + backupLocation : [], + + windowType:"dialog", // "dialog","palette" and the reference of Panel + } + + if(options && colorPicker.isType(options,"Object")){ + for(var i in options) + this.options[i] = options[i]; + } + + this.inputColour = colorPicker.parseColor(inputColour); + this.outputColour = this.inputColour.slice(0); + this.initSetting(); + return this.showColorPicker(); +} + +colorPicker.parseColor = function(inputValue){ + if(!inputValue) + return [1,1,1]; + + if(colorPicker.isRgb(inputValue)) //[0,0,0] - [1,1,1] + return colorPicker.parseRgb(inputValue); + else if(colorPicker.isLargeRgb(inputValue)) //[0,0,0] - [255,255,255] + return colorPicker.parseLargeRgb(inputValue); + else if(colorPicker.isHex(inputValue) ) //FFFFFF + return colorPicker.parseHex(inputValue); + else if(colorPicker.isShortHex(inputValue)) //FFF + return colorPicker.parseShortHex(inputValue); + else if(colorPicker.isHsb(inputValue)) //[0,0,0,'hsb'] - [360,100,100,'hsb'] + return colorPicker.parseHsb(inputValue); + else + return [1,1,1]; +} + +colorPicker.prototype.showColorPicker = function(){ + var win = this.initWindow(); + if(win.type == "dialog" ||win.type == "palette" ){ + if(this.haveSetting ("location")){ + win.location = this.getSetting ("location").split(","); + if(win.location.length != 2) + win.center(); + else if(win.location[0]<0 || win.location[1]<0) + win.center(); + } + win.show(); + this.saveSetting ("location", win.location); + }else if(win.type == "panel"){ + win.layout.layout(true); + } + if(!this.isSmallMode){ + this.outputColour.hex = colorPicker.RgbToHex(this.outputColour); + this.outputColour.hsb = colorPicker.RgbToHsb(this.outputColour); + this.outputColour.rgb = this.outputColour.slice(0); + + return this.outputColour; + }else{ + return { + window:win, + colorPicker:this + }; + } +} + +colorPicker.prototype.initWindow = function(){ + var _this = this; + var type = this.options["windowType"]; + if(type=="palette"){ + var win = new Window("palette", this.options["name"] + this.options["version"], undefined, { + maximizeButton: false, + minimizeButton: false, + }); + this.size = this.options["size"] = 90; + }else if(type instanceof Panel){ + var win = type; + this.size = this.options["size"] = 90; + }else{ + var win = new Window("dialog", this.options["name"] + this.options["version"], undefined, { + maximizeButton: false, + minimizeButton: false, + closeButton:false + }); + this.size = this.options["size"] = 130; + } + + var isSmallMode = this.isSmallMode = this.size != 130; + var targetImage = isSmallMode ? this.options["smallColorWheel"]: this.img ; + var targetSize = this.size*2; + + var colourGroup = win.add('group'); + colourGroup.orientation = "stack"; + + win.image = colourGroup.add("image", undefined,targetImage); + + var colourCursorGroup = this.colourCursorGroup = colourGroup.add('customBoundedValue',[0,0,targetSize+2,targetSize+2]); + colourCursorGroup.fillColour = [0,0,0,0]; + + var colourSelectCursor = this.colourSelectCursor = colourCursorGroup.colourSelectCursor = {}; + colourSelectCursor.size = [12,12]; + colourSelectCursor.strokeWidth = 1; + colourSelectCursor.strokeColour = [0,0,0]; + + this.setCursorLocation (this.inputColour); + + colourCursorGroup.onDraw = function () { + this.graphics.drawOSControl(); + this.graphics.newPath(); + this.graphics.ellipsePath(0,0,this.size[0],this.size[1]); + this.graphics.fillPath(colourCursorGroup.graphics.newBrush(colourCursorGroup.graphics.BrushType.SOLID_COLOR, colourCursorGroup.fillColour)); + + this.graphics.newPath(); + + this.graphics.ellipsePath(this.colourSelectCursor.location[0]+this.colourSelectCursor.strokeWidth/2+1, + this.colourSelectCursor.location[1]+this.colourSelectCursor.strokeWidth/2+1, + this.colourSelectCursor.size[0]-this.colourSelectCursor.strokeWidth, + this.colourSelectCursor.size[1]-this.colourSelectCursor.strokeWidth); + this.graphics.strokePath(this.graphics.newPen(this.graphics.PenType.SOLID_COLOR, + this.colourSelectCursor.strokeColour, this.colourSelectCursor.strokeWidth)); + }; + + + win.brightGroup = win.add("group"); + win.staticBright = win.brightGroup.add("statictext",undefined,"Bright:"); + win.editBright = win.brightGroup.add("edittext{text:'0',characters:3,justify:'center',active:1}"); + win.slider = win.brightGroup.add("slider",undefined,100,0,100); + if(!isSmallMode){ + win.slider.size = "width:160,height:20"; + var spacing = 10; + var character = 4; + }else{ + win.slider.size = "width:100,height:20"; + win.brightGroup.spacing = 2; + win.spacing = 5; + win.margins = 2; + var spacing = 0; + var character = 3; + } + + + var editor = win.add('group'); + editor.orientation = 'column'; + + editor.gulu = editor.add('group'); + + editor.gulu.uni = editor.gulu.add('group'); + editor.gulu.uni.spacing = spacing; + + editor.gulu.uni.Ed = editor.gulu.uni.add('statictext', undefined, '#'); + editor.gulu.uni.unicode = editor.gulu.uni.add('edittext', undefined, 'FF0000') + editor.gulu.uni.unicode.characters = 6; + editor.gulu.uni.unicode.justify = 'center'; + + editor.gulu.color = editor.gulu.add('customBoundedValue', undefined, 'Redraw original image'); + editor.gulu.color.size = [80, 25]; + + editor.colorHolder = editor.add('group'); + editor.colorHolder.orientation = 'row'; + + editor.colorHolder.colorCol1 = editor.colorHolder.add('group'); + editor.colorHolder.colorCol1.orientation = 'column'; + + editor.colorHolder.colorCol1.hGroup = editor.colorHolder.colorCol1.add('group'); + editor.colorHolder.colorCol1.hGroup.spacing = spacing; + + editor.colorHolder.colorCol1.hGroup.hRad = editor.colorHolder.colorCol1.hGroup.add('statictext', undefined, 'H:'); + editor.colorHolder.colorCol1.hGroup.hValue = editor.colorHolder.colorCol1.hGroup.add('edittext', undefined, '0'); + editor.colorHolder.colorCol1.hGroup.hValue.characters = character; + editor.colorHolder.colorCol1.hGroup.hValue.justify = 'center'; + editor.colorHolder.colorCol1.hGroup.hValue._index = 0; + + editor.colorHolder.colorCol1.rGroup = editor.colorHolder.colorCol1.add('group'); + editor.colorHolder.colorCol1.rGroup.spacing = spacing; + + editor.colorHolder.colorCol1.rGroup.rRad = editor.colorHolder.colorCol1.rGroup.add('statictext', undefined, 'R:'); + editor.colorHolder.colorCol1.rGroup.rValue = editor.colorHolder.colorCol1.rGroup.add('edittext', undefined, '0'); + editor.colorHolder.colorCol1.rGroup.rValue.characters = character; + editor.colorHolder.colorCol1.rGroup.rValue.justify = 'center'; + editor.colorHolder.colorCol1.rGroup.rValue._index = 0; + + editor.colorHolder.colorCol2 = editor.colorHolder.add('group'); + editor.colorHolder.colorCol2.orientation = 'column'; + + editor.colorHolder.colorCol2.sGroup = editor.colorHolder.colorCol2.add('group'); + editor.colorHolder.colorCol2.sGroup.spacing = spacing; + + editor.colorHolder.colorCol2.sGroup.sRad = editor.colorHolder.colorCol2.sGroup.add('statictext', undefined, 'S:'); + editor.colorHolder.colorCol2.sGroup.sValue = editor.colorHolder.colorCol2.sGroup.add('edittext', undefined, '0'); + editor.colorHolder.colorCol2.sGroup.sValue.characters = character; + editor.colorHolder.colorCol2.sGroup.sValue.justify = 'center'; + editor.colorHolder.colorCol2.sGroup.sValue._index = 1; + + editor.colorHolder.colorCol2.gGroup = editor.colorHolder.colorCol2.add('group'); + editor.colorHolder.colorCol2.gGroup.spacing = spacing; + + editor.colorHolder.colorCol2.gGroup.gRad = editor.colorHolder.colorCol2.gGroup.add('statictext', undefined, 'G:'); + editor.colorHolder.colorCol2.gGroup.gValue = editor.colorHolder.colorCol2.gGroup.add('edittext', undefined, '0'); + editor.colorHolder.colorCol2.gGroup.gValue.characters = character; + editor.colorHolder.colorCol2.gGroup.gValue.justify = 'center'; + editor.colorHolder.colorCol2.gGroup.gValue._index = 1; + + editor.colorHolder.colorCol3 = editor.colorHolder.add('group'); + editor.colorHolder.colorCol3.orientation = 'column'; + + editor.colorHolder.colorCol3.lGroup = editor.colorHolder.colorCol3.add('group'); + editor.colorHolder.colorCol3.lGroup.spacing = spacing; + + editor.colorHolder.colorCol3.lGroup.lRad = editor.colorHolder.colorCol3.lGroup.add('statictext', undefined, 'B:'); + editor.colorHolder.colorCol3.lGroup.lValue = editor.colorHolder.colorCol3.lGroup.add('edittext', undefined, '0'); + editor.colorHolder.colorCol3.lGroup.lValue.characters = character; + editor.colorHolder.colorCol3.lGroup.lValue.justify = 'center'; + editor.colorHolder.colorCol3.lGroup.lValue._index = 2; + + editor.colorHolder.colorCol3.bGroup = editor.colorHolder.colorCol3.add('group'); + editor.colorHolder.colorCol3.bGroup.spacing = spacing; + + editor.colorHolder.colorCol3.bGroup.bRad = editor.colorHolder.colorCol3.bGroup.add('statictext', undefined, 'B:'); + editor.colorHolder.colorCol3.bGroup.bValue = editor.colorHolder.colorCol3.bGroup.add('edittext', undefined, '0'); + editor.colorHolder.colorCol3.bGroup.bValue.characters = character; + editor.colorHolder.colorCol3.bGroup.bValue.justify = 'center'; + editor.colorHolder.colorCol3.bGroup.bValue._index = 2; + + + win.editor = editor; + if(win.type == "dialog"){ + + + editor.oc = win.editor.oc = win.add("Group{ok:Button{text:'Ok'},can:Button{text:'Cancel'}}"); + + editor.oc.ok.onClick = function(){ + win.close(); + } + + editor.oc.can.onClick = function(){ + colorPicker.copyArr(_this.outputColour,_this.inputColour); + win.close(); + } + + } + + editor.gulu.color.onDraw = function(draw){ + var targetColour = _this.outputColour; + + var gfxs=this.graphics; + gfxs.newPath(); + gfxs.rectPath(0, 0, this.size[0], this.size[1]); + gfxs.fillPath(gfxs.newBrush (gfxs.BrushType.SOLID_COLOR, targetColour)); + }; + + + + + + this.updateCursor(win); + + this.setDefaultValue(win) + + this.bindingKeydown(win); + + this.bindingHandler(win); + + return win; + +} + +colorPicker.prototype.setDefaultValue = function(win){ + var pi = win.editor; + var startColour = this.outputColour; + + + pi.gulu.uni.unicode.text= colorPicker.RgbToHex (startColour); + pi.gulu.uni.unicode.active = true; + + + + pi.colorHolder.colorCol1.rGroup.rValue.text=Math.round(startColour[0]*255); + pi.colorHolder.colorCol2.gGroup.gValue.text=Math.round(startColour[1]*255); + pi.colorHolder.colorCol3.bGroup.bValue.text=Math.round(startColour[2]*255); + + var hsbHere= colorPicker.RgbToHsb([ + startColour[0]*255, + startColour[1]*255, + startColour[2]*255 + ]); + + + pi.colorHolder.colorCol1.hGroup.hValue.text=hsbHere[0]; + pi.colorHolder.colorCol2.sGroup.sValue.text=hsbHere[1]; + pi.colorHolder.colorCol3.lGroup.lValue.text=hsbHere[2]; + + win.slider.value=hsbHere[2]; + win.editBright.text=hsbHere[2]; + + this.colourCursorGroup.fillColour[3] = 1 - (hsbHere[2])/100; + this.colourCursorGroup.notify("onDraw"); +} + +colorPicker.prototype.bindingHandler = function(win){ + var _this = this; + + win.editor.colorHolder.colorCol1.hGroup.hValue.onChange = + win.editor.colorHolder.colorCol2.sGroup.sValue.onChange = + win.editor.colorHolder.colorCol3.lGroup.lValue.onChange = function(){ + _this.options.backupLocation.length = 0; + this.text=Math.round(this.text); + + if(this._index ==0 ){ + if( this.text<0 || this.text>360 || isNaN(this.text)==true ){ + this.text= colorPicker.RgbToHsb([ + _this.outputColour[0]*255, + _this.outputColour[1]*255, + _this.outputColour[2]*255, + ])[this._index]; + } + }else{ + if( this.text<0 || this.text>100 || isNaN(this.text)==true ){ + this.text= colorPicker.RgbToHsb([ + _this.outputColour[0]*255, + _this.outputColour[1]*255, + _this.outputColour[2]*255, + ])[this._index]; + } + } + var hsbArr = [ + Math.round(win.editor.colorHolder.colorCol1.hGroup.hValue.text), + Math.round(win.editor.colorHolder.colorCol2.sGroup.sValue.text), + Math.round(win.editor.colorHolder.colorCol3.lGroup.lValue.text) + ]; + + var rgbArr = colorPicker.HsbToRgb (hsbArr); + var hexStr = colorPicker.RgbToHex ([rgbArr[0]/255,rgbArr[1]/255,rgbArr[2]/255]); + win.editor.gulu.uni.unicode.text = hexStr; + win.editor.gulu.uni.unicode.notify("onChange"); + + } + + + win.editor.colorHolder.colorCol1.rGroup.rValue.onChange = + win.editor.colorHolder.colorCol2.gGroup.gValue.onChange = + win.editor.colorHolder.colorCol3.bGroup.bValue.onChange = function (){ + _this.options.backupLocation.length = 0; + this.text=Math.round(this.text); + + if( this.text<0 || this.text>255 || isNaN(this.text)==true ){ + this.text=Math.round(_this.outputColour[this._index]*255); + } + + if(this._index ==0) + win.editor.gulu.uni.unicode.text= colorPicker.RgbToHex ([this.text/255,_this.outputColour[1],_this.outputColour[2]]); + else if(this._index ==1) + win.editor.gulu.uni.unicode.text= colorPicker.RgbToHex ([_this.outputColour[0],this.text/255,_this.outputColour[2]]); + else if(this._index ==2) + win.editor.gulu.uni.unicode.text= colorPicker.RgbToHex ([_this.outputColour[0],_this.outputColour[1],this.text/255]); + win.editor.gulu.uni.unicode.notify("onChange"); + + } + + win.editBright.onChange = win.editBright.onChanging = function () { + _this.options.backupLocation.length = 0; + if (this.text < 0) + this.text = 0; + if (this.text > 100) + this.text = 100; + if (isNaN(this.text)==true) + this.text = 100; + + win.slider.value = parseInt(this.text); + if(isNaN(win.slider.value)) + return; + win.slider.notify('onChange'); + }; + + win.slider.onChange = win.slider.onChanging = function(){ + + var thisColor= colorPicker.HsbToRgb ([ + Math.round(win.editor.colorHolder.colorCol1.hGroup.hValue.text), + Math.round(win.editor.colorHolder.colorCol2.sGroup.sValue.text), + Math.round(this.value) + ]); + if(this.value != 0){ + if(_this.options.backupLocation.length != 0 && _this.options.shouldUpdateCursor == true){ + _this.getColor({ + type:"mouseup", + clientX: _this.options.backupLocation[0]+6, + clientY: _this.options.backupLocation[1]+6, + }); + _this.options.backupLocation.length = 0; + _this.colourCursorGroup.fillColour[3] = 1 - (this.value)/100; + _this.colourCursorGroup.notify("onDraw"); + return; + } + } + + colorPicker.copyArr(_this.outputColour,[thisColor[0]/255,thisColor[1]/255,thisColor[2]/255]); + + _this.setDefaultValue(win); + _this.notifyColor(win); + _this.updateCursor(win); + + _this.setCursorLocation (_this.outputColour); + + if(this.value == 0){ + _this.options.shouldUpdateCursor = true; + }else{ + _this.options.shouldUpdateCursor = false; + } + + + if(_this.options.backupLocation.length == 0){ + colorPicker.copyArr(_this.options.backupLocation,_this.colourSelectCursor.location); + } + + _this.colourCursorGroup.fillColour[3] = 1 - (this.value)/100; + _this.colourCursorGroup.notify("onDraw"); + + } + + win.editor.gulu.uni.unicode.onChange= function(){ + var hexHere="0x"+this.text; + var eV=0; + if(colorPicker.isHex (this.text) == false && colorPicker.isShortHex(this.text) == false){ + this.text = colorPicker.RgbToHex (_this.outputColour); + eV=1; + } + if(eV==0){ + var rgbHere= (this.text.length == 6) ? colorPicker.parseHex (this.text): colorPicker.parseShortHex (this.text); + colorPicker.copyArr(_this.outputColour,rgbHere); + _this.setDefaultValue(win); + _this.setCursorLocation(rgbHere); + _this.notifyColor(win); + } + } + +} + +colorPicker.prototype.updateCursor = function(win) { + if (colorPicker.arraysEqual(this.colourSelectCursor.strokeColour,[1,1,1])) { + if (win.slider.value > 63) + this.colourSelectCursor.strokeColour = [0,0,0]; + } else if (colorPicker.arraysEqual(this.colourSelectCursor.strokeColour,[0,0,0])) { + if (win.slider.value <= 63) + this.colourSelectCursor.strokeColour = [1,1,1]; + } +}; + +colorPicker.prototype.notifyColor = function(win){ + win.editor.gulu.color.notify("onDraw"); +} + +colorPicker.prototype.setCursorLocation= function(inputColor){ + this.colourSelectCursor.location = (function(_this){ + var hsb = colorPicker.RgbToHsb(inputColor); + hsb = colorPicker.convertHsbToKulerHsb(hsb); + var angle = Math.round(hsb[0]); + var length = Math.round(hsb[1]/100*_this.size); + + var point = [length*Math.cos(angle*2*Math.PI/360),length*Math.sin(angle*2*Math.PI/360)]; + + return [point[0]+_this.size,_this.size-point[1]] + })(this) + + this.colourSelectCursor.location = [this.colourSelectCursor.location[0]-this.colourSelectCursor.size[0]/2, + this.colourSelectCursor.location[1]-this.colourSelectCursor.size[1]/2]; +}; + +colorPicker.prototype.bindingKeydown = function(win){ + var _this = this; + + + var keyDownHandle1 = function(k){ + if (k.keyName == "Up") { + if (k.shiftKey == false) { + this.text = parseFloat(this.text) + 1; + } else { + this.text = parseFloat(this.text) + 10; + } + } else if (k.keyName == "Down") { + if (k.shiftKey == false) { + this.text = parseFloat(this.text) - 1; + } else { + this.text = parseFloat(this.text) - 10; + } + } + } + + win.editor.colorHolder.colorCol1.rGroup.rValue.addEventListener('keydown', keyDownHandle1); + win.editor.colorHolder.colorCol2.gGroup.gValue.addEventListener('keydown', keyDownHandle1); + win.editor.colorHolder.colorCol3.bGroup.bValue.addEventListener('keydown', keyDownHandle1); + win.editBright.addEventListener('keydown', keyDownHandle1); + + win.addEventListener('keydown', function (k) { + if (k.keyName == "Escape") { + win.close(); + } + }); + + var leftPressed = false; + + var getColor = this.getColor = function (k) { + _this.options.backupLocation.length = 0; + + if(k.type == "mouseup"){ + leftPressed = false; + }else if(k.type == "mousemove"){ + if(leftPressed == false) + return; + }else if(k.type == "mousedown"){ + leftPressed = true; + } + var point = [k.clientX, k.clientY]; + if(!_this.isInCircle(point)) return; + + var thisColor = _this.getColorFromPoint(point); + thisColor = colorPicker.RgbToHsb(thisColor); + thisColor[2] = win.slider.value; + thisColor = colorPicker.HsbToRgb(thisColor); + + colorPicker.copyArr(_this.outputColour ,[ + thisColor[0]/255, + thisColor[1]/255, + thisColor[2]/255 + ]); + _this.setCursorLocation (_this.outputColour); + _this.setDefaultValue(win); + win.editor.gulu.color.notify("onDraw"); + } + + this.colourCursorGroup.addEventListener ('mouseup', getColor) + this.colourCursorGroup.addEventListener ('mousemove',getColor) + this.colourCursorGroup.addEventListener ('mousedown',getColor) +} + +colorPicker.prototype.isInCircle = function(point){ + return Math.pow (point[0]-this.size, 2) + Math.pow(point[1]-this.size,2) <= Math.pow(this.size,2); +} + +colorPicker.prototype.getColorFromPoint = function(point){ + var transformedPoint = this.transformPoint(point); + var hAndS = this.getAngleAndLength(transformedPoint); + return this.CoreGetColorFromPoint(hAndS[0],hAndS[1]); +} + +colorPicker.prototype.getAngleAndLength = function(point){ + var angle,length; + var x = point[0],y=point[1]; + length =Math.sqrt( x*x + y*y); + angle = Math.atan2(y,x)/Math.PI*180 + if(angle<=0) + angle += 360; + return [angle,length/this.size]; + } + +colorPicker.prototype.transformPoint = function(point){ + var x = point[0]; + var y = point[1]; + return [x-this.size,this.size-y]; + }, + + +colorPicker.prototype.CoreGetColorFromPoint = function(h,s){ + var i; + + var f, p, q, t; + var r=1,g=1,b=1; + var v = 1; + if( s == 0 ) { + v = Math.floor(v*255); + return [v,v,v]; + } + var originHeight = h; + var condition; + var tempI + + if(originHeight<45 && originHeight>=0){ + i = 0; + f = originHeight/90; + }else if(originHeight<120 && originHeight>=45){ + i = 1 + f = (originHeight-45)/(120-45); + }else if(originHeight<180 && originHeight>=120){ + i = 2 + f = (originHeight-120)/(180-120); + }else if(originHeight<220 && originHeight>=180){ + i = 3 + f = (originHeight-180)/(220-180); + }else if(originHeight<275 && originHeight>=220){ + i = 4 + f = (originHeight-220)/(275-220); + }else if(originHeight<320 && originHeight>=275){ + i = 5 + f = (originHeight-275)/(320-275); + }else if(originHeight<360 && originHeight>=320){ + i = 6 + f = (originHeight-320)/(360-320) + } + + p = 1 - s ; + q = 1 - s * f ; + t = 1 - s * ( 1 - f ); + + switch( i ) { + case 0:r = v;g = t;b = p;break; + case 1:r = v;g = 0.5+t/2;b = p;break; + case 2:r = q;g = v;b = p;break; + case 3:r = p;g = v;b = t;break; + case 4:r = p;g = q;b = v;break; + case 5:r = t;g = p;b = v;break; + case 6:r = v;g = p;b = q;break; + + } + return [r,g,b]; +} + +colorPicker.copyArr = function(defaultArr,otherArr){ + while(defaultArr.length!=0){ + defaultArr.pop(); + } + defaultArr.push(otherArr[0]); + defaultArr.push(otherArr[1]); + defaultArr.push(otherArr[2]); + return defaultArr; +} + +colorPicker.HexToRgb = function(hex){ + var ccolorhex = hex.toString(16); + ccolorb = parseInt(ccolorhex.substr(-2), 16); + ccolorg = parseInt(ccolorhex.substr(-4).substr(0, 2), 16); + ccolorr = parseInt(ccolorhex.substr(-6).substr(0, 2), 16); + return [ccolorr / 255, ccolorg / 255, ccolorb / 255]; +} + +colorPicker.RgbToHex = function(rgb){ + var a=(rgb[0]*255).toString(16); + var b=(rgb[1]*255).toString(16); + var c=(rgb[2]*255).toString(16); + if(a.length!=2){ + a="0"+a; + } + if(b.length!=2){ + b="0"+b; + } + if(c.length!=2){ + c="0"+c; + } + return (a+b+c).toUpperCase(); +} + +colorPicker.HsbToRgb = function(hsb){ + var rgb = []; + hsb = [hsb[0], hsb[1] / 100, hsb[2] / 100]; + for (var offset = 240, i = 0; i < 3; i++, offset -= 120) { + x = Math.abs((hsb[0] + offset) %360 - 240); + if (x <= 60) { + rgb[i] = 255; + } else if (60 < x && x < 120) { + rgb[i] = ((1 - (x - 60) / 60) * 255); + } else { + rgb[i] = 0; + } + } + for (var i = 0; i < 3; i++) { + rgb[i] += (255 - rgb[i]) * (1 - hsb[1]); + } + for (var i = 0; i < 3; i++) { + rgb[i] *= hsb[2]; + } + return [rgb[0], rgb[1], rgb[2]] +} + +colorPicker.RgbToHsb = function(rgb){ + rgb = colorPicker.parseColor (rgb); + rgb = [rgb[0]*255,rgb[1]*255,rgb[2]*255] + var hsb = []; + var rearranged=rgb.slice(0); + var maxIndex = 0; + var minIndex = 0; + var tmp; + rearranged.sort(function(a, b) { + return a - b; + }) + for (var i = 0; i < 3; i++) { + if (rearranged[0] == rgb[i]) minIndex = i; + if (rearranged[2] == rgb[i]) maxIndex = i; + } + if(rearranged[2] !=0 ){ + hsb[2] = rearranged[2] / 255; + hsb[1] = 1 - rearranged[0] / rearranged[2]; + if(hsb[1]!=0){ + hsb[0] = maxIndex * 120 + 60 * (rearranged[1] / hsb[1] / rearranged[2] + (1 - 1 / hsb[1])) * ((maxIndex - minIndex + 3) % 3 == 1 ? 1 : -1); + hsb[0] = (hsb[0] + 360) % 360; + }else{ + hsb[0] =0; + } + }else{ + hsb[2]=0; + hsb[1]=0; + hsb[0]=0; + } + return [Math.round(hsb[0]), Math.round(hsb[1] * 100), Math.round(hsb[2] * 100)]; +} + +colorPicker.convertHsbToKulerHsb = function(hsb){ + var originHeight = hsb[0]; + var s = hsb[1], b = hsb[2]; + var i,f,h; + if(originHeight<30 && originHeight>=0){ + + h = (originHeight-0)/(30-0)*(45-0)+0; + + }else if(originHeight<60 && originHeight>=30){ + h = (originHeight-30)/(60-30)*(120-45)+45; + + }else if(originHeight<120 && originHeight>=60){ + h = (originHeight-60)/(120-60)*(180-120)+120; + + }else if(originHeight<180 && originHeight>=120){ + h = (originHeight-120)/(180-120)*(220-180)+180; + + }else if(originHeight<240 && originHeight>=180){ + h = (originHeight-180)/(240-180)*(275-220)+220; + + }else if(originHeight<300 && originHeight>=240){ + h = (originHeight-240)/(300-240)*(320-275)+275; + + }else if(originHeight<360 && originHeight>=300){ + h = (originHeight-300)/(360-300)*(360-320)+320; + + }else{ + return hsb; + } + + return [h,s,b]; + +} + + + +colorPicker.isType = function(content,type){ + return Object.prototype.toString.call(content) == "[object "+type+"]" +} + +colorPicker.isRgb = function(rgbArr){ + if(!rgbArr) + return false; + + if(!colorPicker.isType(rgbArr,"Array")) + return false; + + if(rgbArr.length != 3) + return false; + + for(var i =0,len = rgbArr.length;i1 || rgbArr[i]<0) + return false; + } + + return true; +} + +colorPicker.isLargeRgb = function(rgbArr){ + if(!rgbArr) + return false; + + if(!colorPicker.isType(rgbArr,"Array")) + return false; + + if(rgbArr.length != 3) + return false; + + for(var i =0,len = rgbArr.length;i255 || rgbArr[i]<0) + return false; + } + + return true; +} + + +colorPicker.isHex = function(hexStr){ + if(!hexStr) + return false; + + if(!colorPicker.isType(hexStr,"String")) + return false; + + if(hexStr.length != 6) + return false; + + + var arr = ["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"]; + var isHex = true; + hexStr = hexStr.toUpperCase(); + for(var i=0,len = hexStr.length;i360 || hsbArr[0]<0) return false; + if(hsbArr[1]>100 || hsbArr[1]<0) return false; + if(hsbArr[2]>100 || hsbArr[2]<0) return false; + + + return true; +} + +colorPicker.parseRgb = function(inputValue){ + return inputValue; +} + +colorPicker.parseLargeRgb = function(inputValue){ + var arr = [inputValue[0]/255,inputValue[1]/255,inputValue[2]/255]; + return arr; +} + +colorPicker.parseHex = function(inputValue){ + return colorPicker.HexToRgb("0x"+inputValue); +} + +colorPicker.parseShortHex = function(inputValue){ + inputValue = inputValue.toUpperCase(); + var hex = "0x"+inputValue[0].toString() + inputValue[0].toString() + +inputValue[1].toString() +inputValue[1].toString() + +inputValue[2].toString() +inputValue[2].toString(); + return colorPicker.HexToRgb(hex); +} + +colorPicker.parseHsb = function(inputValue){ + var hsb = [inputValue[0],inputValue[1],inputValue[2]]; + return colorPicker.parseLargeRgb(colorPicker.HsbToRgb (hsb)); +} + +colorPicker.arrayIndexOf = function(arr,str){ + for(var i=0,len = arr.length;i\u00E7T*\x02I\u0088\x04A\u00D4hLT\u00BC\b-\bb\x0B\x11[\u00EDn\x04\u00FBj\u00BC\u00F8k\x105\u00B7\u00EDn\x1Ft\u00B7^_\r\u00AD\x17\u00C5\u00A6\x01\u00DB\u009F\u00B7\u00B1\x1BE\u00BD`@\x1E\"\u00D7\u0080\u00A1\u0095\u0097B\b\x10\f\x1D\b\t\x18\b\x04\b\u00AF\u00DEO\u00C6[\x06\u00E8\u008D\u0090\u00C5-h\u008B\u00BD\u0090\u00BE\x1F2\u008E\u00806\x00\x02@\x01\b\u00BA\u009C\x00\u009D\u00ED\u0086\u00B6\x07`9<\x10\u0083\u00EC\x1E\u0081\u008D\u00BD\u00E3\u00AC\x7F\u00B1\u00C9\u00EE\u009B\u00BA|\u00C5\r\u00D2\u00BE\u00F2Zi\u00A7~a~\u00E2\u00FD>'\u00F7\u00FB\u00AAk0\u00FF\u00FAO\u008F\u00FA\u00D0O\u00CD\u0086]\u00FB\u008F\u00F1\u0094\x1Co_B\u0093c=\u0080\u00E3\u00ED\u008E\u00B5\u00DE?\u00F5 \x197\u00BFu\\^\u00FE\u00F0\u00BE\u00F5\u00C1o\u0092\u00C5\u00CDg\u00E9\u00F2\u008630\u00DEx\u009An\u00DE \u00C3\u00E2F\u00A8\u00DE\x02\u00C56\u00A0\u008A\u00D6gh\u00AA\x10\u0085\u00D19:\u00A0\x02h\x07\x7F\x12\x00\u00D2\u00FD\u008B\u008A\u00FD\u00A2\u0080\u00EA\b\u0085@\u00B4\x01\u00BDC\u00BA\x02*PQ(\x06@;D\u00ED\u00B2\u00A5\u00AE\x01r?\u00C8\u00FCd\f\u00B3Su\u00B9~\u00EA\u00B5m~\u00D2U2\u00BF\u00FF\u0095\u008B\u00FB\u009F\u00F9\x0F\u00EB\x0Fx\u00CC\x152?\u00E5r\u0091\u00AF\u00B9\u00EEX\u00CD\u00DD\u00F1v\u00C7\u00DBq\u0086p\x0Fl\u00AA\u00B7\u0091\u00F7\u0097\u008E\u00F0\u00AELl1*\u00E8\x1E\u0086\u00BD}\u00E27b8\u00ED\u00BB\u00FF\u00AE\u009D\u00FE/^4<\u00F0\u00B1\x7F#\u00ED~\u0087\u009A\u0091\u00E3m\u00A5\x1Dg\b\u00B7\u00D3Tu\u00D0\u00E5[\x7Fd\u00EC\x17\u00FC\u009A.\u00FE\u00FA\x11\u00D2?\u0085\x06E\u00EB\u0087\u0080\x00U\u00AA\x020\u0082.Q<\x13\u0098\u008E\t\u00EC\u008F\u00F3\u00E1\f\u00A1\u00C2w\u0091 \x10\u00B3\u00C0\x17\u0086\u00D0\u008D!Xs\u0086\u00B0\u00AA\u009E\u0094\u00E1I7\u00D7^\u00C4\x0F\u0088\x13\x1D\x10\u00FF\u00D2\u00E2OF\x116\fu\x1BF\u00C0w\u00F7Hja\b(\fI\x0BC\x0B&\u0092\f&\x18\u0082O\u0090I})\u00FCU\u008B'%\u00BD/\u00DA\x01\x14\u00B4\u0090\x0F\u00E8j\u0084\x02\x18\u00E7PUl\u009Ep\n\u00F0\u00E0\u00EF\u00B9l\u00FEuO~\u00FE\u00EC\u00C1\u00FF\u00E4/d8\u00A5@\u00B9\u00E3m\u00B5\x1Dg\b\u0087i\u00AA\u00D7\x0F\u00D0\x0F?M\x17\u00AF\x7FN_\u00BE\u00F1\u00AC\u00A1_\x0B\u00C8\u00B6/H\u0087\u00E0h\x00z\x12+\u00CA\u0084V=~\x07\u00E4OF\u00D0\x1D\u00FE\u008AN\u00AE\u009E\u00C2k0\u008F\u00C0m\x06\u00BD\x10g\u0091\u00DE\u00ADx!v\u00A8,D\x1C\x107\u00D8\u00F9u\x18w\u00BA\x12\x15\x19i\u00B8\u00D4\u00B8n\u00E2\u00FA\u00F4F\u00F5\u0081\u00AAC\u00C48L\u0090\u008D\u00DB\x1DbNJ|D\x18:]\u00B5\u00D0\x16@H\u00DCf\x10h\u00896\x14\u00F5\u00F9%##\u00E3\u0099\u00DC3U.\u00ED\u00C0b~\n\u00F0\u0090\u00B3\u00AF\x1C\u00BE\u00FE\u009F?o\u00F8\u00EA\x1F|\u008D\u00C8\u00C9\u00C7\x19\u00C3!\u00DAq\u0086\u00B0\u00D2TU\u00FA\u00F8\u008E\x1F\u00D6\u00F1\u0082\u00E7\x02\u00AF\u00FDf\x19o@\u00EB\u00DB)\u00C6}\u00D1\u0086qK\u00A6D\u00DC\u0082Z\x14\x13\u00A3Xa\b\n\x14(\\\u00AC\u00ED\u00AB\u00AF\u00A3\u00B8(\u00ABI\u0081\u00C4%+\f \rx\u00E5F;`u\u00D1\u00F3\u00CB\u00B8\u00C4\u00EFA\u00DBF\u00C0w\x12\u00F1\x04\u00D9PUQg\b9\u008E\n\u00E3\u0095\u00FF\u00E9S7\u00A4B\u0092\u00D0\u00E3\u00F9z\u00AA,Z\u0080E\u00D7\u00F0b\u00D49RG(D:\u0093\u00A0\u00AA\x1A}\u00C9\u0081i\x03\u00C6\u008E\u00ED\u00F9\x03\u00D0\x1F\u00F6O?2\u00FF\u00FA\x1F\u00FC\u008D~\u00EA\u00F7\u00BD~m\u00D7)\u00C7U\u0089\u00D2\u008E3\u0084\u00D2\u00C6\u00F1\u00D2\u00B3u|\u00D5\x0B\u00B4\u00BF\u00E1\u00D1\rW\u00FB\u00E2\x1E'\u00BA\u00B2-22\x04\u0087\u00CFe\u0091N\x18\x02m\x00\u00AB\fA\u009C!t\u00B1K\u008B\u00B4\u009B\u00BC\x12^W \u00B3\u00B2\u0083\u00C2\x10\u00E0\u00A7u]\u00F5: u\u00ED\u00C9\u0083\u008A\u008F\u00DD\u00CE\u00A9\u00C6;\t\u00D5\x00\u00888\u0084\u00A2\u00E2\u0098+\x12\u0080v'J\u0089\u0090\u00A2\u00C9\u00BD\u009COtOz\u0092\x12c@\x04!\u00D5\u00CB\u0081>\u0091\u00F0]\u00BD\u00D7C1\x04\u00D1D!=\x19\u00E4\x04\u00BA\u00F4\u00B6\u00C2\x10`>RiP\fX\u00CENA\u00FF\u00EA\u00EF\u00BF\x04\u00DFr\u00CE\u00AFl<\u00E8\u00C9\x7F\u0087\u00E3\r\u00C0q\u0086\x00\x00\u00E8\u00FA\u00E13\u00FB\u00F8W\u00BF\u0083\u00EDW=\u00B9\rW\x01\u00D8\u0086\u00D0\u00FAM\x1D\u00BEH\u00D2$\x14\u0093`\u00D5\x18\x16m\u0095\bU\u00A0\u00BDO\u0088\x15\u00B1\u00C8W~\u00B3;\u00D9OaX+\x04\x15\u0092\u00BE\x01\u00BA\u00F4\u00F3\u008C \u00D3\u00A2O\u0082\u00F3{\u00D7\x1B\x15\u00EB?\x01\u00800\nq\x15U\u00D0\u00C0X=\x10\u00B4a\u00DC\u00CE\u00B3P\u00B5\u0089\u009F\x14h+\u00AAC\x18]\u00FBT\u00AD\u00D22\u009F\u0093x\x05m\u00C6a\u00C2\u00FD\u0088dj<\u00DE\u0089X\u008C\u00D9H\u00A7\u00E7\x04\u00C1\u00C8\u00CC%\u00DA\u00B0\u00BD\u00FBk\u00A0_}\u00F6\x05\x1B\x0F\u00FF\u00F1\u00FFKN~\u00C2G\u00F1e\u00DE\u00BE\u00AC\x19\u0082\u00EA\u00A7\u00EE?\u008Eo\u00FB\r\u00ED\u00AF\u00FD\u00B9\u0086w\u00CE\x1B:\u0080\x11\x1A\u00BEr$\u00E1\u00C3\u008Cq\u0093\u00EC@\u0097\u00E0i\u00F4\u0092\u00C95\u00AB\fbjq/\u00FFR\bWi]\u00FB\u00AA\u00F7\u008C\u00B1\u008B\u00DF\u0097H\x05\u00A0:0\u0085\u00CE\u00DEw\u00B9\u0098\f\u00A5Q(ke\b+\u00CF0\u0089E :\u00C8\u0098\x04E\u00BA\nWU\u0098I\u00CE\u0084\x16\u0086\u0080\u00D2\x1F\x19\x02\u009F\u00BF\u00CC\x17m#S\u0082'\u00F4\u00D0\u00B8\x06\u00F5\u009C\u00BE\u00C2\x10 \u00AE\u00D6\u00D0k\u00D3\x11\x01Vj\u0091\u009D#\u0080\u00F1\u00E4oY\u00C8\u00D7\u00FD\u00E0\u00EF\u00AF}\u00EB\u008F?W\u00D6\u00CF\u00DC\u0083/\u00D3\u00F6e\u00C9\x10\u00C6qK\u009A\u00BE\u00ED\x19\x1D\x7F\u00FE\u00C2\u00AEox\u00D0L\u00F6B\u00A5\u00E7\"\u00EE2\u00CD1\x00\u00A0\u00AD\u00A1\u00FB\u00E2m!\x11\u009DI8\u0094\x15\x14\t*\u0098\x12\u00BF\x1B\x00W\u00E1;\u00D5\x07\x1DI\\\u00F6\u00BB\x14D\u0090\x12\u00D8\x16\u00B8\rK]\u00EFoa|c\u00EB\x0E\u00C7\x05\u0088 \u00A1\t3q\u0084\u00DE\u00BA\u00A07u\u00C8\r\u0084[\x10\u0080\u00D6\u00EC\u00C4\u009A\x13\u00A1\u0080\u00A2\x01}\u00CCHG\u0097\u00EE4\u00A70@s5\u0089\u008A\f!\u00DC\u008C\u0095!`\u00FA\u00FC6^\u0081\u008EN\u00D4\u0095\u00A1\x16\u00DBF\f\u0093Lal\u0089J\u0098\u00A7\u00C1\u00CC\u00CB`\bD\b\u00D3\u00F7\u00B1\u00A5s\u00E8iO\u00BC\u00AE\u009Du\u00CE/\u00EB\u00D7\u00FE\u00D0+66N]y[\u00F7\u00FD\u00F6e\u00C7\x10\u00B4_qV\u00D7\u00BFx\t\u00FA+\u009E\u0088\u00E1\u0093\u0096[P\u00CD\u00EC\u00AB\b .\u00AC\x04M\u00A3\u0095QVD\u00F0\u00D5\u00A0\x1E\u0094\u00EB\x15\x0E\u00BD\u00D9w1pS\x1D \u0095\u00C6}\x0FaK\u0088\u00CF2\u00FDL\u0094P\u00A5\u00AA\u009FP\u00DDv\t\u00DF\u0093@\u00A4{\x05%WM\u00EATD\u00CA4\u00C7\u00C2\u0080*\u00B1\u00AAI\u00F0k\u00D9\u00A8\u00DA\u00D4\u00FBs\u00CE\u0098CAU\"]\u00B45_B\u00A6\u00CF\n\u0089\u00E8E\x16{YuA\u00C2]\u0090;T\u0096.1\u0096L\u00E8B0>\u00DE&\f\u009B\u0081Z\x06\u008C\u00EDT,N\u00FF\u00A7\u00EFX\u00FF\u00DF\u009E\u00FEo\u0087\x07=\u00E9J|\x19\u00B5/\x1B\u0086\u00A0\u00BAw\u00DE\u00FB\x1B~u\u00C4\u009F>[\u00E5]\u00EB\x03\u00B6\u00C3\x1C\u00B8#\u00E30\u008C\u0081\u00E9\u00DF?$CpW\u009C\u00C6\"n\t\u00E3\u0081)C\u00A1\x1B/\u00EE\u00B3B\u00E0\u00BCn\u00C2\u0088n\u00DB\u00C08\u00D5\u00F7ih3\u00C2\u00AB\b\u00A5\x05\u00A1\u00EEd\b\u00E1Jt\u00A9)u\f\u00D5]*\x00F\u00DE{\u0088\u00EB\u008C!\u00FA)\u00E5>\u00BC\u00FF\u00E1\x19B\u00CE\x19B\x05Xa\b\x13\u00E6\x027\u00A4\u0096\u00E7\u0087\u008F\u00A9\u0097w\x13\u0088$\x19B\u00A83\u00EC\u00BB\x0B\u00BA[U\u009A\u00A3\u008DV\u00E7s\\G\u00EFKl\u009D\u00F2\u00AD[\u00C3YO\u00FB\u00ED\u00B53\u00FF\u00E5\x7F\u0091\x13\u00BFz\u0081/\u0083\u00F6e\u00C1\x10T/}\u00E4v\x7F\u00F9\u00CB\u00C6\u00FE\u00DAG\u00CCf7`\x00Cy:F\u00E4\u0082\x05\x17q\r\u00ACA\u00EA\u00C6\u0094\u0096\u00D5\x16\u00C0\f=\u00E1a^3\u0089C\u00C0\u00E4z\u0088CeU\u00FBL\u00C8\u00DF\u00F34\u00A9\u00D7y\u00F4\u00A0z\u0090S\u00B5\u00D8\x1Bn\u0097B\u00D4\u0085\u00DFh\u009E2\u00D1\u00C5\u00EB\u00DC\u0090\u0089\x157\u00E0\u00A4\u00C2\x11k\x1C\u0084-A\x10\u00B6\x04\u009B\u0080D'%8\u00A9\u00D7{\u00D5\u00FB\x1F\u00C2\u00E3\u00C0\u00FB'\u0093J\u0086Y\u00F3\x1Bb\u00DE\u00BB\u00E4\u00C2-\f!\u00CE\x1B=\u009C\u00DB\u009F\u00C5\u0090P\u00CE\u0087M\u00A33\u00A7C1\u0084\u00CE\u00C7j\u00E8\u00B2\x0B\u008B\u00D3\u00FF\u00D9e\u00B3o>\u00E7'\u00D7\u00BE\u00EEG\u00EF\u00F3\u00A1\u00D0\u00F7i\u00860\u00EA\u00FE\u00D9\u00F6\u00F2u\u00FFq\u00D9^\u00F6\x1C\u0095w\u00CF\u009B\u008C\u0098\x01\u0098\u00C1\x18\u0082\u00D0\u00D4\u00A6\f4*R\u00A4\"\x05\u00B6j4\u00F3\u0096\u00C4\u00E6zt@\u00D0\u00DB20\u00D6E_\u00EE;1\b\u00A2\u00F4#y\u0080\x16\x7F\u00F6\x13\u00FD!\u00FA\\5\u00E4\u00ED0\u0084N\f\n-$(\x0F\u00D1\u00F7_\u0087/\x15\u0095T\u00AF\u0087GlV\x064E.+\u00DF\u00CB_\u00CD\u00AF\u00A8\u00E3\\5\u00BE\u00F2\x1D\u00C5\u00FD\u0082\u00D9H\x06$\u00D1\u00C8\x19\u008Cg\u0085!\u00F8\u009C\u00D7w\x156\u0099nk\x01\u00CEl8\x07\u00E8\u00E6\u00A1\u00E8\u00DA\u00B0}\u00CA7.\u00E4\u00E1?\u00FA\u00BC\u00F5\u0087\u00FF\u00EB\u00FF,\u00EB\u00A7-q\x1Fm\u00F7Y\u00860\u008E\u0097\u009F\u00B1\x1F\x7F\u00F6\u008A\x03\u00F2\u00F2\u00EFX\u00C3u\x18\f\x00`\x06\u00C5\f\x02\u00F3F{\u008B\u0090W\u00EA\u00F0\u0085\u0088\u008B\u00D4?\x1CC\x00\x1C)L\x16\u00F2a\u00EC\t\u00F0\u00FE\x0E\x15\u00FA\x1C\u00F6\x04\u009D\u00DE\u00B72\x04 u\u00E6\x18W\u00C6\x06L\x18\x02\u0092\u00D0\x12\u00A6\u00AF\u00BA \u0093Xz\x19+m\x0F;\x19\u0082\x06\u00D1\u00C4X\u0090C\x16\x7F\u008EP\x11\u00D8\u00DF\u00E1\\\u0090\u0085\u0090s.W\u0090\u008C\x02\x1Ah\ra\u00EF\b5\u008C\f\u00A1\x04rU\u00A6\x15\u00B6\x02\u00C0S\u00C8\x0BCX\u00AD\u00F9@d\u00D1\x01\x19\u00ED\u00B7\u008E\x01\u00AA\x02\u00C5.\u008Cg<\u00E5}k\u00FF\u00E8'\u009F\u00D1\u00BE\u00EA{\u00AF\u00C2}\u00B0\u00DD'\x19\u00C2\u00A6\u00FE\u00E5O\u00EC\u00D5\u0097\u00BEx\u0081\u00B7\u009F8\u0093%\x06tg\x02\u0086\fLeP\u00CC\x14hu\x06V\nt\u00C4B\u00ED\u00AB\u00D3\u00B4s\x11\u00D7H\u00BE\u0094v\u00A5\u00D8I\u00B94\u00FA\u00C7\u008A\u0095\u00BD\x10!\u00EF\u00A8\u00BD\x10c\u009C\u00A7IP\u0093\x03\u0094\u008A\x19\u00E4\u0093:|J\u00CFU>\x04PZ\u00D3X\u00DA\u0083\u00B8\u00E9\u00CB\u00AF\u00EAG\u00CC\u00D5\u00A4\b\u008AzAW/\u00D3\u00EE\x07\u00E8\x05\u0088\u00BA\u008B\n0\u0097\u0082\x1E\u0087\f=&GX\u00B5%\u00DC\x06C\x00\u0092A\u00B2\n\u00F5\u00EAs\u0086\u0097\u00E1(\x18\u00C2d^\x15\u00AA\r\u009B\x0F|\u00CC\u00BE\u00D9\u00B7\u00FD\x1F?\u00BF\u00FEm\u00FF\u00E1\u00E5;g\u00F2\u00DE\u00DD\u00EES\f\u00A1\u00EBU'\u00DE\u00DA\u00DF\u00F4\u0092\u00BD\u00F2\u00E2\u00A7\u008F\u00F8\x14\x06\u00E9\u0098A1\u00A8\u00AB\t\x02\fh\u00CE\x10z0\u0084\u00A9\u00DE[\u00F4SMC\x1DP\u00A5\u0096\x11\u0089\u00ADWM\u00F8\u00AA\u00E5\x1A\x05\u00CC\u00C8\u00A8+\u00E8 \u00FB\x06\x122\u00F3\x10m\x18S\u0086\u00E0\u00FD\u00C7y\u008A\u00ACPT\u0099\x18\u008D\u00A1=nQ\x19B\u00DC\u00B6\u008E\u00B7\\+\u008E4*\u00CC\u00D6J,X\u00C9\u00C2\f\x02\"#\u00EC\u00F1]\u00DC\u00A8\u00A2\u0085\u00C8\x15E\u00A5\u00F2\u00F1\u00F3\u0099'\u0092\x1E8D\u00A0\x12\u00C7\u0088T)\u00F8\x1C4*\u00D6|\x06\u008Em\u00C5-\x19\f\u0096\u00CF\u00B5\u00C2\u00D4\u00AA\u00CA\x10\u00C9^nS`\u009F\x1D\r\u00E3\u00DA)\u00C07=\u00E3\u0095k\u00DF\u00F5o\u00FE\u00AD\u009Cp\u00C6}\u00A6\x18\u00EC}\u0086!l\u00E9\u00DF?\u00FC\u0096\u00F1O_w\x13^q\u00D6l\u00B8\x15\r\u00C0\\\u00A9\"\x00\x03\x04\u0083\x003/f&P\u00AC)m\t\u00B0\x1A\u00A3\x00@\u00E9L?\u00FE\u008A\u00E4\u0098X\u00B2U\u00D0\u00D1\u00C3S\u00D1'\x0B\u0096\u00BA?\u00AF)\u00D4W\u00BFW\x1BE=\u00CE\\\u0087\u0090\u00CC+\u00AFj\u0087\u00DA\u00C01\u00EA\u008E{\u00A9\x1B\x02E\x07\u00C0]y\u0082\x16L\u00CDG\t\u00BA?\u00ED7~\u00F6\x10\u00E9\u00F8k;\u00EF\u00EB\f*m\x18|\u00B6\u009E\u008C\b\u00F4\x04\u00D896\u00C7\u009A\u00CF\x11:|_\u00E9\u00BF0\u0085\u00A2\u008AL\x18\x02\u0099X\u00ECSAC\u00E5j\u0090\u0092\u00A3\u00BD.9\u00CE\u0082\u00B22\u00E9+\u00E7\u00D3\x18\u0083\x04C\u00A0\u00F1R\u00D1\u00A0}\u008E\u00ED\u00AF\u00FB\u009E+7\u00BE\u00FD'\u00CE\x19N?\u00E7\u008AC\u00BC\u00C9{]\u00BBO0\u0084}\u00FD\u008D?v}\x7F\u00C9\x1F\u00ED\u0093\u00B7\u00EC\u009EA14\u00B3\x0F\u00CC\u00D4U\x03\x18Ch\x02\u00CC\u0091L`\u00EEv\u0084\u00AC\u00BDS\u00BC\x055\x18\u00C6\u008F)-\u00E4Q/\x00\x18\u00A1\u0093\x12b;\u00A5j\u00EA\u00E8\u00D1\u00AAd\x0E=\u0098\x18\x7F\u00A5@I\u00FC[\u00CE\u009F\x1Co\u00D9\x15\x17q,\u00FE9h\u00B57\x1B\u00C7\x00\u00E8,\u009F\u00CF\u00AF\x11\u00DE7\u00AE_a@\u0094\u00AE!\u00A5\u00D5C&\u0082\u00DA\u00D3\u00D7\x0Fx0T\u00CEA\x10?\f1\u00D8\u009C*DGG\x15=\u00BD*\u009C\x06g&\u00AB\u00F3\u009F^\u0088\u00A9\u00B1\u0094j\x14\x19\u0085\u00A1\u0085\x12\u00A4\u00C4k<\u0098,\x10\u00C5\u00B8\u00CA\x10\u00AA\r\u00A7\u0099g\u00A7\u00A3xr\u00CA\u00BCu@\u00BB`\u00FB\u0094o\u00DD\u008FG\u009F\u00FB\u00AF6\x1E\u00F5\u00F3\u00AF\u00C6\u00BD\u00BC\u00DD\u00AB\x19\u00C2Ro\x1En\u00EE\u00AFz\u00E1u\u00FD\x0F~a{v\x15\x1A\u00B6ME\u0080\x18C\u0080\u00BA\u00CD@\\= s\u00B0s\x1A\x14s\u00FF\u0097d\x15\f\u00A1 \x04JPJ\x0B4\u0087\u00FA\u00AAQ^\u00B02\x04(-\u00F6\\\u00B8\u00AB\u00F0\u00BC|\x16\u00B8>~\x1B\f\u0081\u00D7P\"\u00FAw\x052N\x1F\u00CD\t\u00BE\x19\u00E1\u0088B\u00FAZH}\u00AA0\u00CCc\u00A8\x03\u0091p%\u0096sw\u008CYr\fa|M\u00E1n\x04R~<\u00DC\u00F8u4\"#aw\u00AF\u00D5\b\u00B7\u00F4w\u0086\u008F\u008F\u00A0\u00CA!\u00D0\u00A9[\u00D7\u00FB]\rR\u00EA\u00BD\x04b9\x11O\x1E\u00D5\u0089\u00B8\u00FB\u00FC\u00EEd\b\u0098x,\u00A6\bA\u00C1P\u00E7\f\u00F62T\u00A2\x10,\u00D7O\u0083~\u00FB\u00D3\x7Fw\u00ED\x1F?\u00EB\u0097ex\u00E8\u00BD6\u00B5\u00FA^\u00CB\x10\x0E\u00EA'O\u00BA\u00BE\u00BF\u00EC5\u00D7\u00EB\x7F\u00FF\u00BE\u00DE\u00F6\u00B8}\u00A0\u00FB\u009F`\x0E\u00C1\u00CC%\u00D1\x00\u00C1\f\u0082A\u00D4\u0098\u0084\u00C2\u00D5\x07\t\u00840\x14\u00A6p(\u00E2c\u00E8\u00AD\u00D9\x05\u00AA\u0095\u00DE\u00FF\r]\u00B9\u00F8\u00E8A\x1D\u00FA0(A\u00F3\x16v\u008F\u0095\u00E3E\u008FN\u00D4\u00C2\u00E2\u00A7\u00FC\u00D7\u00EEi\u00F9\tm\u0082\x00Z$#\u00B5\u00F2<\u00AD\u00D4\\\u00A4-\u00C0\u00F5\u00FE\x18\u00BF\u0096gpc\u009C3\u008B\u0088\u00AF\u00A0z\x00E\u00A6\u0083\u00AF$H\u00A1F\x17\u00F22\u008D\u00E8H\x06\x1A1\u0095\x1APHw\u008F^\x1F\u00BD\u00EF\x0EQ\u00CB?P\u00EF\u00AFi\u0086N\u00C7s\u0089\u0098\u00CA0\u00F6\t\u00D2\u00C8\u00B9l\u008E \u00EC\u00DA(#\x07\u0084=\u00C3\u00C2\u00B0Q\x10\x06\x19\u00BFLl!\u0093\u00EC\u00CA\u00D2\u00C7\x12\u00BB\u00B1x\u00F8\u008F\u00BCe\u00E3;\u00FF\u00DD\u00D3\u00DAW>\u00EA^Y\r\u00FA^\u00C9\x106\u00F5\u00B2o\u00F8\u00F4\u00F8\u00E2\x0B>\u0083W\u009E9o\u00DB\u0098\u00A1\x192\x10\r\u00860\u0080\u00EA\u0081\x19\x15\x07\x11\fP\u00FB\u00CD\x19\u0082\u009D\u00A7\u00E9\u0081P\u00844\u009A2\u0084b`(\u008B\u00DB\u008E\x15\t\u00C8s\u00AB\u00F4\u009C\x14,\x05d\u0095)H\u00E9s\u00D5\u009E@F\u00E4\u00A3\u00B2HB\u00C38F\u00B8\u00CD\u0089}\u00F0\u00FE\u00E9G\u00A1E\u00DF\x18\u00C2\u0084p*\x13@\u00F3b\u00A5q\u00A3x\u00D6\u0088\u00CB\x00b\u00EC\u00D3}\"\u008DP\u00BA\u00DF\u00C7\u00A4\u00B2)\u00F1B\u00D8@&\u00B7\x03)\u0088\u00A3\u008C\u00D1\u00C7\u0099\u00D7di4\u00BAPml\u00A2#\x14\x0B\u00A8v\u00B4b\u00A7\u0090\u0092\u00DF\u0081\x11\x11\u00BCU\u00FFjH\u00B5\u00A83\u008E\u0089\u00AD\u00E30\fa\x15!\u00F8\u00FB\u00AD\f!\x12\u00DE:\u00A0\u00E3\u0080\x0E\u00C1\u00F2\u00F4\x1F\u00F8\u00E8\u00FAc\u00FF\u00CF'\u00CB\x19?\u00F4q\u00DC\u00CB\u00DA\u00BD\u008E!\u00EC\u00D1\u008B\u00BE\u00EB\u00EA\u00E5\u00EF\u009E\x7F\u00ED\u00F0\u00A6S\x06,\u00B0\u00AE\u00DD<\x07\u008D\u00AA\u0080\u00D9\x05\u00A6\x7Fb\u00AA\u0082*f\u0082\u00C2 \u00D2\x0598S\x18T\u00D1\\0\u0087\x1E\x1D\u0095\u008B\u00FCo\u00E2\u00EE#\u00E5\u00AFD0N\u00A2\u00FE\u00EC8\u00ED\x12\x13\u00A4P\u0098L\u00E8\u00C0q\u00C8\u0089^\x07'\u00FA6\u00FDW\u00C5\u00C7F\u0086\x01\x7F\u009A\u00FCl\u00E3ru\u00A0,^2\u0090\u0090\u00D4\x00\x18\u0085\x18F\u00D1\t!3\u00BEA1\u0089\u00E0,\u00EED\u00D0\x00\t>\u00B7&\u00DA\u0098\x140\u00D1\u00F2\x07\u00D4B\u00AB\u0093\u00DF\u00B4g\u00BC\u0086.m\u00EA\u00B5\u00A31\\\u00DA\u00D1\x03\u009Ci\u00A0\u00AB\u00AB#\u00F9\u00FEt\u00A4\x1A\u00C1\u00F7\u00E3hf\x05!\u00A4\n\u0086\u009D\f\u0081\b\u00C1\u0099\u00D9\u00E1\x18\x02T\u00D0G`\u00D4\u0086\u00E5\u0083\x1FyS{\u00DCO\u00FE\u00D0\u00C6#~\u00F6\u00A2\u009D\u00AB\u00F8\u009E\u00DB\u00EEU\f\u00E1\u00DA\u00F1/\u00CE\u00B9\u00BA\u00BF\u00F8\u00BC\x1B\u0087wm4\u0098+q\r\u00DD\u0088\u00BC\u00D8\x04\u008C\u00D0i/\x00\x06m\x18\u00C4T\x05C\x12<\u00D7Hf\u00A6\u0082A\x1A\x1Az\u00D8\x1381]=\u00DE\u009DR\r\u00C8p\u00E5\x15\u00A4P\u00E9<\u00F7L\\\u0085\u0096\u0094\u00C8\u00BC.\u00AEp}\u00BA!\u00CA\u00B3\x05\u00F1\u00CF\u00CBg\u00AA\n\u0082\u00D4\u009F\u00AB\u00E5\u00BF\u00D4\x15\fd\u00D0\x10~\u00FC\x12\u00A0d\u00D7\u00A69\u00B5\u00C6\x1Cd\u00E0\x0F\t\u0099\u00CFa\f\u0083?5'\u008A\u0089\u00A4\u00AFAW\x135bu.4%\u00B5\u00C7.h\t\x0E\u00CB\u00A4$'>\x1D\u00C1\u00BD.\u00B42\x03\u00ED\u00E8:\u00A2\u00C5\x1E\u0098Z\u0090\t\u00E7\u0096]\u00B14\u009D\u00A1\x1B\u00E9c\x18\x18\u00A5\u00BA\u0081i\u0083`\u00DC\x02]\u008F\u009C\u00C3\u008A|z\u00F6\u00CFu\u00A0\u00E3\u0080\u00C5Ign\u00EAw\u00FE\u00C4\u008F\u00EFz\u00DC/\u00BF\x0E\u00F7\u0092v\u00AFa\b\u00D7\u008D\u00E7\u00FD\u00FCe\u00FA_\x7Fo\u00DFpEk\x1Ehd\u0084\u00DF=\x1C9\u0089{o\u00D0\u00F5\u00D3\u00D0\u00FF\u00D13\x7Fk\u00EDI\u00BF\u00F4\u00EB\u00B2~\u00F2!\u00D7\u00F9=\u00A5\u00CD\u008E\u00F5\x00n\u00AB\u008Dz\u00B3\\\u00D3_\u00FE{\u00EF\u00D7\u00E7=k\u00FF\u00EC\u00B3\u0098\u00F9\u00E2h\x10\u00F3\u00FF\u009B\u00AC\u00B6\u0080\u00A0X\u00DF\u0096\u00DA*H\x1B\u009D/I\u00C0\t\u009E\u00EF\u0090\u00E0]\u00CBy\u00BE\u00EC\x02\x11\u00D4H\u00C6z\u0092\x00n\u0089\u00AA\u00D2\u0096w\u00948Y\u00D8\u0091\u00A64\u00B7\u00FB\u00B9\u00D2\u00A3\u00FCwf\u00BA>\x1A,\x03\u00D2q\u008D#\x01\u00BB_G\u00E8\u00FD\u00D2 \u00E2\fC\u00A4\u00D0\u008C\u00E4\u00F8\u009Am`\"~\u008E\x11\u00A1\u00D7M$\u008A\u0080B\u00C5~\u00A3\u00C8\u00D7\u00CE\u00F9l\u00E1N\u00E5V\u00F3\u00A2\u00CD9$\u00E2\u00FA` \u00E2\bA(\u00F5;l{8I\u00CD\u00A4\u00DAb8\u00F1\u00CD~o]\x1D\u00BB)\u0080\u00D1\u00F5\x11\u008E\u0093\u00CA}\u00DAa\u00B3o5\u00C6\u00E5\u00FFF\u009C\b\u00D4\u009F\u00DB\u00DC\u009A\u00D6\x15\u00DF\u0089\u0097\u00ACG\u00B0Y\u00F0\u00D2\u00AA\u00C61\x01N@F$\x01\u00AA\x025\x06\u00B7[\u0091\u00AF]0t\u0085\u00EE\u00BF\x0E\u00FD\u00BD/\u00FEO[\u00BA\u00E7\u00FE\u00BA\u00BC\u00F6\u00DF\u00CB\u00EC4\u00C5=\u00B4\u00DDc\x19\u00C2R\x0F\u00B6\u00AB\u00C7\u0097\u00BF\u00F4\u00DD\u00FD\u00B7\u00CE\u00DD\u009A]\u008B9\x14\x0B8\u0087\u00F7\u0085\u00EB\u00B5}<\x1F\u00C1\x16\x12]\u00C9\u00A2\u00C0R\u0082\u00EC\u00D0}\u00A9\x19\x13w\x15\u00C2\u00A1\u00EF\u00E8o\u00B6\u00A9\x1A\u00B3\u00F1\u00F7\x1A\u00B6\u0084\u00A4ooE\u00E2N\x1A\u0097W\u00ADG\u00E00\u009CT\u00AA\u00F4\x10x\u00DEex\x06\u0086\u00F2\u00AF r2\u00E3\u00D9\x04*\u00CD\u00D8a!\u00A4P\x1Fj\x1C\x01\u00F2\u00BE\x12{:\u00B8\u008E\u00EC\u00A3\u00B1\u00E7\u00F2\u00B1\u00D2&\x00\u00EBK\u00A4\u00F4#:}\u00FCbK\u00B1\x1F]4J\u0092\x16\u00DF\u008F\bc\x1E\u008A\u00EA\u0084\x0Ei@\u00D4\u009F\u00AF\u00AEVa\u00C5&\u0085\x15a\u0081\x13\u00B3\u0082\t\u00EB\x12o\u00B8\u0099\u009A\u00E0oU\u00D0,/\x02\n\u00C5h\u00F3\x0F\x010\x022B\u00C5\u00FBq\u00F7\u00A5\u0084\u009A\u00A2\u00ABd<\u0099\u00BF\u00E0\u0093\u00A8\u00AF\u00BF0\u00B3rN=i\x12{\"\u008A6\u00EEG\x7F\u00EFy\u00CF:\u00B8\u00DC\u00DE\u00AD\u00E3M?-\u00C3)\u0087\u008AQ=\u00E6\u00ED\x1E\u00C9\x10\u0096\u00BAg\u00B8r|\u00F1\u009F\\\u00A8/zf\u009F}\x11\x03\u0080\u00A5\u00BB\r;\u0080\u00AE\u00CA\u00EA\u0087q\rQ\u00C1\b_:\u00B1 \u0092I(\u0080%\u00CC\u00A8(\x10\u008C\x10\u0080\x0B\u0085D\f\u00BBX\\\u0092\u00F4\u00E8\u008F\u0092\u0082\x12\b&\x05\u0093n@\u0098\u00C2u\u00A1\x11E\u00D8\u00A0b\u0084/\u00E1\u00E4\u009C\u00C5\u00EF\n\u00B7\x17\u0088\u00A3\x01f_F\u0092v\x04X\u00DBgJb\u00C0T\x06\u008E)\f\u0081\x1C\u00A3\x11\u0097LV\u00EA\n\u0083PJA\u0081\u008A\u00AB\b1\x7F6{\u00C67\u008D\u00C3\u00A9\u008B\u00D2`.\x05I\x00$\u00AF,\u00A7\u00C6\u0098\u008D\u00C8\u00B0\u0094\x01\u00E1NQMi^)\u008Eh\u0086\x1AO \x11\u00F8\u00DC\u008D\x10\u00C9\u00E0&\u00F1\u00B8b\u00CD\u00B2'\u00C68\u00B4\u008A\u0083\x0E\u00C5\x12\r\x1D\u0090%\u00B4\u0099\u00D12\u00EC!\x13\n\u00BF\u00BDv\x18Dp\u0098&\x10\u00CCT\u00A0\u00DB\u00FB\u0080\u00F7\u00BE\u00F2\u00DC\u00ADq>S\u00DDs\u00AE\u00C8\u00FD\u00EFq\x01L\u00F78\u0086\u00B0\u00A5\x07\u00DB\u0087\x17\u00BF\u00FF'\x7F+/x\u00E6r\u00D8\u008B\u00B9sc\n \u0093\x07d\f\u00F6\u00EA\x15U\x05\u00B0%\u00EC\u00CB\x12\u00C5\\er\u00C4\x17XG\u00B7eSP\u00BFi\x00\x1A\u00B0\u00DAH\u0092\u008C\u00C0\u009Ae\u00E7\u00F1\x07\u00814\u00B7*\u00A3\u00D4a\u00CC\u00C30\u00CC\u00E1\u008EO\u009D#\u00AB1\u00E4_\u00E4a\nU\x04\u0087\u00F8\u00F08\u0083\u0080\u00F9\u00EC\u00D9\u0088\u00D7\u00B2%+s\x00\"\u00BC*\u00F0o2\u0096\u00C9\u00D8\u009C\x19$\u00AD\u00B9\x11\u00AF0\u00BB\u00C9\u00D9b\u00E8\f\"@\x1B\u00C2//\u00BC\x17\u00FB\x10\u009B\u00F1@H\"6\u00F3\u00AC\u00D5\u0088\x02>2\u00DA\x0B\x14\u00C3\u00EA8>\u008C\u008E\u00BC>E/R\u00DD\u00E8\u00C6H\u00A1P,\u0091f\u00E1\x0ES\u00A9J\u00FF\x02Ge\u00BD\u00A0\x1CgD\u00BE7\u00DC4\u00A2tU-J\u00E45\u00F1.\u00DD\u00D1\u00E6hqm{\x0B\u00CB\u008B\u00FF\u00F4\u0099\u009B\u00E3\x12z\u00F0s?%\u00BB\x1Er\u008FB\n\u00F7(\u00860\u00EA\u00ADr\u00E9\u00F2\u008F_\u00FA\x0E\u00BC\u00E8\u0099\x07\u00DB\x1E\u00ACa\u0089\u00A6\u00E4\u00F7)\u00E7T\u009C!\u00888X\x04\x00\r\u00E2\x1E\u00E1h\u00D4\u00DFn\u0087\u00A9\u00A3K\u00AA\x06\u00E29\f\u00CA\u00FB\u00DA\u00BF\x12L\u0085\u00CC\u0084\u00EB\u00A3\u00FE\u00B7\u0090\x16\u00E1\u00A4\u00B8J\u0090+\x1D\u00E9\x02\u009CC1\u00F7\u0080\u00A2\u0099\x11=\x04i'pI.\u00E9Q \u00A9I\x1B\\b\x1398t\x0E\u00D1I\u00DD\u00DCg\u00A0\u00AA(\u00BE\u00B5;%xz7\u009A\x11\x00!@\x18Z\u00B4\x1COB\u0097B\x18R\u00E7Bh\x18,\u0093G\x03\u00A2T\x17\u00AC\u00C2\u00D4 \u0083\u00EB9\u0089!\u009E\x1D\x11\u00B8\u00F1\x12\x1AR{\u00BA\u00AD=\x19\u00A11l\u00A5\u00FBQ\u009A\x1Fi@\u00EF\x10LK\u00DA\x01\x1D\u00AC\u00A2\u00CD\u00BC\t3\u00DCv@\x17\u00BEz\x16\u00C6\u00C0V=\x05\u00AB\u00A8a\u00F2Uv\x1E?ls&\u00D7\x01H\u00C3l\u00DC\u00C2\u00F8\u00F7\x7F\u00F6\u00CC\u00ADa\u00B6\u00D4\u00C5-\u00FFJ\u00E6\x0F8\x1A\x16s\u0097\u00B4{\fC\u00D0\u00AD\x11\u0097-_\u00FE{\x7F\u0083\u00DF>\u00F7\u00C0\u00FCzxZ\x0E\x06 \u00F6U\u00E6\u00FA]\u0080\u0081\u0083\u00B1Ja\u0084\u009E\u00F2\u0090\u0088\x00\u00FEy\u0094\u00A9\u00A4\x17X\x18;\rl\u009DF# P\u0085\u008B\u00F8\u00EC7`B\u00ED\u00C9\u00FB\x13\u00B8ZA?\u0085\u00FB5t\x0E\u00E1w)\x01E\u0081\x10\u00F8\u0094D\t\x04\u00E3$b\x0F:\u00A2>\x1E^\x05J\u00B3\u00A2R\x04s\u00A0\u00B4GJ\u00D9\u0096q\x06\u00C6\u009C\\\x01j\u00AE\x0E\x18lr\x06\u00E0\u00E2]\u0087\u0088\u00E1\x07\u00ABR\u00C3\u008E9y\"8bw\x1C\u00A6\u0085\u00B7\u00C0&-=\f-$\u00B3\u00EA\x00\u00B4fx\u00AE'\u00A22\x17\u00A5]-\u0092\x18M\u00BDc\u0081@\u00DBhs\u00C2\u0098\x0E\u00D1\u009C\u0093@\\\u009E8%\x03\u00C4sO\x04n\x10E\u0087\u0088[\u0095\u00B4\x032\x03t\x01\u0095\x11\"N\u00B9\u00BD2#\x7F\u009A\u0098\u00CF\u00FC\u00E9h\u00DB\u00FAr\x13\u00DB\u00EFy\u00D9\u00B9\u00FBe}\u00BF.n\u00FDw2\u00FF\u008A\u00A3\u00EF\u00ECNl\u00F7\x18\u0086\u00F0\u00A1\u00F6\u0087\u00BFy~\x7F\u00FE\u00B3n\u009E\u00DF\u0080\r\u0095p\u00ED.\u008B\u0084\x18\x1C\u00D2Sr\u008Dj\u00CB\u00C5\b\u00DE\u00DE\u00D3\x120i@\u00FA0`\x1A\u008B\u008C\u009F\u0093i\u00E4yD\x15\u00FCNx\u00ABJ\u00C9d\u00AD;\u00BD\u00ACj\u0090*\u00E2\x10v\u00CD\u0099@a\x04\u00D5X\x18\u0084\u00DB\u00CC\u00CE\u00E0\u00C7\r\r{\u00CC\u00814\u0087\u00BD\u00C2\u00CE!\u00AD\x01}@\u00D8\x01\\\u0095\u0080\x1B\x013i\u00A9\u00C4\"\u00F8yS\u0089V\u00D4\u0089\bT2\u00C9n\u00F7*\u00B1\x16\x01\u00CB\u00DA\u00B4o\u00F4\u0082\u0084\u009C\u0088\u0088.B\u00C2W\x1D\u008AP_\u00CAW\u0093\u00DC\x12F\u00C9\u00A2\x0Ex\x1F\u0089*\u009C\u00E1\u00C0\x18\u00958S\u0096\u00F0&\u00901\u00E43ReP\u00FF\u00ACq/z|L\u00BD\x10\x1A\x1A\u00A5\u0085\u00FA\u00E0b\x04\u0081\x15w\u00A8\x0FD\u008De\x0F\u008F\u00BA\x16@\u00DBMY%\x02\u00EF\u00BBA\x1B0loB\u00DF\u00F5\u00B2g\x1D\x18\u0096{\x00\u00FC\u00FA\u008EN\u008EA[]\u00D3\u00C7\u00A4]\u00BE|\u00FD\u00CF\u00BF\u00B6\u00FF\u00DA\x7F\u00BBi\u00F6q\u00CCDqB\x17\u00CC\x04\u0098\u0089bM\x1531S\u00DC\x1AJ$\u00A2*\u00E6\u00B0c\x19ld\tM$\u00C5\u00994Ot\u00B2\u0090f\u00F1\u00F3\"&\x01-\n\u00A8X\u00BD\u0084\x15\u00F9\u00AE\x04\u00FDN\u00BE\u0092\u00E5\u00BB\x01\u0094\u00C0\x19z\r\x06\u0088\x0E@\u00F7\b\b\u009D\u0095\u0085G\"u\u00CF\u00C2J\"\u00920\u00F8(\b/%^\u00A2\x01z(d\u00B2\u00F0\u00E3\u009C\x12\u00C5[\u00C3\u00A5\u00F3\u00BCr\x0E\u0088\x16\u00A8~\u00A0\x04\u00D7\u00F8aU\b}s\u00B5`IHc\u008D\u0090]\u0085Z^A\u00A0\x01\u009D0\u0085\u00DCI\u00DA\u00FF\u008D\x18\x05\u00F6\u00AB\u00C8\u009D\u00B2=\u00A7\u00C13\x1FA/\u0088\u00C7\r\x00\u00DEOw\u0086\u00C1\u00A6c\u00C44\u00D89\x16\u00AB\u00A0,\x19\u00DF\x01\x19\x1D7v5\u00B5\u00A3\u00BBQR\u0097\x1E\u00CB\u00D03\u00A6A\x17\u0088 \u00A7\u00D1\u00E7\u00A3\u00FA\u00B2\u00BB\u00F8\x1E\x1E\x1C\x0B\u0091\u0092]\x16\u0099\u00A8\u00BD\u008C7\n\u00B2\u00F8s/\x05\u00DB\u00EB\u00A7B\u00BF\u00FB'\u009F\u00B5\u00F1\u0094\u00FFr\u00CC\u0083\u0097\u008E9C\u00B8r\u00FC\u00FF\u00CEy\u00F5\u00F8\u00BC\u00D7|j\u00FE\u0081\u00B6\u00A6\u00C0\\\x04\x1B\u00AAX\u0093\u0086\x19:\u00D6\u009C\u0080\u00E7h\u00CE\x10j$\u00A2\x05)\x19(\u00AF\u0084\u00CE\u00C2(\u00CD\u00CDy\x1A\u00D9\u008C5\u00A4\u0099\u00A9\u00CF3\u0098\x15XD'\u00C7\u00C3\x1F\u00A0\u0099\u00E3\x00\u00A0\u00ACaIu@\u00E7\x16e\u0088\u0099\u00A5\x1DC\u0090a\u00C65\u00A2\u0090\u00C1D\u00E6YP\u00FF]\"\b\u00C8n\x10j\u0080\u00BA\u00D7\u00A1J\u00E8\x12D\x14)\u00D7\u0090\b\u00CCc\x1F\u00D3\u00AD\u00DC\u00E0\u00C4\u00E9\u00B1\x05N\u0090\u0096\x1198\u00F1J\b\u00FE\u00E4|I\u008C\n\u0084\u00E1\u008D\x12>\u00F7\u00A4@\u00BA\x10W\u0082\u0092\u00F2\u00B7z\u00B7\u00FEGEl\u00E7\x16\x01T~~Wg\"dN#\u00B4/\x01\u00ED\u0090\t\x03I&\u00F9%3\u0084Q\u00A1}\u00C0b\u00F7\u0083\u00FB\u00F2\u00EC\u009Fy\u00DA\u00EE\x1F\u00F8\u008F\u00C74\u00CC\u00F9\u0098\u00AA\f\u009F\u00D3\u008B\u00BF\u00EB\u008F\u00B7\u00FE\u00C6\u0092\u00E1\u00EF\x00\x00 \x00IDAT\u00C3yW\u00CD.kM\u00CD)\u00D4`j\u0082 \u00EB\u00FA\x01\u00AE\x1A\u00B8\u00BBQ\\\u00CF^\"d+\u00A8y\u008B\u009A\u0083\u00C9T\b3E\u00A6\fQ\u00F7J\u00A8\u00DB\"XhUC\u0093W\x15\u00F74\u00D0\u00ADiq\t*\u0099/A\u00B7\u00A6b\x06\u00E8:\u0098U\u00D1\x18G\x10*\x02\u00D5\x04\u00EF]\x05\u00E6I\x18,~`\"\u00C1\u00DBDUI\u0086R\u00EC\x0B<7\x14\u00EE\u00C2h\u00AAB\x1Bq\x04U\u00E9\u0095\u00BC\u00954\u0097\u00E6\u00E5\u00B8\u00B8\u009F\u00BF\u00B1\u00D0\b\u00FB\x0F\u00B8\x10s\u009C0\u00A2\u008E\u009B\u0090}\u00F58\u00A6\u00D7(h\x11\u0088w'\u00A1\x02x_\u00E1*\u00F49H\u00BF}\x03Z\u009B\u0084s\u00B2/\u00EA\u00E7\u009C\u008B\u00EC\u0093\u00A4?\u0086\u00E7f\u00E2\u0082\u00F3/v\u00F5\n: \x1Bh0\u00C9,\u00FE\u00CE\u00F8@\u00A4A\u00AA(\u00D4aD\u0081n\x1E\x16\u0086 \u00AB\u00F4\x18\u008BMFs\u0091L&\u00EA\x04\u00CE\u00F7\x1EF\u00D8\u009E\u00B6\x07\x7F\u008E\x12B\u0089p\u00B9b\u00CC\u00B9\u00E7\"@2D-\u00CC@\u00F8\u00DC+&\fa\u00AF~\u00EE\u00A4\u0097m\u00FD\u00E6\x05\x17\fo:eC:\u00EA\u00B2o\u00BE2m\u008E-\u0085\u00A5I\u00C6\u00A9\u0091\u0088\x07h\x18\u00F7\u00962\u00F5\u00D2\x03\u00C9\u00D3k\x135oC:0=b1z\x15\u008C*\u00E8b\tSc\u00C82.\u00AD\u00E6\u0098\u00C3c\nt#z\x00\u0086\b>\u0082\x1B\x17Y\u00C3\u0090\u00A8\u00A0Ju\x01\u00DD\u008A\x1A\x18\x07\u00EA\x01L\u00E4l\u009A\u00AB,\u00D0\u0083\f\u00D0F4T$\x13\u00E3\x12\u00FCX\u00EC\u00CD\u00C8\u00D8\u0086\u009E\u00BD$zh\x11\u0092L\b\x1BFJ\u00E1y\u00D5MN\u00F68\u00C0\u0082\u0094\u00C4\r\u0091\u00CE\u00CC\u009C\u00F0\x05\x1A\u009Fsl\u00894\u00D2;+\x1E\x04\u00A2P\u00A9o\u00CB\u0098\u0096\x05]u\u00A7}I\u0081\u009D\u00AC\x0B\u008AE\x12\u009A \x11\u0084\u0088{\n\u008A\u00DB\u00D6v\u0089\x01\u00BDS;\u0098\u0099\u00ABTTO\u00AA\u0091R\u00FD\x02\x11q\u0086\u00BA\u00F4a\u00F4\u00C9{:\u00E2V\u009C\x193U\f\u009F\u00FB\u00C8)\x07\u00DE\u00FC\x07\x17\u00E8\u00E7.|\u009C<\u00E4\u00BB\u00EF\u00F6\"+w;CX\u00E8bx\u00CD\u00F6\u00EF\u00BC\u00E6\u00E5\u00F8\u00B33g2\u00A2\u00F9\"\u00A4\u0083\u008D\u0084_u\u00FE\u00D1\x7F#`\u00B3(C\x7F\u00FF\x0E\u00B9\u00C4\t\u00BC9q\u0093\u00EB2\x1C\u00BEC\u00B0\u0094\u00EE\u00A1\u00B9\u00F6\x06\u00E8\u00A10\x15\u00C3\u00A4\u00E9\f\x04\u0086\u00F4\u00E33/\u00C2=\x01X\x03\x03\u008DDf\u00E6\u00C2\x13\u00D3\u00F15P\u0082\u00BB\u00BE\x1A\u00F5\u00FD\u00C1\b\u0093\u00CC\u0080D\u00A4\u00A6\u00B0$K\u00F4\u0085.-\u00FC\u00F2\u00D3\u00A0\"\u0097xe\u009FH\x1B\"\u00CFQ\u0097l\u00B47\x18\u00D22\x15'\u0099L\u008F\u00D9\u00B3\x19h\u00AE\u00D3\u00D6\u00A8g\u00A6?\x13_\x01pz\u00A6;\u00D0\u008C\r]Z\u00BC3;\u00E6~\u00FF \u0094\u00AA\u00BD\u00D8{\u00EA\u00EE\u009ElE'Tm%\u008F\u00A0\u00A8\x0F\u00E2\u00DF\u0093\u0087#\u00FCF\u00AA\u0080\f\u00E6.D\x0BI\x1E\x1E\u0087\u0098\x13G!\u009D\u00F3I\x1F@\u0089\u00C9\b\u00A2v/\x00Fgl\u00CD\u00C3\u009CGD\x15Ww\u00C9&|PL\u00F6\u00EB\u00BC\u00CDv(Uj\u00FA\u00DC\u00F3\u008F\u00BF\u00E7\u00CC\u00AD7\u00FD\u00FEk\u00F4\u00C0g\u00FF\u0099\u009Cp\u00F7\u0096c\u00BB\u00DB\x19\u00C2\u009B\u0097\x7F\u00F6\u00C2g\u00E3w\u00BF\u00EF\u00E0\u00DAA\u009C\u00EC\u00849\u00F8+\x1E\u00A1Xz\u00ED\u0082\x11\u0082\u00B1\u00DBk\u00A0\u00CD`\u008Cs\u00D5\u00ED\x07\u00BEdI\x1F\u00C8 $\u00F5\x05\u00DE\u00C5Q\u0087;\x14M\u00E6\u00FB\u00A2piU\u00DD\u008F\u00DD\r\u008B\nE\x17[4\x1A\u00BE\u00865\x003\u008C:G\u0093\x19\u0086\u0082\x06B\x12\u00AB\u00D9\x10\u00CC\u00D8\u00C7p\u00E4\u0082\x10\u0084z\u00AE\u00A9\x11\u00A2\u00EAIJ-\x17\x1A\u00C3\u00FC\u00DA\u00AA\u00AB\x0F\u00A6fpM5\u00F3L\u00A8C\x7F\u0091b\u00C0\u00F4\u00C8\u00BB\x18#<\u00BB\x0F\u0080\u0088Ey\u00A4\u00844\u0082\u00A0\u00A1\x0F\u00C1^}\u00A8\u00E2\u00D2X\x11\u00CCT(\u0091\u009B'\x16\u00C5~\x07\u00AErHs;\u00A8\"\n\u00B0\b|\u00F6\x07W;\u008C\x15B\x05\u008D\u00B9\x0BN\x14\x16p\u00A4\u00B0\u00C2(+\u00E2\u00DC\x19S\x07\u00D0d\x16H\u00C2\u00E2@<\u00AA\u0091h\u0081U\u0099\x18\u008F\u00A0\u008C\u00A7\u00F0't&b\u00D6%\u008F[@)\u00A4\"#\u0088R\u00C2;\u0083f\u00B9\x11tO\u00EA\x12io\u00F1\x19%wsf\u009B\u008C$\u00BF\u00FA\x0BE\u0085+\u00D2\x05k]\u00B1\u00BC\u00E4\u0082\u00EF\u00DB\u00DE\u00F5U/\x04\u00F0\u008B\u00B8\x1B\u00DB\u00DD\u00CA\x10.\x19\u00FF\u00E6\u00C7~v\u00F9\x0B\u00BFp\u00DD\u00B0\x17\u00A2\x1Dk\x10\u00CC\x05\u0098k\u00C7\u00DC%Q\u00A4&\u008B\x04B\u00E0,\u008A\u0087\r\u00AB\x18\u00D1\x0F\n,]\x124\x15\u008C\u00CE8Dh1\u0090@\u008F\u0084\u00B1\x1D\rcx\f\b\u0093\u00BD\x1F!\u00BA \u0082\x00:\x064\u009D\u00A3\u00CB:\u00809\u00BA\x17r763\u00A0\u00D68\u00AC5\u0098\x02\u00C2\u00F3)\u00C2\u0088\u0098\nR\x1A\u00C1\u00F8\u0099\u00AB\u00858\u00C5\u00C7\b\u00AA\x01\u0094\u00CE\x1C;|!\u00931%2\b\u0098Mb\x17\u00FFQ\u00A4\u00AC[\x0F\u00EEqF\x10\u0091\u00CE\u008AHpj\u00E1\x1D\x002\x00\bH\u00DF\u00A63\x10i\u0099\u00D9Y\u00D4\u009C0\x04R{\bJ\u00A8\x19\x16\u00DD\x19MB\u00F4tw\u00F8|uC%6\fC Lz\"\u0083\x17\u00D0>\u00B2,\x04\u0097R<\u00A2\u00B9+\u00BB\u008B\u00B1y\x16L\u00B5)\x04\"\u00E0@MY\r\u00F1\u00A4\u00DD\u00D1\u0089\u00A0\u0084\u00CB\u00A1\u00DC\u00FC0\u00AD\u00B2\u00DBC\x1F\u009E\u008D[\u00D8|\u00DF+~a\u00F3M/x\u00FF\u00C6?\u00FF\u0095\u00BB\u00AD\u009A\u00F3\u00DD\u00C6\x10\u00AE\u00EE\x1F|\u00F8\u00AFn\u00FF\u00EA\x1F]\u00BA\u00F6\t\u00A8,\x00\x15\u00EC\u0083b\x03\u0082\r\u00C0+\x1AYu\u00E49\u008C\u00B8G\u00E9\x18\u00FD}\u008C\u00A2\x1E\u0098\u0084\x00oKAl\u00D1f 8\u0093\u009E\x04\x12\u00A1\u00C9U\u00F5\u00A4i\u00D1\x12\u009B8:;q\u00F4\u00C5lK\u00B0ad\u00D8\u00B1\u00B1.d9\x16E:>[2\x05\x1A\x0F\x03\u00C2\u00B3\u00B2Bs\u0098O\u00C8\u00EF\x06A\u00F5\u00DF\u009D\u0098\u00A3\u00CAR\u00E8\u00C3\u00FC\u00EE\f\u00C1Q\u008Ee<\x0E\u00C8\u00D0b\u00B1\u00AC\u00C6@\x0F\u008A\u0089\u0087\u00C3\u00C5\u009BiW\u0092nG\u00CE\u008E\u00DF+\u00A6\u00C3\u00A0\x12\nwp~\u00A5N[\u00DE\x7F\u00C4&9Y7\u00A60k\u008C\u0083\u00C6X{\x00'\x04\u00CD\u00F7\u00D1\u00DD(\u00C8B\u00AB\u0089@\u00FC9\u00AA\u009D$xM\x03\u00D5\u008F\u00A9\u008D\u00C3\u008Fu\u008F\u00C4t&ch\u008D\u00CA:W\u0089\u00C6<\u00C7|\u00A2;\"(\x0B\u00C6\u00DF\u0087B\u0090\u00E9\u00E9\u00DD\u0099l\u00F7\u009A\x13#B\u00D2+\x19Im\u00B7\u00C7 \x0E\u00D1\u00A4c\u00E3\u00C0\x17q\u00F0\u009D/\u00FF\u00A3\u00E5%\u00E7]>{\u00F4\u008F\u00DF-\u00FB>\u00DC-\f\u00E1:\u00BD\u00F6\u00C4\u00FFg\u00EB\u00FF~\u00DD\u00EBgo\u00DB=zv\u00A1\n\u00B0\x1F\u008A\r\x00\u00BB\u009D\u00D8\u00E7\u00A2\u0098\u00AB\u00B9\x13\u00E1\u0084\u00EBk\x18J\u00F0\u00AEf7\x1B\u0085\x0E/\u00F7\x06\u0088\u0086l\u00CF?_L\u00AA\u00EE\u00FEe-\u0085\u0089\u00DD\u00DE\u0092\u00A4\u00C4\u00E4\u00CF\x00\u00AF\u00C7\u00A4\x16\u00E1\x00Y\u0087\u00CA\x1C\u00AAV@\u00B3\u0083\u009E\u0081\u00E6\f\x01\x0E3kHr\u00F54\u0098\x112\f\u0080\"\u00A9\u00F3\u00ABDxn\u00D4i\u00A2\u00FB/\u0098\x03\u00E2\\\u00B7\u00C9\u0083\u0099\u0089\u00ADY_\u00EA1\f\x00\x11j\u0089\u0092s\u00C8*\u00AB\u00C8\u0080\u00A9\u00C6\x0EL\f\u0095;\u00EA\u0098l\u00B0\"\u00FE\f\u00E2\b\u00A20R\u008F\x11`\u00BD\u00C2\u00A6-\u008D\u0099\x1C\r\u00D1\x19\u00BF\u00A7Ng$\u00E9\u0086K\u00A6`k\u00F3\u00D4\u00E4\x0E3\nJ\x0B[\u008E\u00BD,\u00CE\u0087\x02\u00DA\u00ED\u00B9\u009A\u00D9\x07\u0094\f\u0085\u00CCK\u00C9\u00E0\u008DX5\u0090\u00D2\x10\u00C7L\u00CDr\x13\u00B4$Z\u00E2\u00D8\u00B5\u00D3q=:j\"\u009B$\u00D4\u00A7w\u00C8\u00D5\x0BzL\u0094\u00C7{\u00BC\u0083T\x1FJ+?O7\u00E31\u00E6\u00B5~\u00DD\u0095\u00BB\u00B7\u00DF\u00FA\u00B2\u00D7\u00E9\u008DW>Z\x1Ex\u00D6]\u00BEC\u00D4\u00DD\u00C2\x10\u00DE\u00BC|\u00FD\x1F\u00FC\x0Fy\u00C5Y\u00E3@\u008E\r\x00f\x07\u00D8\x03`\x17\f\u00A22\u00B8\u00A8\t\x17\u008B\u00BB\x1A\u00D5\x10\x04\u00E3:h?`_\x16\u00A3 XJz\u0088=\u0080\x0Es\x00py>\u00C0\u00FA0f\u00C2Q$\u00CA\u00B0W?@\u00B0\u008E\u00E6\u00EA\x01\u00D3\u0095\u00BB'\x1FY1\u0096\x01c\u00893hn`J\u0095\u0080jDa\f\u008CjR\u00C2{\tn\u00A7\u0091P4\u00F89dU\u00C3!\x16Q\u00DA\x13\u00D4\u00A5;},\x12\u00C7\u0081\u00F0\u00CD\x16\u00C6B\u00A1\x17\u008B\u0090\u00D2\u0096C\u00F3'Hwg\u0089\u00E2H|\u009F\\:\x16;\u00BB\u0090\u00A2\u00D2\u00F8\u00AF$\u008C\u00F8\u00C9G*H\u00C4`\u00D4\u00E0\u00844P\u00A6\u00DB\x7F\u00C5\u00C2\u00C6\u008D\x10\u009D\x00\u00B9\u00D7]\x10ZU\u00B7\u00AA4\u00EE9\u00E7\u00EA1)\u00EAy\f\u0081\u008A\u00A8\u00D2\x144F5\u00C9\u0089\\\u00C3`H\u00C6\u00C2\u00ACI+\u00D3#D\x04\u00E1\u0095I\u00C7\u00F74\u00AA\u00B4\u00BEK\u009D\u00FE\u00A4\u0089\u00A7j\u00D3\u00A6\u0098]y\u00D1Y\x07\u00CE\x7F\u00FEK\x00<\x03wqk\u00B7\x7F\u00CA\u0097\u00D6\u00FEn|\u00DBO<\u00BF\u00FF\u00DE\u00BF\u00BCem\u00D3\x7F\u0099.\u0098-\x007w\u00C1\x01\x05\u00B6\u00E1\x7F*X@\u00B0\x00\u00B0\x10S\r\u009605b\u00E1\u009F\u0097Hc \u00D5\u0087\u00B12\x03\x18\u00BB\u00E8\u00E5\u00BC\u00E2\u00E1\t\u0090\u0097\x7F\u0086\f:\u00D61b\rK\u0099\u00FBw\u00EE\u00F6\u00D0\u00CC\u00D0)3\u008C\x180\u00A2a\u0084\u0095e\u00EDbj\u0080\u00B6\x01*\x03\u00D0\u00D2\u008E\u00E0\u009A-hs\u00C8\u0090ff?\u00CE\u00D2\u00A8\b\x01\u00CB\u00A9A\x06\u00A0\u0089\u00B9\x18K\x1A\u00B3\u00D9\x0BL5\u00D1\u00E6\u00FF\u008A\u00C7gj\u00AA\t*\u0083\x1Fs\x06\u00E4}(\x1A\u00BA\u00D7`0\x17g\u00B3\u00F1\u008A\u00A9/v\x1DK\u00B8!\u00CB\x12\u00C2\u00A4\u00AB\u00D9,\u00FD\u00D9\u00A4\u00F9\u00BD%\u00FAS\u0099#b=e\x06\u00C8\u00DC\u00FF\u00EC\u00B3\u00CA\x1C\u00C6\u00A6\x1D\u00811\x03\u00D4\u009F\t\u008E\u00C0\x04\x16\u00D1\u0099\u00CFkc\x17&j\u0089\u00C4\u00BCU4e\u00CF\u00E0\u00CF\x1B\u00CF\u00E4\u009F\u0083i'\u00A3\u00CF\u0087J[\u00D0\x0E;\u008Fr<\u00F6\u00A7\u008E\x14w2\x7F\u00FE1\u00CD}\u0096(5\u00DA\u0091\u00A9\x0FV\x1D\u00BC\u00A3\u00BD\u00EF\u008DO?\u00F8\u00C6\u00DF\u00FE\u0089#\u00BA\u00F8(\u00DA]\u008A\x10>\u00AB\u009F>\u00E3Y\u00DB?\u00F3\u00E2\u008F\u00AD]\u008D\u009D\u00BA^B\u00DC}M\u00B1\x0B\u0082u\b\u00E6\u00A2\u00E6\u008F\u0085\x05\x05/\u00E0S\u00AE,u!\x1Epd\x10\u00BF\x03\u00F1]\u00DCX\u00D8\u00E2\x18\x19D\u00AA\x07K\u00CFGH\u00B3\x1D\u00E3\x0B\u00E6\u00E8:\u00C3(\u00EB`\u00D4!\x03\u009E\x15\x03\u00BA641\x06\u00D0\u00D4\u0088\u00CA\u00CD\u00A0h\u0093\u0085\u00D4\u00A0\x13\u008F\u0082\x13\u00B2\x0ENX-~\u0097N\u00E3\u00A3K?\u00D8B\u008E\u0094gM\u0087l\u00CC\x19\u00DDs!\u00D6K>\x02]h\u0094\u009A\u008A\u00D0\u00C9\u00AD\u00C0\t2\u00AC9R\u00A8{~\u00DF\x11\u00D7\u0080@6R~WwwB\u00A8Z\fn\u008F-\u00EA\x04u\u0082bhS\u00A2\x02A\tSN4\x02\u00B1\u00DC\t\u00D6Q\u0088x\u00D40Lj\x10\u00B0\u0094d&cVn\u0098,v\u008A\u0090\u00F6\x00Pl\b6_\u008CTl\u00B9\x1CUa\u00F5.V\u0095N\x12\u00FD\u0098\u00EF\u00C4\u008B\u00C1\u008A\u00BB)s\u00DE\u00DD\u00D8\b\u0081H\t\u00A1\x0E\u0083K\u00A6=\x11D\u0088j<\u00E2\u00A4)\x02\u00B5l\x1C\u00B8\x05\u00FB\u00DE\u00F9\u008A\x17/\u00AEx\u00CD\u00BB\u00E7\x0F\x7F\u00DA]\u00B6\x15\u00FD]\u00C6\x10\x0E\u00EA\u00DE\u00D9\u008B\u00B6^\u00F8\u008A\x0B\u00E6o9\u00D1\u00EA\u00F0\u00D5$f\u00FE\u00D9bQ\x00\u00B7\u00C0\u0098\u00C2\u00CC'\u00A5\u00A9\u00D9\x15\u00C8\u0087\x07\u00A4\u00FA\u00D0\u00C4\u00C3\u0093\x15\u0090\u00F0F \u00EA#0]vt\u00AB|\u00B5g7G\u00D2\u00B6<\x1A\u0080\x19T-K\u00A23\u00BE\x00n/\x10+\u00BD\u00DAK\u00A6b\u00C3\f#\u00A5\u0086\u00B8g\u0081\u00AE\u00BE *'\u00FA0k\u00D3\u00ED\bp\u00F1h,\u00FA\"\u0091\u008A\u00AB*\u00AD\u00D9T18}\x1E\u009D\x18\x1E\u0085JT.\u00AD\u00C3bo\u00F3\u00AD\u00939\u00AFYx\u0084\u00EE|/pI\fD\u0090R\x10\u00B9C\u00F5\u00D0M\u00CC\x06aR\u009BC\u0099\u00E8\x0F9\u0086J\u0097\u00F5p\u00B42\x16\x0E\u00A8\u00FA\u0092\u00C3\x1E\u00C0\u009C\x06'\x1E\u00B7#\u00D8}\x06\u00EFi\u0084\u00EA2\u0099G0\u00A4\u00F46\x04*\x10\u0080\u00D9\u0087\u00D9\u00F7\u0088(\u0082\x13\u009E\u008E2\u00C7\u00D2<\u00F1\u00C9\\\u0094\x18\x07c\x022&\x12\u00D3% \u00DD\u008D\u0090\x03R\x1D\u00CA\u00F5\x1E\u008F\u00E9?L\u0083\u00A4\u0080Pa\x14f\x10m\u0082]\u009F\u00FF\u00F8\u0089\x07\u00DF\u00F4\u00A7\u00AF\u00D0[>\u00F3]\u00F2\u0080\u00AF^\u00EE\u0098\u00C6;\u00A1\r\u00B7\x7F\u00CA\u00D1\u00B5o\x7F\u00CE\u00A3\u009E\u00F3\u009Bx\u00DE\u00D3o\u009D\u00DD\n\u0095\u008E|\u00DE\u00E9\u00E2\u0084\u00FF\u00D7\u00DC\u00C1\u008254/q\u00A6\u00BE=\u009B3\x04\x117vk\u00AC\x1D\u00BA\x0E\x05\x00\u008B\u0087\u0088\u00A4\u00DB0\u00D5\u00D9B\x02\u00C2o\u00C6\f\u00809D\u00D6\x00Y\u0083A\u00E5L\u009F\u00CA\x14\u00E6\u0099\u00FB\u00EE\u00FDw\u0087\u00AB\u0082\x01\u0083\u00E7.\b\x04M\x04\x01u\u00A5\u00C0^G\f\u00BC&\u00E11\u00AD\u00D6\u008E\x06\u00DC\u00C0H\u0098ly\u009A\u00CE\u00D0\b\u00AB\u00A3\u009E\u0082\u00CFeQ'\u00D8\u00AF\u0090\u00D1DNE+4\u00CF-i\x1C\u00867\u00EF[[<\u0087\x05<\u0091\u00B90\u00D8\u00AB\u00F2\r\u00BBg\u00D4\\\u00F0\u00E3\u00B9\u00E35]\u0081-\u0098\u009E\x10\u00AE\x0B \u00EEuI\u00ECA\u00A3g\u00FE\u00C6O\x11v,\x16\u00C5\u00D9d%~\x02\u00EE\u00E5q\u00E9+\u00F0\u00C5\u00C4\u00D4q\u00A6\u00AD\x07s\u00A1\u00DA@\u00E4\u0094\u00C4\x18k\u0083a\u00D2'\u008C \u008EI\u009EP\u008D\u00CA\n\u00A0+Z\u00EFh7\\\u00F3\u00D0\u0083\x1D\u00E3\x7F\u00FE\u00CB\u00F7\u00BC\x13wA\u00BBKl\b\u009F\u00D2+\x1E\u00F9?\u0096\u00BF\u00FF\u009C\x1B\u00E6_\u00F4_\x0E\u0089\u0085&\u00BFt\x00\u00B7\u008Ab/\u0080\u0083*\u00D8\x12`\u00E16\u0083\x11\u0096\u00A46\"\u00ED\x07\u00F69\u0099I\u00A8\x10\n\x0B?\u008Ec\u00F4<\u00A4}\u00816\u0083\x11st\u00DB\u00EA\u00C5m\b\f\u009E\u009E\u00C1\u0092\u00AB\u00D7L\u0095\u0088|\u00C9T!\u00EA\u00F7\x0E\u00C1\u00E8\u00EA\u00C4\u00A4\u00E8{\u00842\u00A7\u009A\u0090\u00B5\x15\u00CB\u00B1\u00D5]\u0099\u0088(\u0088@\"\u00CA1\u00ED\x01\u00A9\u00BFS\x0F\u0097\u0094\u00D7S%\u0090$F\u00BE\x0F/{\u00C7\u00C4x\u0089=1\x1C\u0091M\u00E2MZ\u008C]&\u00E3\u00A4\u00F0\u00E1\u00B3\u00DFN\u00A3As\u0095n\x04\u0098\u008DK\u00B4\u00F7\u00BE\u00F19[\u00EF\u00FE\u00E3G\u00DE^7G\u00D3\u00EEt\u0095a\u00EF\u00C1/\u00CC\u009F\u00BF\u00FD\u00C2\u0097\u00BDc\u00ED]\u00F31\u0092]\x0E5\x05\u00AB\x18\u00C9\u0088z\u00AF\x00\u00BBT\u00B1\x0E\u00C16\u00CA\u0094\u008A\u00A1\x00\u00BE\u00E6\u00EEn\u00AA\u00A5d\u00A6\u00E2\b\u00DA\x10\f&\u00AF\u0094\u00D8\x07m\u00B8\x1D\x03D\u00E7hn8\x1C}\u0081Z\u00C2\u00B5%M's\u0090\u00C2\x04\u009C\u00A8\u00C1\x1D \u009A\u00D9\u0097}\u0081\u008Chh\\\x10\u00AE2\u00984pi\\-\u00D9~\u008E(\x17\u00BCd\u0096\u00A1b\"\u00C5s\u00BA\b\u008D)\u0095|\u00EE(]C\u00CAH^\u00EBY\u008DR\u00CF\u00ED\u00D3\u00EAQ$\u009C\u0094\u00F6~\r\u00AD\u00F1 |e?\u00E9y\u0090IG:\u00F9\u0087'\u00D9)\u009E\u0090\x14\u00FA9\u0093\u00C5\x04\u008C/\u00A7\u00A4\u008F-\u00E3\u00A3\u00E2r\u00C4\u0091z\u00DF-\u00FAQ\u00F4\x12\u00C8H\u00BB\u0089\u00C3v\x00\u00A1\u0086\u00E5\u00E3\u00DB\u00DD\u00F9\x1EZ\u00B3~\x18g\x15\u00EB\u00B1\u008CSl\u00E3\\\u009B^\u00CD\u00E35\u00A9\u00C9k;\u009A\u00AA\u0090o!m\x14\u00EA\u00FE\u00F2\x05b'\u00A8\u00FA^W\u009B\u00A3\u0082\u00A2\u008F\u00F9.b\x1D\u00B3\x1B?1_\u00BC\u00E3\u00CF_\u00A6\x07>\u00FFh9\u00E1\u00AB\x16;/>\u00FAv\u00A7\u00AB\f\u008F\u00FD\u008Do{\u00F6\u00AF\u00CB\u008B~l\u00FFl\x13\u00AB.\u0094;\u00D2FX\x04\u00E2L|\u00F7f\u00E1r\u00A5\u00AD\u00A0\u0085<`H-\u00A1(\u00E1s\u00FC\u00D7\u00ED\x0BI?\u00ACz\u00BC\u00E6\x7F\u00EBP\u00B1\x12*\u00C9\u00BD\u00D3B\x1CP\u0097\u00B9\t\x10'x\u00C2\u00DFT\x0B\u00E0\x16\u00E8p\x1DJIv\x02%.s \u00AA\x04\u00F3\x01\u00B2\x1F0X\u0089\u00D2:\u00F7U\u0088x\u0085\x12\u00B0\u0094\u00C9\u00DF\u0084\u00AF\u0094\u00D4\u00DE\x187\x10(\u00C5\u00A5ZQeR\u00DA\u00C3\u008D\u00A5\r\x11\x06\x1DR\u00CF\u00E1\x7F\u0098&\b\u00EB\u0093\u00F9X\u00F0N\u00C2t\u008B]\u00E0\u0082vD\u00C2\u008F@a|dB~P\u00CBx\u00A9\x12Q\rb\f\x07\u00D5+M\x0BId\u00B4P\u00D2\x07\u00DDfNF\u00A2sJ\u00F1\u00A2\x06\x043\u00B6\x0B\x15,\u00F0\u00E2\u00EA\x11U\t\u008FgH\u00B8\u00EF6\x0EWIb\u00F3[\u00DA!\u00AAJ@B\u00E7\u00F3\u0087zP&\u00A6\u00AA\x11aK\u00D1`4\x03\x04\u00B8\u00EE\u00DA\u00D3\x0E.\x16\u008B\u00E7\u009F\u00FF\u009E\x0Bq'\u00B6;\x15!\\\u00ADW\u009D\u00F53[\u00FF\u00E6\u00D9{\u00E77\u00E3\u0090\\\u00EF\x0E4\x05\u00B0G\x14\u00BB0`\x1D\u0096x3\x13C\x0B\x16s\u00D2\u0083A\x00S\u00B0F\u00B3Q\u0087\u00E7@\u00C4\x12\u00F0\x00\x18ihj1\x06\u0090\x19D-`\u00BA\u00EB\x1C\"t-\u009A\u00E4\x17w-\x02\n\u0096J\x1F\u00FC.44j%F\x1F\u0095\x11T\u00A6+\x19\u0081\x0Fe:x\r\u00B7p\u00F7\u00E5\\\u00F4\u00EF\\\u00CD<\u00C6\u00DE\u00AA\u00FF\u00DD\u0089^\u00F3Nv\u00AC\u0095\u00FB\u00D8\u008C\x06yN\x02_lB#\u00F7S\u0090\u00CC,F@\u00E9\u00E6\u00BF\u00A8\u00AF\u00DD@\nH\u00B1Z\u00B3))\u00C1\u008B\u00FF=\f\u009D \x120\u008FBTb\"qNR\u00AF5\u0098\u009C1\u00A2\x1A\u009D\u00C8\u00FE\u0086\u00F2\u0099\u00CF\u00DB\x1D\u00BD$\u00E7!+\u00A8\u00BE\u00A7@\\\u009A\u0088\u0083\u00E5\u00D32\u00EF\u00C5v\u009B\u00AE\u0088!\u0099W\u00CFk\u00F9\u00BD\u009E\u00A7\u00FE\u00DE\u00D5\u009D\u00DC\u00EA\u00F1\t\f\u0080\u00C2\u00EA5\u0085)\u00D6\u00B9\u00F5\u0093\x03\u00EC(0\x1B\x0F`\u00F3\u00E27>{\u00F3\u00D27\u00BEn\u00E3QO\u00B9\x12wR\u00BB\u00D3\x18\u00C28\u008E\u00F2\u0082\u00AD\u00E7\u00BE\u00E4\u00EF\u00E6\x17\u00AE/\u009AW\u00C4=\u008A~\x14f;\u00B8\tK\u00AC\u0089\u00A1\u0085Z:mA\u00A9\u00EA\u00FFI\u00CD\u0091\x1E\u00FF\u00EA\x04R41\u00F2\\\u00CA\u0080\x01\u00A6&\bf\u0098\u00D3\x06\u00A03LU\x02\u0097\u00D2\u00FE\u00D7\u0089\n\u00C2\u00E8f\u00DC\u009F\x06\u00C0\x0E\u00A0\u00EB\f\u00CD!\u00BF\u00A5d\u009B+R\u00A4\u00EC\u00B1P!\u00AA\u00A6\u00B1\r\x00\u00B4{\u00A4\u009FL\x19\fd\x06\u00ED\x1DQA\u00D9\u00F5\u00DC\u00C8] \u00BBc\u00E0Q\x18\x18\u00EB\u0084\u0096\u00F3}\u00CEr\x0Bu\x12\t\u00E7\u00DE\u00C3\u00BD]\x1AUo&\u0085X\x0B\u00B4\u00C4.z\u00B9\x1A\u00C82\u00EC4\x14\u00BA:@f&\x00\u0098?\x01&$y\u00DF\u00A2\u00CE\u00F3\u009C\x00v \x07\u008E\u0094L\u00B3\u0097\u00CFD\u008D\u00B5\u00B0\x0E\u0099M\x12\u009C\u00B8\u0084\u00AE\u00E6K\u008B\u0094d\u00D7bN\x035\u00C5\u00D3J\u00F4\x17OE\r228\u0092\u00DFc>*c\u00D7r\u00CC\u00D7\u00816\x00\u00BEq\u00AD\u00F2=\x10\tHv\u00ED*\x16Yz\u00DE\u00D7\u00C6\x7F\u00E2\x17>\u00B1~\u00F0m/\x7F\u0089\x1E\u00B8\u00E1{\u00E4\u0084S\u008FN\x02\u00AF\u00B4;\u008D!\\\u00A4o\x7F\u00C6Kq\u00DE\x13\x17mt\u00B9\u00FC\u00A5\u008D\u00EF \u0080[`\u00B5\x15\u00D7\u0094\x1A{\u00A9\x1F\u00A4fN\u00EBPw72\x1B\x12\x1E\u008DH\u00DB\u0082I\u00F3\x063\u00B2)\u00E6P\x190b\x0E\u00C1<\u0082_\f\x11T\u0083VZ\u00E3G'*\u00D1\u00861`,\u00F7[\x10tF.\n3\r\u00FC\u009E\u00DA\u00FC}K\x10p\x1A\u00A4\u009C\u008D\t,\x0BO\u0080\u00DC\u00D8\x05\u00A0e;\u00B6k\u008B\x05V\x10\x01\u00FB\u0093\u00B2\u0088\u00B8\u00B0\u00C85\u00E9\u00EB\u00E7\x16l\n\u00B0\u00A4\u00BDAz\"\u00D2\u00BA\u00E8\u00BC?Z\u00D0\u00C3\r\u00C7G\u0091X\u00E7\x14[\u00CA\u00F8\x01\u00B8\x1F\u009F\u00CC\u00A7\u00C0nk\u00FE\x1C\u0082\x18w\x12>Q\u0090F\u00FF\u00E1\u00C5U\u00B8*\u00A5EpV\x06\u00E8\u00F51z\u009B\u00C2y\u00A2\x0E\u00A5\u0094\u0095\u0098\x16a\u00DDu\u00E5\x1E\x0EH\x06J\u00A6\x14\u00CC\u00C8\x11\u0094(\u00AC\u00DC;%}\u00F7q\regm\u00A2\x1C\u00CDg\u00ED\u0092\u00CC\"\u00F6\u00A8(s>)9\x7F\u00C7\u009A@1\\\u00F2\u00F6'n\u00BE\u00E5%\u00CF\x00p\u00DE\x11]|\u0098v\u00A70\u0084\u00EB\u00FA\x17\u00EF\u00FF\u008B[\u00BF\u00F8\u00C2k\u00D6?\u00F3%\u00B2\u0081l\x02\u00E0V\x00\u00BB\u00B4a\x1D\x1D3\u00A1\u00F4\u00CF\x05\u00D0\u0080\x02%\u0093\x0El\u00BD\x12\u00B8[(\u00B2`\x06\u0088%)\u0089G\u00AAu\u00C9(\u00C4\u00B4t\u00DBw\u0093i)y\u00BB6,\u00C5l\x10\u009F\x1B\u008D\u00B5\x01\u00BAD\u0098H\u00E39\x15\u00901\u0088?\u008D\u00A0\x1C\u008E\x0B\x04H\u00B8\u00CCw\x06\u00EF\u00DD\x1E\u008BP\u00ACm\u00ED\u00C3\u00FE\x0B\u00CF\x7F\u00A1\u00DEt\u00E5\x1B\u00E4\u0094\u00B3\u00F6\u00DC\u00E6\u00E9w\u00A0\u00DD)F\u00C5oy\u00F6\u0099\u00CF\u00FF\u00DD\u00E1\u00F7\u00BEw9l}\u00C9\u00C8\u0080-\u00C2C\x05X\x070\x17/v*40j\u0098\u00F7X-\u00B9z\u00BC\u00F9m\u00C0\x1C\u00A2s\fX\x03d\u008E\x06n\x1C\u00DF\x1C\u00DA'\u00A4\u0096\u00E8\x01.\u00E7\u008D\x014\x1D\u00D0\u00E8\u00BE\u00E39\u008E\x12Z\x04\x10\u00F1~t\u00AF\u00F9\u00B9\u00D2\u00DC\u00D8\u0098\u00D7\x00\u00F4\u00EFs\u00C7\u00E74\u00E0\u0089G\"\u00DA\u00F9\u00C5\u00855qw9k\u009C\u00C4\x01\u00B0\u00FF!\u00C6\b\u00BF?&\u00A8\u00C6\u009E*~W\u00B2\u00B5\u00EA\u00E2\u00F4\u00F1G<\u0085\u00DB;\u00C2\rI#f+\u0092^\x12\u00E6\u0086J\u00E1\u00E8\u00A5DuJ\u00B8M\u0081\u00AA\u00FAX\u00FA\u00B5\x11\x19\u00B8\u00FD:\u00EC\u00DFF5-\u00882\u00E3\x14r\u00B5p(I\u00E0t\u00EBN\u00EC\x0EZ\u00C6\u00AB\u00CEP'(\u00A0el\x02\u00A3;\u00A3w2 )\u00E7\u0093q\u0092)\u00FA\u00C8\u0098\x19\n\u00A4\x1A@\x04\u00E5\u00EFN\u00E2>\u00D8\u00C9\x1Ci\u00A7\u00E9Ts\u00C4\x02\u00A2F\u00AAa\u00A9\u00A2\r_\u00BC\u00FE\u00C4\u00ED}\u00DB\u00EB\u00BF\u00FD\u00D7\u00FF\u00EB\u00CDw\u009C\u00C2\x0E\u00DD\u00DA\u00ED\u009Fr\u00DB\u00ED\x1F\u00F4cg\u009E\u00D7_\u00F9s\u009B\u00B3}w\x1A:\u00A8\u00EDV(n\x05\u00B0\t\u008BM\u00D8V\u008BI\u00E8\u00EA\u00F1\tb\u00DF\u0097\u009A\u00A1\u00CC\u00A33\u0093\x0ES\rF\u00CC\u00B1\u0088X\u0082\u0099\u00C7\x15\u00CC\u00D0\u00A5a\u0094\x01\u00A3\u00D0\u0097M\u00A16\u00B3\u00ECF\u00CF9P\f\u00A6\x16\u0088\u00A9\f\u008C\u0088\u00E4\u00BD\u0098\u00D7`\x7F\u0083\u00E7<\u00D8_\u00C4A\x04\u00E1f\u00AEBz!$\x18R\u00AEl\u0093\u00E4\u0096#\u00C0`&\u00DA\x02'\u00A0F\x11\u0092\u00BD\u0095k\x1C]u@\u00B1\u008D\u009D\x16\u0095\u0096\u00D7\x07\u00E2\u00A8\u00CFE$\u00E2\u0089W\x05E\u00D8\u0089\u0082pG\u00A2\u00C3\x18E\u00A5x\u00CF\u00A0\u008C\u00F1W\x1BFm\u0087\u00A6\u00B1\u00B5\u00EB?3?\u00F87o\u00F8\x1D\x00?x\u00C8\x13\u00EE`\u00FB\u0092\x10\u00C2\x07\u00FB\u00A5g\u009F\u0087\u00F3\u009E\u009C\u00BBW\u00DC\u00B9\u008D\x12\x7FS\u0080/B\u00B1\t`\u00A1\u008A\u0085\u00A2dC\u00AA\u00A3\x03\u008FPT\u00C5(\x03\x14\x1B\u00E8X\u00F3D#\u00F3&\u008ChX\u00AAI\u00F1\u00AE\u00CD\u00AB\u00E6\u0099d_\u00C2\u00D1\x02f\u00FEo\u00C3\x12\u009Em\t\u00BE*\u0093\u00D8d\n\u00E9\x04#q\u00D2n\u00D1\u00CAw\u00B8\x141cf\u0084\x15O$\u00B3\u00C3u\f\u00E1\u00E2\u00D4\bw\u0096\u008C\x1Ad\u00B90\x15\u0087\u009C\x02f\u00E0e\u00B5&\x01\u00EB34\u0088\u00BB[%$9\x17\u00AC6\u0097\u00F4T\u00BE\u00C2x\u00C9\u00F0\u00EC6E1B\u00D5\b\u00B6!\u00AB\x0B\u00C3\u00E6cD\u0093\u00AC\u00A9\u00E2F\u00B6\u0088\u00D6\x14\u00AA?\u00B0g\u00F2{(w\u00DE\u0085\u00C0jQ\x02\u00DC\u00B7\u00A2\u0081\u0090\u00DC\u00A0}\u0087\u00A1\x11{n\x1F\x0B\x03\u0083\u009A#\u009BT\"\u008Da\x07\u0083*\u00E3\u00C1`\u00E5\u00DA|\u00AE\x12\u00AD\u00C0\u00BC\"\u0082xV\u00DA\u00A8\u00A6.a\u00F6O\u0081\u0091q*LG\u00B7\u00E7\u00E1x\u00D8\nbp\u00C4\u00A1b\x1E.D\u0086)\u00EDSE\u0088\x04_\u00A2\r\u00C4\u009F\u00A7\u00B9\u00DD\u00A4\x03\u00E8&\u00DA\u00E4\u00D2\u00BF}\u00F2\u00D6\u009B\u00FF\u00E8\u00EC;H^\u0087lG\u008D\x10\x0E\u008E\x07\u00E4\u00B9[\u00BF\u00F5\u0082O\u00CC>j\x05*\nG\u00BD3\x1B\u00F9\u00E1>(\u00F6B\u00AC\u00AA\u00A1\u00B8\u009C\u008C\u00C9O\u00AE\u00D9\u009D\x19\u00A8\u00AC{\u00AC@\u00C2\u00CC\x0E\u009B\u00F8\u00CE\u0097\u0080\x06`\u00869\u00A6)\u00CAF\u0090N\u00ECB\u009Em\x0B!\u00CBm\u00B0z\x12\x1Cm\u00D0\x1A\u00C1\rh\u00D3(\u00D9\u009D\x03C\u00A5\bBSG\x16g4\r4P\x02\u00DC\x1E\x1E\u0080I\u00E1\u00CE\u0085H)\u009C\x069\u00B35y\u00AD(\u00C9\u00FEke\u009F\u00EE\u00C93\u00A2\u00CD%\u00AE\u00C4\u009A3)J\x15\u00C5I\u00A6y\x1C\x02\x17Z\u00B7\u00E3\u00DD-i\x1D\u00E2^\u008D\x18\u0086\u00AF\u00E3\x1EFK\u00B0\u00B2\u00B2G7\u009AV\u00A3\x163\u0081\u00B2\u0086=\x07\u00A1\u0086\u00E0\u008Ad\u0081\x1CSm\x1AI\u00D9\x18E\x17Xm\u0087\f&\x120%\u00D9\u00C3\u009F#\x18\u00AA\u00C2n\u00EF3\u00EEns\u00C1\u00CA\u00CA*K \b\x1D\u00A0\u0092F:\u00CFRh\u00DE\x07\x03\u00A6\u009C\u0099\u0091\x17\u0084\x17\u00C1\u00A3E3\u00A2\u0081\f\u00D7\u0082\u00E8\u00C9\u00BC\u00CD9>B=5]\u00F8n'\u00A8\u00C3\u0099e\u00A8\"\u00FC\u00CC\u00E7+\u00AA\u0085\u00BFwn\u00C2\u00CB\u00B9#\x0F\u009F}\u00E8\u009D\u008F\u00DE|\u00DB\x1F\u00FD0\u0080\u00BF\u00C0Q\u00B4\u00A3R\x19\u00B6t\u00FF\u00F0\u00DA\u00C5\u00AB\u009E\u00FB\u0099\u00B5O\u0082\u00E9C\u0099Nt\u00D7\u00B5-\u00B1\nK\u009B\"\u00D8tMo\u00E9\u008C`[\x1A\x16\u00B2fFDI5`!\x16\u0094\u00B4\u0080`)\u00E2\u00C7\u00868Gai\u00CE\x195oU\u0091\u00BA\x0E\x18\u00B5E\u00D2\x13\u00D0\u00D0\u00B5\u00A1\u00AB\x17\x19\u00E1y@\u00E6=\u00A8\u00B8\x1Ab\x7F\u00A32\u00B8)\u00D5\u0089\f\u009Dr\u00C4\u00D0\f\u00B5\u00D0gR\"-\x10!\u00C4\u00C5\u0086\u0091(\x03\u00F9\u00BB\x1B\x1D\u0099xcp\u00D9\u00D5\x00I\u0088*Q\u00C4\u0083Q\x1D\u00EC\u00CEJ\u008F%\u00C6)\u0085[\u00985\u00D8\u00A8>P\x1D\u00A9R\u00D4\u00FF\u00FC|\u00A5\u00AD$\x1A\u00D5\x02S-x?\u0086\u00A5\u00F3\u0098\u00F8^\x16i\x0Ba\x02\u0092\u0087\u0093s_L^\x13\u00A1\u00DA\u0086\u00DC\u00C2\u00A8\u00E9\u0089E5iI&\x04\u0098\u00FFf9\u00BCz\x7F2f\u009E7\u00E4\u00BB\u00E0\u00EFJ^\u00C4\u00F7\u00C5\u00C7\u00F4\u00F7\u00C1\u0094xJpE2\u00E7\u0089\u00D4\u00F7\u00FB3\u0097#\f\u00B1+\x06O\u00E5\u00F6w\u00AE*Z\u00AF`\f\x07\u00C3\u00BB\u00D6\u00B6\x0E\u00A0\u00BF\u00FBo\u009F\u00AB{\u00AE=*\x0F\u00E2Q!\u0084\u008B\u0097\u0097<\u00ED|\u00FD\u008Bo\u00F6G=\u009A.\u008E\u00BA\u00ED\u0085b\u00B7\u0096\u00DC1q\t\u00ACs,\u00B1\u0086\x19\u00E6X\u00AAW\u00E8\u00C1\f\x03f\x18\u00A9\u0097\u00AAy\x00\u00A8\u00C7\x0BfX\u00C0\u00CB\u00A3\u00A9\u00EB\u00B5B\u00C8_\u0089\u00D9\u00EC\x0BT\x03h-\u00CE\u00CC\u00C9d\x02\u00AA\u00D6\u0087*U\x10[l#\u00A6.Q\u0084\u00A4\u00A1^\u00AF\u00C8\x1C\u0087\x1E\u0092H\u0084\u008B5-\u00D8*\u00C4\x14\u00B9\u00A0\x01\u00F8\ne\u00BCCK\u00D5W\u00E9\u00EB&a\x02\u00DA\u00E7\u0081dW\u00DF\u00A1]\u00E7\x12H\x11\u0084\u00CB\x05\u00E9g\u00D9\u00FF]\u00C2\u00C7\u00BD\u00BA\u00DF\u00A7\u00BB\u00C2TC\x1EaRXH\u00CC\u00A1\u00AC\u00B4<\x17\u00FC\u009DF\u00BB\u0094\u00C1\u00C4R\u00A6n1\u00B88\u008Dyv\u00FD8\u0091K\x19\u00FCS=\x00<\u00CFK\u00AE\x03\u00A6b\u00B0\u00A8\u00CC$\u009C\u0098\u0090\u00DF\u00DF\u0099\b \u00A3\u00DB\"+\u00E2(\u00A8\u00CB\u00E3\x13\u00D2\u0080\u00E8\u00EF\x03\x00d,9\x14n\x00\u00AE\u008C\u00BE\u00C4P\u00A8_?\u00D9\u0087\u00C2_M<#U\x11g>\u0082\u0086\u00F9\x15\u0097|\u00F3\u00D6\u00DF\u009E\u00F74\x00\x7F\u0086#lG\u00CC\x10Tu\u00F8\u00D9\u0083?\u00FB\u009C\u00EB7\u00AEu\x18tH5\u00E7.i\n\u00DB\u00A5\u00E9F\u00B0(+\u00A3\x18\x07\fXC\u00935\u00CCt\x0E\x11&'\u00CD0b\u0086&&\u00D1Fa\u00DC\u0080y\x00F\u00D0\u00AFN\x1F\u00FEDi\x00`\x1E\x0B\x11[z45\u00D1\x7F^\u00D1\u00C1\b7zQ\u00AATKsi#\u00EF\u00D7`\u00BEeg\n\u00E1U\u00D8\x01\u00DA$\x18\x15\x02\u0086*\u009A[\u00F0\u0094\x12<\x16\x14U\"\u00E4o\x023B1b\u00AF\x19\u00B3b\u00982O\u00C9O$\x07z\x16\u00C8P\x00\u0090qu~v5@5rv\u0092\u00D1\u0095\u00A8\u00C3\u00B8~\x063B\x1B4\u00AE~\u0087\u00D8iZ\x19\u00AF\u0090\u00CCJ\u0099\x02\u00DD\u00FD\u00DF\u00D8\u009B\u00D1G-\u0095\u00C1\u0098\u00AD\u00C0\u00C2\u008E\r-51U'\u008B\u00A0:\u00E3\u00B5\u00CEB\u00FD\tB\rX\u00CF\u00C2|~\u008C\u0084\u00A7\fX\"\u00D3HT\u00A4|n\u00C9\u00FB\u0090)\u0088o\u00FAjU\u0092\u00B8;\x15\u00D5\u00A0\u00CA8\u00874\u008D\u00F5\u00C1\x18\u00EC\u00A4\u0080\u00AD\u008F\u00A8\u00DA,\u00BA1\u00B3\u00F9\u00D6\u00AD8\u00F8\u008E\x0B\u009E\u00A3\u00DB7\u00BEF\u00D6\x1ExD\x1B\u00BD\x1C1Cx\u00DB\u00F2\u00A2\x1Fy\x03\u00DEpV/n\u0097\u00BB\u00BBmA\u00B0G\u00D4\x03\u0096\u00B2\u00CAQ\u00D3\x01s\u00CF#\u0098\u00C1\u00CA\u009C\u008D\n/\\\".\u00F7\u00FD|e\u0088q\x03\u00D3\u0091\b\u00EBI\u009C\u00DDa\"\x11C/\x7F\u00B4*\u00AB\u00AB\x12Le\u00EEE\u00D7\x0F\x1D\x15\u00A9Tqy4\u0080\u00C2\u00DA\u009B\u00BB\u00ABVtT.\u008E\tq3\\9\"\x1A+|\u00AF\f\u00C5\u00DF\u008E\u00D6s)I\u009Cx\x18z\\\u0089\x19(v\u00DA\u00B0F\u00F8\u0093d\u00B7\u00F1\u00C5C\t[q\u00EDY3\u00A2\x11.\u00F6\u00C8\n\u0094\t\u00AA\u0091\u00B8\x7FYM\u00D2\u009Cq\u0090\u00E0Sb&\u00FB\u00E2x\x14\x19i\u00C99\u00F0-\u00E0\u00E8^-Oa\u00FD\u00F9y\u00B1\u00E9m+D\u00C9q4\u00C4N\u00CF1A\u00EE2\u008C\u0099R\u00D8\u0096\u00F1d\u00C8\u00EA\u00F3\u00CBq8\u00EAP\u00B1\u00F3\u00C2>\u00C0s<\u00E9I\u00C9D\x15i\u00F4\u00E4\u00A9\u00E5])\x19d\u00FE\f\u00AA\x12Dm\x00p\u00E5\u00FB\u00CF\u00DA\u00FC\u00AB?\u00FE\x11\x00\u00AF\u00C5\x11\u00B4#b\b\u00B7\u00EA\u00A6\u00FC\u00D2\u00E6\u00AF\u00FD\u00DA\u00B5\u00EB\u00D7q\u00CAA\x18ww5\u00F5\u00FB\u00EE\u0085`C\x05\x1BX\u00C3\u00809\u00E6\u0098a\x01\u00C16\x18\x13g:\u00F3\u00E8\u008C\u00C2T\x06\u008F\x13\x103\u00D4u\u00D0v\u0090\u00CC\u0080\fB\u00C5\\\x7FZ\u00CEcP\r=\n\u00C6\f\\\u00CE021\x10\u0085\u00DB\x1E\u0094\u00B5\x18m\u00C1\u00D8\u00B5\u008C5pfA\u00D7\u00A0/\u00A4\u0088\u00D8\u00A3\u00F4p\u00C6\u00A4Z\u00B2\u008CbW%\u00E0\u00AA\u0096\bl\u00AD\u00AC\x14\x0FV\x1ASW\u0086\u008BJ\u00F0\u00E5\u0084>\u0094gc\u00FF3djt\u00B9\x07U\x03E\u00B9o\u00B6:C\r\u0082\u00F5\u00AD\u00FD\u00B8\u00F5\u00A2\u00F3\x7F\tG\u00C0\x10\u00EE\u00B0\u00DB\u00F1\u00E3\u00FD\u00EAG\u00BEux\u00D3\u00D9KYB\u00CB\u00FF\u008EE3\x0B\u00FE\x00\u00C5:\u00F6\u00A0a?f8\u0088\x01\u00DB\x10l\u00A3a[\x1A\u00B6\x01l\x01\u00D8\u0086E$.\x01l\x0B\u00F7o\u00F0hEa\u00F8\u00B2\u00FD\u00D1\u009E\u00ABJ\u0097\u00A2\u00AB\x12d2\u00A8\u00C1K\u00B5fB\u008D^l\u0081:\u00F2x+\u00E7\x0F\x18\u00DD\u00DB\x11\x05R\"\u00B1I\\j\t\u00D0\u009C i0\u00EC\u00EE\u0092r\x03\u00A9%\u00FA\t\u00CCHg.B\u00EE\r\u00D1\u0099\u00F3\u00D0\u00FC\u00CFU\x17\t\u00B7\u00A0\u00F5),\x0E\x02\t\u00F7&\u00C2\u00AB\u00A7N\u0093\x19\u0089g\x11\u0084\u008C\u00A9\u00F0\u00F14\u00AB\u00C0\u00C4\u00F8\nV\u0084b\u00A2T\u00BAS\x19\u0088\u00D5\u00C2\u00E8\u00CB\u00F8~i\rh\x12\x02^buq\u00FC\u00C0D\u00AD a\u0085\u00EE\u00EF\x7F\u00F1y\u00C8\u00F9\u00EC\x00m.dzT\u00EF\x10\u00EB\u00C8\u009F\u0085\u00E4P\\\u0083\fI'z\u008A\u00F8\x01\u0097\u00DA\x1A\u00E7\x0Bv\u00D6\u0093l\u00D8\u00C1\u0094\u00E3\u00B3\u00C4\u00DC\x07\x02,\x11\u00A8\u00F9\"xIA\u008C\u008C\u008E\u00E4\u00B9\u00EA\u00E3\u00AA\u0081Sn\u00BC\x1C>|\u00F9\u00D9\u00E3\u00BB^}\u0087\u00EB/\u00DEa\u0084\u00F0\u009A\u0083\u00AF{\u00D6G\u00D6?\u00E4\u0093w\u00D7\u0084*\u00DF\u00B1F\u00AEi\x05D\u00972\u00C7\x1E\x15l`\u00C0L\u00E6\u00B0\u00C0\u00A1\x19\x06\x190x\u00CA\u00F2\u00B6\u00FB\u00B3\x1B\x06,]\u00CF\x1EP\u008D\u0084%\u00B6\u00C0\u0089\x19\x11b\u00EC/\u00CB?\u00B7\u00A4\u0098\u00F2?#\x06\u00BB\u00D6j9u4,]M\u00D1bl\x14HT\u008B\u00EER\u00FAP&\u00D3\u00F8\u00BD\u00B9(\x14\u00BE\u00D8J\x04\u00A2\u0087\u00AE\u00DA\x16WC\u00AA\u00B3\u00CD\u00B3\x02C\u00FAJ\\_\u00AB;\u00D9\u00FE\u00D9U\x1E\u00DAB\u00CA\u00FD\x1E\u00FDwJ\u00FBf\u00C4\u00A4]3.H\u00D2\u00A1G_\u00F8\u00A1\u00E5\u0083\u0093\u00B8 \u00A1~Qv\x15\u00D5\u0080\u00D6\fvG\u00BEB\u00CFc\u0085\b\x01@\x19\u00A4t8\u0099\u00E4\u00E1\u00DE\fr\u009A\")\x1F\u00B5\u00D8;\u00B0@\u00DB\x15[\x06\u00EF)\u00E4'R\x0EW\x14\u00B4\u0082\u00CC\u0082\u00C9{\u00B5\u00A4\u0089)\u00B9\u008Ew\u008Ax\u00D4\x03\u00CCRm\u00C9\u00B9\u00CBHF\u00AEI\x18\u00BA\u00D1j[\u00C8!e\u00AE\x06\u00B0~\u00CB\r\u00D8\u00F7?\u00DF\u00F4,\x00?y\u0098\u0099\u009A\u00B4;\u0084\x10>\u00A7\u009F9\u00F5\u00A2\u00E1\u00A2\u00A7\u00F5\u00B6\u00AB0\u00F38\x02Ce\\\u0082\u00EC@\x12,\u00E3\u0082\u00F8\f3 \u008A@=?\u00A03\u00AB\u0090\x01+2\x00\u00ADAZ#]\u00D9\u00F9\u00B1x\x1A,\x04\u009A\u00EAAap\u00DE\x17\x19]\u0081\x04N\u009C)\u00BD#8F\u009A#\x11{F\"+\u008D\u00BE\u00AC\u00D8LV\u008F\u00AE\u00FD\x16U\u00A8d;\u00C6_0\u00AB\x1A4\u00C51\u0094\u00B1\u00C0\u0088\u009B\u00D7\u00B115|zO\u009F\u0094*\u00A9\u00CBsR\u00C5\u00D06C\u00A8\x07\u00BC>\u00E2=*\u00E3\u00F79.\u00EF{\u0095\u00A0\x03\u00ADL\u00A4\u00BB\u008F!\u00CA\u00B4U\x02'\x1AA9\u00B7\u00F1e\u0096\u00E7\u00A9\u0081JD\x00\u00F5y\x15\u0099FM\x04\u0091c\x12\fh\u009F\u00FC\u00C0\u00D3\u00F4\u00AA\u00CBO\u00C5\x1Dhw\b!\u00FC\u00ED\u00F6\u00C5?ua{\u00D7F\u0096!96\u00CD\u008Cj\x1E=\u00C7\x04\x19X\u00C5\"C\t\u00CD}\x0E\x19\u00C1\u00D8\\j\u00E7&.$\u00CC\u00C1\u00A59\u008D\u0089\bb\u00A6\rB\u00D4\u00E0q]\b\u00A6B\b\u0096\x0E\u00E1\u00E8A\x10 \f\u008E)u\x1D\x11\u00B8[\x12\n4\u0087\u00EC\u00A3/\u009C\u00EER\u00D8\x02\u00AC\u009C0Cof\u008C\u0081C\u00C4\u0080\u00A5\u00BE\t\u008D\u00B2\u00EC\x1A\r\u00A1@\u00C1\u00DD\u00DE\u0097\u00BA\u00F7.%\u008F\u00C8\u00E0k\u0089\x12\u00DB\u00A0u\u00F3\u00EB\x1DX\x17\u00C9\u00ED\u00A8#\x10\u0093\u00AD\u0082Fh\x1A\x02\u00D8-\u00FF\u00F5\u009D\u00B5\u009Ee\u00D1\u00C4;\u008B\u00BF\x0E\u00D1\u00B9I\u00BBncQ\u00D7\u00FFm\u00F8\r\u00DA\u00DDU\u00E7\u00AB^\u00D0l3Z\x12\x1F\u0091\x07\u00FC\u00DF \u008AUi\u00EF\u00CF\u00AD<\u00DF\u00F2\x1D\u00C2\u00DB\x02\u0084qR\u00DD0\u0087.\u00E6\u00FB\u00F7\u00AEl\u0095\u008C\u00D0\u0088_h\u0085\x10]4\u00A3\u00C16m\u00B1\u00F1\u0087]#\b\u00DE\u00CFS\x18Qw\u00D8<0N\u0082\u00E7\u00F0\u009A\u00E2\x16\x15\u00F5\u00FE\u00B8\u00DB\x16\u008D\u00C0\u00BD\u00C73\x11aj\x17HW\u00B4q\u0081\u00F5O\x7Flc\u00FF\u009B\u00FE\u00F8\u00A7\x00\u00BC\u00E00\u00A4\x15\u00EDv\x19\u00C2\u00D6\u00F2@\u00FB\u00D7\u008B_\u00F8\u00E9\u00AD\u00B5\u00BDH\x7F\u00F7\u00B1jU\u0082\f\u0093\u00BFmi\u00B8Q\x15\u00EB\u00DA0\u0097\u0086-\u00D7y)M\u00A2\u00DC\u0089\x13\u00961\u008A\x04\u00D1\u0091\u0081H\u00E2\u00F2\u00F3\u00A8\x0E\u00D4\u00C2 \u00EA\u00C46\u0080\u00B6\x06\x7F\tN\u00B0\n\u00EE\x1C\u00E8\u0088@H\x10\u008C9K)\u0093\u009E\x02\u00C5\x10\u009B\u00C6\x12\u0099\u00B2\x10k\x03\x03\u009D\u00D2Ah\u008B\u009D\u00C7\x03\u00E2\u00FB\u00FAa\u0090S\b\u00A0p\x11\u00B8z\x000\x04\x01\u0088s\x10\u00C7\x11gec\u00E4\u00BCS\x07b\u00B7e\u00EA2A\x1C@\u00D8\u0097\x18OP\x02\u009BHaY-\u00C8]\u0080\x11}\u00C8-\u00D58\x1E#B\u00EB;\x0B\u00BA\u00A0\u00E4E\x04\u00C3!\u008C.\x1B\u00D1N\x1F'\x1F:B\u00A4\u00C3\u00E0gk,\\\u0084\u0084\u00FB\u00CED\u00ECJF \u00FA\\2\u00DD\\\u00BB\x07Ka\u00F2{DG\x06\u00AA\u00F1\u00BE\u00AB1\u0095\u00EE\u00CBp3R-(\u0088F+\u00B3@\u009E\x17\u00C6S\u00FF\u008Dh!fE1h\x07>|\u00E9O\u00EB\u00DE/\u00BEH\u00EEw\u00F2m\u00EA\u00FB\u00B7\u00CB\x10\u00AE\x18>\u00F1\u00A4\u00BF[\u00BC\u00F5\u00F4\u00DE\x00\u00A0\u00EF\u0098\u00E3\u00BB\u00AFQ:\u00CE\x01\u009D\u0081\u00A9\u00BB\u00B99\u00EA\f\x0B\x01n\x15\u00B3.\x18A\x0E\u0098\x17\u0083\u00E0\u0082\u0084\u00AA\x1E\u00B4\u00E4}2\u008Dut\u00A2[B\u00C0-\u00E0\x1A\u00EAn\u00D3\u00FE\u00AA\u00D4<\b\u00CB\u0088\x104\u00F7\u00E6\x00\x17dRC\u00953\x17\"\u00D3PZ\b7[BL[\u00CE\u00BA\u00C7\x11\u00B5X\x16\x14mF\u00CCW0\u00B4Rc\b\u00A8\x1Ad\x16\u009F\u00F9\u00D4\u009B\u00AB\u00A1I$<>\r \x00i}:\u00EFQ\u00E3P\u00DD\u0080\u00EF\u0096tqw%\u00D1\u0086\u00EAd\u00B9F?\u00E2\x01J<&d-\n\x0B\u0097\u00E4\u00D8\u008C\u00E0+\u00E1\u009A\u00FA\u00E4\u00DE\x00h\u00CE\x0BLR\u00AA\u00BB\x1Fm\u0088C\u00DC\u00DD\u00EE\u00C5 \u00A2\u008E\u00F0\u00FD\x0B\u0090\u00AEK\u00B7~T\u00C3\u00DF!9e\x12\u00A5\u00ACfY2\"\u00B1\u00AF\u009C\x1B\u00AB\u00A5\u00A0\x178\u0093\u0088w\u00CE\u00E1\u0092q\x14\u0084\x03gT\u0093\u00EFd4dF\u00C6\x1C\n\t\u009EHG\u0099\u00B3A\u00A9\u00AFN\u00E3\u00BD\u0080\u00AA\u00D5~\u00BD\u00BE$#\x1C+\u008D\u00BA\u00AA\u00C8\u009A\u00A3\u00EB\u00CB\u00FD\u00B8\u00E5\u00C27\u009D\u008B/\u0085!\\\u00A3\u00D7\u009Dt\u00EE\u00E6\u00B9O\u00EDm5\u0093\u00F1\u00EEW\x1C\x04\u00BE=\x19\u00B7>\u008F\u00B7\u009B\u00C6 \u0095\u0086\x05\x06|\x11\x03v\u00A1\u0099r!3\u00CB\u00CD\u00F3\u00AAI\u0083\u00DB\x06b\x03\x14\"\x044\u00B0\u00B8i\x0B\u0084\u0090\x0E\u00B6\u00E0\u00C3*\u008E$\u00CC\u00E0\u00A3j/\u00BBF;\u00DA\u00B9C \x03\u00AB\u00C8l\u00E3\u00ED\u00A0{\u008D9\x11\u0088gY\u00F2\u00EEb(fbd\u00E2i\u00A17\x0B&\x1B\u00BF\u0086[\u008D~\u00F4B\u00E1d\x1E\r\u0099\x0B\x00\u0097\u00AE\x15\u0089D\u00D3\u0089\n\x10\u00D6mF\u00FD)-\u00FCIx\u00B9:8>\u00EFg\u00D2\u00AF\x13\x06\u00C7O\u00A9\x06M\u00A9\x1D\x1D\u00D5<\x01B\u00EC\u00ACM\u00C0\u00E4&S\u0097\u00B4\u009C\u00EB\u00F7Q\x14\u0086UU\u00AD\u00D2\u00BF\x02\u00CAd#\x12\u00DFd\u00D1\u0089?\x7FM\u00BEb\u00AA\u00B2\u00A3\u0096\n\u00D7\x0F\x19qE\"g\u00FF2\u00F9=\n\u00B8\x06\u00A6j\u00E5x\u0099\u00A7\u00C9q&b9\u00E3\b\u00F5&\u0091\u008D\"U\x07\u00AA8kW\x7F\u00F8\u00A9\u00FA\u00F9\u008F\u009D$_\u00F5\u008D7\u00E30\u00ED6\x19\u00C2\u00FF\u00DA\u00BE\u00E2G\u00DF\u0087\u00F7l\u0088\u00CE\x00\u00B9Sw\u008C:\u00C2f\x15\u008F\u00B8\x11+K\u00A21;P\u0095\u00B6\x02\u00B3\u00E8n\u008Ab\u008F6\u00AC\u00C9\u00CC\u00E2\x15\x15\x18$}\x01\x10\u00B5]\u00A0}\u00F1\u00B2@\u00C6L@\u00EC\x00q\u00D4\u00D0a\x1E\x07\x06%\u008D\u0092R\u00A3\x01\x101\u00CF\x04\u00B9;\u0097g\u0087y(\x06\u00B4\u00A0\u0091\u0080\u00F9HGT\u00DE\u00D1\x18\u00C4\b+Y\u00A2M`{1j\u00BA#\t\u00FF\u0095R\u00CF1\u0085\x1B\u00B7\u00B4\x19R\u00E0\x1Aa\u00B5\u00A4\u0088e\u0080\u0086kR\u0089>J\u00B3{\"U\x0B\u00A1\u00DE\u00CCPe\x01\x0B\x1D\u0087\u00FBs\u0082\x12J#4'\u00DD\x13\u00DD\u0088B\u0086\u00F2\u00A3\u00DFk\"1\u00C3m\u00D7\u0091\n[\u0081\u00F0\u00D2`%\u00D4\u00FD\u009C\x1D1\n\u00F53\\\u00AD \u00F3\x17d\u00895\u0087\u00E0\u00F5\u00BB]Q\u00FE\u00F1\u00C8N\u009A\u00F2\u0083\u00D1\x19^\u00A4*S\u00DFh\u00BD\u00F7\u00E4_\u00A2\u00B4\x18\u009F\u00AFY q\u00CC\u00AA\u00CA0Q\x1D\x14\u00C9\u00DC\u00E2\u00E9l\u008D\u0094\u00BD&\x0E\u00D5T\x15\u00C35\u009F\u00DC\u00B8\u00F5/\u00CF\u00FBQ\x00\x7Fx\u00B8\u00F3n\u0093!\u00BCe|\u00EB\u00D3\u00F7m\u00DC\u008A.U\u008B\u00BE\u00BB\x1B_d\rr\u00A9\u0093\u00E6\u00A4F\x03\u009C\u00BB\u00DFn\x11\u00C5\t\u00AE&\f\u00D20\u0087\u00A55\u00CD\u00B5\u00C4\x1C\u0088\u00A4\u00FB\u00AC\u00FC\u00AE\x1E\x13\u0090\x11\u0088TQ\x10\u00D2\u00DD\x18\u00D1,\u00DCf\u00D3\u0094ic2\u00CD\u00EF\u00D1\u008A\r!\u00AB)Q\u00EE\u00D4c\u00F463\x10\u0088l$\tz\x12\u00AB\x0F8<\u00A5A3\u0099\x1B\u00AB\x1B\x07\u00C4wv\u00C4\u00FC\u0088\u0080\u00C1&\u00FA|\u00AE)R(\u0095\u00ED\u00B70\u00A4z\u00EE\u0083m6\u0083P\t4\u00A4\u00A3&\u00BC\u00ADR\u009F\u00F7\u0086\x16T\u00E1\u00C3\u00EA\u00E5^\u00E1?K\u00F4!A@=\u00C7\x05\u00D7/te\u00DC\x05N\u00A7\u00BF>\u00F36R\u00F7N\u00C9\u009E\u00DB\u00B7\u00AD\u00A2`#D\u00FA\u009F\x02\u00B2+@+\x7F\u00C6\u00E4Ti^\u00A4\u00BDq\u00D1r\x1FC9\u00E6\x1D\u00A0\u00FA@\u00A3$\u00C7\u00E1\u008CC\u00810pr>\u00CB\u00BA\u00B7\u0090mu E\u00EF\u008E3\x07N\u00A3??\u00A7k\u00DE\x17\u00D8\u00FA\u00D0%O\u00C7\u00D10\u0084\u00EBu\u00DF\u00C3~x\u00F3\u00A9\u008F\u00EF\u0093\u0082\u0095\u00C7\u00A25\u00E4\u008E\u00C0\u00B5\u00EA\x11an\u0081\u00D6\u0085\u00E3.z\u00C3\r\u00E2\u00FB.\u00A9:B\u0080o5_!\u00B9\u00873\u00D3\u00BD\x07I}0\u008EcBLD#\u00AC\u008A\u00F9\x0F\u008F\u00D7\u00CB\u00DF\u00F30\u00F9\u00D6\u00EF\u00BC\x06\u0087h\u0087e\b\x17,\u00DE|\u00CE\u00A5\u00B8\u00F4X\u00C1\u0082\u00D2\x06\x00\u00EB\u00B0\u0082'T\x0B\u008CP\u00E9\u00C3O\u0089@\u00A9`\u00BA\u00EAAi\u00D8\u008B\x01\u00BB X\u00D3\u00C1\u00B3!\r1\u0088\x133\u00C9\u0088\fB\u0085\u0092:\u00E3\x16F\u00CF\u0094\u00CC<\u0082V\u00CE\u0099\x02Nj\u00DC\u0095M\x13\u0094\x0E\x18\x10!\u00F3\u00B0\u00D4lH\u008F1\x18w\u00EFf\u0098\u0094d\x02M\u00B88\x04\x16PC\u00AEoz}x.T3\u00E8\u00C8\u00E7\u00A5\u0092s\u00A0\x064wo8\u00D1\u00BA$\x0F\u0095As+\u00B6j\u00C0\u008B0\u00E7p\x0F\u00E6\u00ECW\u009BB\u008F\x1C\t\u00D8\u00EFf|q\u00E3\u00DD\f\u00DDk\x1B\u00C6NG\u0085iA\u0096\u0080\u0088mQ/\n\x1DK=o\x0E?f\u00D5\u00F3\"\u009C\u0089\x18O44\x1B\u008E\u00826\x00\u00A3\u00BF\u00A5\u0089\x04w\u00A2\u009A0\u00D7\n\u00D5\u0081\u0084\u00E9\u00D3\x16\x01\u00A0$\u00BC\u00B0\u00C1tT\u0094\u0092\u00E8\u008CL\x0B\u0098\u00AA\x15~\u00A6\u00B62\u009B\u00FE,\u00AAa\u00C7\u009DVkv\u0083\u00EC\u00C4\u00C0Xb\x14z\u00BE\u00F5\u00C9\u00F8; :b\u00D7\u00F5\u009F\u0093[\u00DF\u00FC\u00FAs\x00\u00FC\u00D7\x1D\x03\u00C1m0\u0084\u008B\u00B7\u00DFs\u00CE\u00D6\t{o3:\u00F4\u00AEo3\b\u00E6\u0080\u00B8\u00ED\u00A0J\u00CFp\u0099\u00D5(?\x12\u008E\u009D\u00D7\u00B5a\u00AF4\u009C\u0080\u0086\u00990\u00A2\u00C0\\\u0091\u0083\u00D7JX\u008A\u0095Z_\u0082\u0081A\u00FE_\x157\u00EE\x05\u00B9\x01ji\u00D5]\u00C4K\u00A9\u0099ps\u00F9\x1E\u00B2p\x14\u00C6\u00C8\x0F\u00CEt<\u0091I\u00AA\u00CA\x00\u008F\u00F8K5\u0083\u00F5\x12\u00C9\"\u00FC\u0097\u0088S\u0097\u00F2\u00FCA\x17\u0093\b\u00C5\u009E\x04\x16\x11n\\\u00EE\u00C5\u00AFO\u00AA\u00AA\u00EE5!\u00CA@\u00FE6! \u00F5s|\u00F1\u0092\"\nl\u00CF\u00CB\u00C9A\u00EA8y.k\fT\t\u00CC\x11\u008E\x10\f&\u00CDc+xx?V\u0090\x154hv\u0092\x10359\u00DE\x01;\u00A4\u00BB\u00F8\u00F5A\u0098\u009C\u00A7\x01,r\"Er[\u00A1\u009B\u00AA\n ?\u00C7\u00FC\u00F3\u0098\x14T\u00E2\u00FDO\u00EA\x19\u00F8\u00F3\u00D1\u009B\u00A4\u00D9\u00C7\x04Y\u00F0;]\u0090q\u00E3D\x7F\u00C9|\u00C6@\x01Y\u00AF\u00A1\u00A2\x14\u00C5\u0084\u00F1P\u008DTE\x1B;\u00DAG/?,Ch\u0087\u00FA\u00F1\x1A\u00BD\u00FE\u00A1\x1F\x1A.}L\u008F\u009B\x1C\x1B\u0096 \u00A8nE\u00FF<\t\u00D6\u00A0\u0091h\n\u00B3Eh\x12\u00B4R\u00EA7\x03\u00D8\u00AF\u0082\u00ED>`\u00A1V\u009Bq\x01\u00DF\u00E8E\u008Dq\u00A8\n\x16RB\u009A\u00DDE\u00B9\u0084y\x15\x16\u00C2\u00D8\x03\x0Fe\u0096\u0086\u00A50\u00F4\u00D9\u00A2!\u0097:\u00F3$)\u00BAH[\u00B8}\x00\r\u00C4A\x06\u00C6d\u009F\u00F8\u008E\x06\u00AB\u00C1\u00C0Me2\u00CC\u00B9BCF\u00C9\u00E5\u00C6-\u0096\u00AA\x1D\u00B1\u008E%\u00ECX\u00A4\u0095\u0099\u00F1F\u009F\u00B94d\u00D9u\x0F\u00BE\u00F2MP\x04Y\u008A\u00CDB\u00A5g\u00906\u00C45\u0093\u00C4%\u008F\u008B\u00C8$##\u00CCI\rB\u008E=\u00DE\r\u00AB@\re\x0EL\u0085\u008A\u00E7\u00AD*a\u009C\u0097HP\u00B50! %\u00A7r>\u00B9\\\u008C\tN\x0B\u009B\x165\n\u00E2\u00F3\u009Eu\x18i\u0093\u00D1\u0080\u00DF-\u00FE\x15w%KOi\u00AE\x11\u00B1\u00C9\u00A45^\u0087\u00BCg\u008Dw\u00F0\u00B9\u00B3\rar\u00C5\u00C7\u00F9\u00BA\u00F2\u00D6\u00D8/\u00F2x\u0084\u00B2\u00ABL\u00E9\x02b\u00B6\x19gJ\u00E1\x1C\u00F1Ml\u00F5\u00EA\u008F>F\u00AF|\u00EFCq\u0088vH\u0084\u00F0\u00FE\u00AD\u00CB\u009E\u00FA\u00A1\u00E1\u00FD\u00A2my\f\u00D1A\u00F1\x1C\u00AC,\u00AA\u0086\x06\x15\"\u0083\u00BA\u00E8\x10\u00E7\u00E4\u00AEH\r\u00FB\u00C5\\\u00913X|\u00C2L\x1B\u00E6\u00F0\u009D\u00A4=\x18H`Kq\tF X\x12\x12\u00F3\x17\u008C\u00B9\u00A4\u008C\x1E}w\u00EF/\u008Cg<\u00B7\u009E#\u00C6\u00A4xn0\u0097\u00D1\u00CF*\u00F7v\x0FCT7V\u00C4oY^\x0E\u00D1w\u00A3\u00F1N\u0081Iy6\u0091\x12\u00C4\u00A4\u00E6\x1A\u00F6\u00D4\u00B7\u00BCW\u00CE\u00F7\u00C4\u0086\x10\u00DE\x0E\u0081j\u00DDQJP\x19\u0081\u00D0u\u00CC\u00F9\u00E2\u0098{QM\u00B49\n\x00&5\x19BUi\u00C1\u0084\u00AA%\t\u00DA1W\u00C5\u00F2\u008A\x0F>\x05\u0087`\b;T\u0086\u00EBu\u00CF\u0089\x1F\u0097\u008F>\u00A1\u00B7#\u00AA\u00CDx'6\u00BE\u00F8\x1606e8\x00pwf\u00FA\u00FE\u008B\u00B4\x04w0\x02\u00A6j\u0086\u00A1\u008D\u00BD*\u00D8'\x03\x0E\u00C8\u0080M\x01\u00B6\u00A0\x18;0v\u00C1B\u00ADL\u00BB\x11\u00B7\x0B\x01\x11\u00DF!\u00DA\u00D2\u00A8\u00BB\u00C34F3\u009A\u00CF\u00BF\u00B9\u00CAQ\u00BE\u00D3.\u00A04P\u00DA\u00A6.\u00DD\u00EB p\x03\u0099t5f\u00F6\x1F\u00F7\u0098P(zx\x1D\u00CA_0:>\u00A63&\u00F1\x04*i\u00E6\x16\u0094f\x06\u00B5\u00C6\u00D0*GU~N\x17Af;\u00BA\u00B7#j\txt%\u00B8\u00AFd\u00E6\u00F8\u0087\u009A#T\t\u00CAq\u00AA.m\u0080xv\u00A41\u00F4\u0096\u00EF\u00D1\u00C7FH\x0E(\x10\u00AACaR\u00C1\u00D0\u008A\u00AA ^\u0086\u00DD\u00E1\x15\u008D\u00C1\u00B6#t\u0081\u00CD\u00C5\u00B5Ji\u00A9\u0091.\u00EC}\u0093=\u00F6Da\x02\u0098\u00C14\u00F4~7\u00D6\u00F9|\u00D3\x13\x05\u0087~\u00A9\u00A6\u00B1\u00BE\u0082\u00A2\x06k\u00E5\u00C6\u00ADpDAAW\x18\u009B?\u008B\r\u00B3\u00AC\u00E5b\x06I\u00A3\u00ADf2Y\u00D7\x12z\u00CE\u00E3\u00E2\u00D1\u0093\x151#\u00F9g\u00ED\u00F3\u00BA\u00CF?A\u00BF\u00F0\u00F1\x13\u00B1\u00D2v \u0084\u00CB\u00F5\u00D3O\u00FA\x00\u00DE\u00BB~\u00CC\u00D1\u0081\u00EBsf\f\x02rQ &\u00B1\u00EA\u0082)u\u00EAb\u00B3\u00F3\x18SpP\x047\u00A9\x15g\u009D\t0\x13\u00AB\u008C\u00C4x\x01\u00C0\u00F6\u008B\x14\x01\x18\u00A3\u00D8`\u00F6\x03\u0086\u00D6r\u00A9\u00D9\u00F6b\u0099\u00B3\u0090\u00A8@\x10\u008BQh=f\u00F2\u008D\u00A2a\u00C0\u00A8\u008C\u00844\u00CE?\u0082\u00BA\u00B7\x19\x11\u00AD\u00D2\u0092\u00E5G0\u00C6\u00813\u00C0\bE\u00A2\u0084L\x00\u00F2\u0081\u00C3\t&\u0082\u0099\u0098\x1D\u008A \b\x03\x0E\x1E;Q|\u00F21cQ\u00FD\x18\u00C8\u0083\u009Ak\u0098\u0096f\u00F1\u00DF\u0095\u00F7\u00F6]\u00A2\u00E0\u0086<\u00BE\u00AB\u00A8oP\u00DF[\x05\u00DBD\x0F{\x18\u00F7xOw/JJ\u00CB\u0098\u009B\u008A\u00C9\u00B5\u008E\u008B\u0086\u00C7\u00D2\u008F\u00C3\u00EF\u00A9\u0085\u00BF0\"~\u00A6D\u00AFT\u00C8\u0089\u00F7\u00ECE\x06\u00A9\u00D9\x14\u00B6\u008C\u00AA\u00D4\u00B2\u00D9M \u00AE\x1CN\u00AE\u00EC\u0082|\u0094/\u00B5E\x1F\u00C1l&\u00C75\u009EE\u00AF\u00FE\u00C4\u00FA\u00D6\u00DB\u00DE\u00F8$\x00o@i;\x18\u00C2\u0085\u009Bo\u00FD\u00FE\u009B7n\u00C2\u00A0\r\u00E3]\u00B4g\u00E3\u00ED6ui\u00E00\u00DE\x16\t\u00E3\x10l\"\n\bBr|\x0F\u008D]\u00F9\r>\u00F9#\x04\u00FBD\u00B0\x07\x16\u00CE<\u0087{\x1F\x14\u00BEAl\x1A\x1A\u00B7\x0B\u0083\u00E8jD\u00CA\u00A4\u00A7\u00E0\u00C8(\u00DE\rg\x02\u0099\u00F3`)\u00CE,\u009C\u00D2\u00C5\x7F\u00F7B-\u00AA-<\x14D<\u00BC\u008E\u00EEM\x16de<\x03\u00C3\u009E\u00E1\u00E7X \x14\u00A1v\u00DA/\u008Cp\u00D3hF\u008B8\x19YX\u009D\u00A1\u00E9%\u00D1:gH\u00CB}e\b\x10\u00C0c\u00E7\u0095:.\u0095i0\u00A8\u00AA\x07dV?\x1Fp/M,b }3F\x1A\u0091\u00BC\u00B4\u00CA\x00\u00F89\x18\u0097\x07(\u0085NNX]\u00C0n\u00C0e\x12%R\u0090\u0094J\u00CEq@K\u00B2UxH\u00FCZ\u00E3\x00\u00E5\u0092U\u00C3\b\u009B\u00CF;\u0098R\u00BDb\x7F\u0098\u00CC\u00AF3\u00F3`\x18\x1C+\u0092\u0080s\u00C0E\u00C2\u00F37\u00CEe\u00B9\u008FGv\n4\u00DFq\\\u00A7\u00F9\u00DD\u00EF\u00B11.\u00B0\u00EF\u00E2\u00F7}\x1Fn\u008F!\\\u00D5>\u00FA\u00BD\u0090\x05\u00D2\u00A2y76Up\u00E7\u009B\u00A6^\fClkv\u0080\u00D0\u0089\u00E8\u00A10\x035\b\u009B\u00CC\u0080\x05V\x1D1\u00805\r\u00CC\u0092\u00FDE\u00ED\u0098K\u00C3\x1C\u00DD\\\u0090hh\x1Eq8hn\u009BjD\u00ED\u0089NJw\u00A3\u0085/\x13\x15\u00C4\x06\u00AA\u0090\u00D8\u00A2\u009ED\u00DB0x\u00A4b\u00B8\u0088\u00C1\u00ADAX\u00B9\u00B9C#\u00E6\u0080\u009E\x06\u00CA\u00B14\x13\u0099\x04\u00B1\u00BB\rf`t&\u00C0 *\u0085\u00D7=\bfe\u0086\u00BD\u00E6?q\u0091\u008B\u0087,\u00B3\u009Aql\x0B\x07\u009D\u00D2\u00E0\u00AA\x0F^\u00C4\u00E2\x14\\\u008F\u008D:\x01\x00\u0098\x04\u00D5\u0088^\u00D0\x1C\u00D2\u00F2\t`\u00EF\u008D\x0BS\u0080\u0088\u00E0\x10\u00C0\u00AA\x1F\u00F9Vq$l\u00D2\u0082.!\u009E\u00A4\u00C5\u00ED\u00CB\u00C8PRS\u00AF\u0084\u00E6\u00918\u00EAv'I\x17]\x18J\x0B\u0086\u00E6\u009E\x1BtcN\x10\u0087x\x1A\u00B6\u00F9\u0088\u00D3\u00F6@q=r\r\u0092y\u00F0\u00F9\u0097\u00F6\u00AC4\u00A0\u00F6\u00CA\u0084$\u009F/~\u00CE=\x1E\x04j\u00A5\u00F1T2i\u00CD\x14I\x0B\u00C4\u00EA\u00D6\u00AF\u00F6\x16\x15\u00AF\u00C3\u00FE`\u00D5t\u008A7Y\u00C0\x04,u\u0084\u00D7F\u00F1\u00F7\u00DC\u00D1\u00AE\u00BB\u00E6\u009F`\u00A5M\x18\u00C2g\u00F5\x0B\x0F\u00FB\u00C1\u00CD\u00FF\u00FD\u008Cx\u0089\u00C7\u00A4\u0091\u00E0\u0087 b\u00E3\u0084\u0083?(\u00D3\u0080\x0BD\x02\u00BF\u00A7\u0084\x03\x10\u00D2;\u00FD\u00F469[\"\u00D8\u0083\u008E\r\f^\u0098\x04`Y\u00B1&\u00D5^\u00A1h\u00A2Pt_\u0087\\\u0084\u00B5w.\"c^)\u008F\x19\u00FC\u00E4\x05Q\u00A4\u0085\u00DCqYm\u00D7\u00BA\u00EA0\u0082\u0092\u0094s/\u0091\u0084\u00D5\u00D1|\u00D3\u00D9L\u00D1\u0099\u00F8\u00C1\u00E1\u00EAIC\u00EA\u00BC\x13)\u0083$T\u00F7\x00d`\u0091f)7\u00E3\x14\u00B6\u00A8\u009C<\u00C4\x17\x12{\u00CB\u00D8d1\u00EFB\u00CF\u00F9\u00A8\u00FF\n\u00D3\u0082I@~M\u00C6\fp\u00F85B\x11\u0087\x18;+W\u00F7\u00A2\x1E\u00D5V%&\u00FB\t|\x12\u00F3c\u00EF\u009E^\u0086:^)\u00BF\u00D5.I\u0094TCh\u00FC#\x04/\u008C+\u00F6e\u00A8\f\x02\x05Y\x1C\u008A\u009A$\u00EEa\u00CC\u0093\f\u00B3\x04Eiy\x1E\u00AAAPLj8h\u00C3\u00B4\u00FC\u00DA\u008A\u00A1\x12H\u00E4S\u008C\u00CC\u00ADw\u00CC>\u00FD\u00E93\u00F4\u00A3\x1Fx\u0098\u009C\u00F9\u00C8k8\u00AA\tC\u00B8b\u00F9\u0089'^9\u00BB\u00FC\x182\u0083\x06\u00F3,x\u00C9\u00B0\t\u00C1\u00D7i\u009DB\u00AF\u00E9wJ\u00C8zM\x1Ecb\u00D2>4\u00DF\u00F8m\u00865\u00D5\u00D8\x12n\x11\u008ED\u00F3,4'\u00CA\u009A|D\u0092\u00A4'\u00A11\u00E6\x00@W#~2\x06\x120\u0097iw\t9e`F\u00ACV\u00C9\u0099\u00B5\u008F2Yetd\u0090\u0091\u0092\u00E6a3?x\u00E9\u008B\u00A1\u00D5A\u00C3+\u00C6\u00A50\u008A\x11-\x18\u00B3\u00A3\u00D1\u00AA7w\x1DR\u00DA\u00C75(\x0B{*a\x11Q\u0093\\t+\u00EF\u00D3\u00BB\bD\u00A2\u00F5\u0098\u0096\u0085[\u00FB>\x04Q\u0093(+\u0093\x03\x10\u00B5\x0B\u00AB\x00\u00D6\x12\u00EB\u00CF\u0083\u00F4(D\u00DFTE\x10\u00F9\x1Fe\u00A2\u00CA\u00B9\u00E9\u00DAS\u00E6!T\u00E3e\x04\x12\u00F1>u-\u00E6\u00D4\u00C9\u00EA\u00B8\u00E3\x1C\u00FD\u00FF\u0089{\u00B7^\u00DB\u00B2\u00E3<\u00EC\u00AB1\u00E7\u00DE\u00E7\u009C\u00BE\u00F2*6E\u009ATD5E\u00C5V\b\u00EB\x02:1\x1D\u00CB@\"8\u0092\x03%A\x12+\x01b\x04A\x00\u00FF\u0080<\u00E5=\u0081\x1F\x14 \u0080\u00DFb\u00C0\x0E\u0090\u00F8\u00C1\u0090^L#\x12\x02\u00CB\u0092%@\u0092\x05\u00CA\u00B2@\u008B&e\u00D1\u00A1\u00A9\u00B6D5\u00D9d\u00F3\u00D6\u0097s\u00CE^sT\x1E\u00EA\u00FB\u00AAj\u00CC\u00BD\u009Bl\u00C1\u00BA\u00AC\u00EEu\u00D6\u00DAs\u00CD9\u00E6\x18c\u008E\u00AA\u00FA\u00EA:\x1AZ\u00A8u\u00D3\u00EF\u00EF\u00B29\u0088\u00F0\u00DB\u00DC:=\fr\u00B3\u00F6\u00A2\u00AB*>\u0083d\x18\u00FD\u00F6\u0086\u00ED\u00E5/\u00E0k?\u00F3\u0093?\x04\u00E0\u00FF\u00D2\u00E1\u0085!\u00FC\u00C2\u00CD\u00CF\u00FF\u00C5\u009B\u00FB\u00AF\u00E1O\u00EC\u0095\u00FE\u00F3^\u00B8\u009C\u00E4\u00A4\x00\u008E\x1CT,\u00A4\u00DA\u00E0\x13-\u00D0\u00A5$\u008E\u00A9-\u00B7<\u00D7\x11\u00EE\u00C3\u00AF\u00BB\u00E3I\u00F3,\u009A\u00B2a\u00C3\x05\u00B1\u00ED\u00D7cJ\u00DD*\u00B0*\u00A3\u00DF`\u00AB\u0083\u00E9\u00CA\f\x7F\u0096\u00A1P\u00D26U\u0080-\u009FwH\u00FA\u008A\\<\u00F2\u00CC\u00AA\u00B1X\t\u00B2\u0081\u0084\u00C2\u00F0\x17\u00C1Q\u00A5npd\x06\u00A4;\x0B\u0096\u00B6\u0084\u00A0{/\u00A9\u00E5c\u00A5#\u00931-\u00DA\u00AE\u009CF\u00E9\u00C1*)\u00D6\u009E\r\x17\u00AE\u00A0'\u00CCs[2\u009E\u0080Jr\u00C2\u0089\x18\u00A5\x1C\x11\u00F6fX\u00F7\u00A0JO\x1B\x01\u008B78\u009D\u00BBz\u00CCI\u00C0mw\u00EB5:\u00D0\u00D9n\u00D93\x14\u00F7Q\u008C@s\u00A5\x10f\u0084\u00E0\x11\u00F7t\u00A1+\x05\x18X\u008D\t\u009D\u00BDw\u009B\x06\x0B\u009F\x0E\x00\x07%\u00F5l\f\x03\u00D1'\u00F3\x1E\x14\u00C5y\u00F4\u00AE\u00947\u00CE1\u00F9\u00BC\u00BCv\u00D3\u008A{7\x17hhX\u00C9\x002\u00D5\"\x19\u00A3\x10\u009E\u00AF\u00E8!\u00D5\n\x07&\u00B0\u00CF\u0089\u00FD\u0093\u009F\u00FE\u008Bx#\u0086\u00F09{\u00E9\u00A3\x07zG\u00FF\u00B8_\x03\u00EB\u00AE\u00BDUG \t;\u00A5\x7FI\u00D6\u00EE\u00AE\u00A97\u0090aD^@_\u00D7\u008Eix4\u0080\u0097\u00DC\u00C3\u0086\x000\u00AE\x00\u00D8\u00DC#\x12\x11*\u0093\x16\u00F1\u00F9\x13\x1E\u00AED\u00AB\u00D2i\x07\u00E2\u00FA\u0083\u00EBj\u0098\x12\u009Dr[SXJwp\u00A9g\u0089\x16DmGY\x01\u00C2 T\x1B\u00CEV\u0088\u00B3l\x16\u00950\u00C5\u00D2ln9\u00CE\u00B4\u00FEC\u008CA\u0088i,\u008B\x05\u00C9H\x10-\u00E5z\u008C\\\b\x11I\u00AE\u0083D\x07]\x14#\u0088\u00DA.1\u00BF\u008C\x7F\u00D0B\x0F\u00E2G#\u00AC\u00B6\u00AAD\u00C8\x16*A\x1C;?\u00D7\u008E(\u00C4\u00CDJ\u00FDK\u00F5&\u00D5\u0091\x16\u00A4\u00E3\u0086\u00C5\u00D2\u00AE\u00B5\u00D5\u0099\x14\u00DB\u008C\x023rm\u0093\u00D0\u009B\x07\u00A1\x03\u008F\u00EA\x7F\x19\x1Cm1\x1E\nI\u00E8J#\u0081w&\u00D1Q\u0087\u00B5{\u00F5;\u00E9\u009C\u0086j\\;II\u00ED\u00A9\u00B0\x00\u00AD\u0087\u00A5\u008DTi\u00BA\u00D7\u00C2k\u00F8\u00D3\u0082\u00A9|\u00F1\u00C5\u008F\u00F6\u00A1%&\u00FF\u00DA|\u00F5\x1D\u009F\x1B\u009Fz\u00BE\u00FC\u00F8\x7F\u00DC\u00AFB\x07\u00F1\u008E\u00A0\u00A4[*\x01\u00CF\u00AD\u00CFB\x03\u00BD\u00AD\u0080\u008D\x15\x11x~\x05\u00DA\x0EW\u00E4\u00D71\u00F0\u009A\u00EDx\u00E4\u0086G\u0088J\u00CD7\x0E\\(\u00AB.\x16\x01J\x17\u00C6*\x1C\u0088\u00B0\u00E5xo\u00B8Al/\u00DF\u0093\u009D\x0E\"\u0080x\u00EBX1\x11\u00C5\u009A\x1D\u0098\u00BC.v\u00A9\u008E}#\u0090^\x06\u00B93\x0F\u00AF\u00EBj\u00D7\u00A9\u0088-P\u00C5\u00E5x\u00CE\u008Dq\u009A\u0085\u00CD@s\u00AA8\x03#\u00A3\u00D5\u00DF\u0083\u009F\fWVT\u00E4\u00F2V[ryj\u00F1\u00DB\x0E_\u00FC\u00F1#\u00ECzz.C\u00EA\x1F\u0090\u00D9{\u00EA\x1B\x14\u00B6\u00CB6\u00B9`U\u00C9\u00CA\x19Ay\u00FB!\u00B6>\x01\u0090\x01\u00B1b6\x001\u00BA\b1n\u00EB(\u00C3}G;fi|C\u009F;\u00FD\u0086\u0090\u00E8\u00BDL}_g\u00C8$\u00ADF\u00F8\u00F2\u00F2\u00F4k\x14f\u00CC\u00FE'\u009F\u00D5gB|\u00B5\u0081BD4l\u00D6\u00AB\u00D90Z?S\x006&\x14\u00CC 6\u00DBq\u00AAO9\u009E\x17_|\u00DE\u00FF\u00D5\u00AF\u00BFC\u00AD&B\u00F8\u00B8}\u00F6\u00CF\u00FD\u00D6\u00FC\u00B4\u00C1\u00FE\u00A4\x02\u0092\u00A2|I1\x05@\u008B\u00C0\u00F3\u00BB\x1E8\x07\u00DA\u0085N\x0B\u00D81J\u00CB5\x07@\u00EF*\u0098\x1Ar\u00CC\u00F1U\x00\u00F7\u00A6c\x1B\u00B1I\u00EC\u00EE\u00AC\u00A3\u00C0H\u00C1\r!E6T\u00AC\u00C1\u00C0\u00A0\x07b\u00E3.Q(\u0082 \u00E2P\u0090\u0093\x1EK\x14M\u00A9\x07w\u0085\nb\u00BA``\u00E3\x18\u00D4~\u00EE3\t\u00ED\u00E1P5\x15\x00\u0085k)@K#\u00D7Bi\u00D2\u00B2Gmv]\u00D24\u00BB\u009C\u00B7\u00F4U\u0083\u00F7j\u00B3o\r\u00E66\u009F\u00F9j\u008B\u0088\u00A6,\u00A1=c\u00FC\x01\x06,90\u008F`>)\u00C1%\u00C1\x06\u00BB7\u00B9\u00CB\u00DA@l\x0Bg\u00C8\u009D\u009E\u00A8\u00AFgr\u00D4t\x12/J\"\u00C2q\u00CE?\u008D\u00B1\x15a\u00BA\u00EA\u00CA\x11B;\u00A1w\x15ia\u00D7Dd9g\x16v\u0084\x05o\u00A6u\u00E8\u008E\u00F8\x042@?\b\u00ED=\x04\u00D5\u00AD\u00E2\u00AB\u00CD\x0B\u00E1=Q\u008B\u00EA\u00C0\u00ECc\u00D15\u0097\u0094\u00F4\u00B9\u008B8\u0091Dz`\u00BA\u00BB\u00D1\u00DB\u00E3NDh\x18/}\u00C1\x1E\u00FD\u00FC?\u00FAs\x00\u00FE\x1F\u00A01\u0084\x7F\u00FE\u00E8\u009F\u00FC\u00E0\u00D7\u00EF\u00BDae\u00A5?\u00E2\u0097\x16eS\x17\u00806ae\u00F3\u0086o\u0094H\u008Al\u00B3\u00C6\f\u00EA\u00FC7\u00FF\u008E<\u0084/Z\x04)_aFz4{f^E\u00D6v'\x02\u00B0\u0088O\u0088\u00A5\u00E7\u0084\u00FB[\u00EC\u00F0d\u00D1\x03\u00ED\u00F3\u00AB\u00D8\u0082\u00D5\u00D5\x18\u008B\u00EF\u00E0&\u00B4\x07\u00C7\x11*\u00CBF\x15O\u0089Ib\u008A}?\u0083x\u0098!P\x14\x04\u00A3\u0099\u00ECsUR1\u00D5fI\x1E\u00A0\b\u00A9UN.\u0097{ \b\x11t\u00FC|R\x19\u00B4\u00F0\x10\u00C5>XG\x19J\u008ENv\u009E\u00CA0\u0099\u0093\x03k\x1E\u00836\u008E\x19dJ\"\u00AA\r\u0081k\u00AD5#)Z\u00AB<\u00F8X\u0093\u00BC^\u00B3\x10]\u00E0\u008C\u00E8\u0092D\b\u0092\u0096\u00D9H\u00B47\u00EB\u00DC\u0094\u00D4yO\u00F5`\u00B6\u00F6\u0089h\u00D3C\u00D0\u00D5\x1D}\u00F7;l\f\x03\u0085\nd\u00B4\u00CC\x07\u0089\x1E\u00C8\u0094\u00E7&\u0081\u00B7k\u00F5\u00AC;\u00A3\u00F6\u0081,\\\u00DBJ\u00CF\u00F5\u0097\x01\u00B8w\u00B9\u00E0\u00CB\u009F\u00FA\u00E4\x0F\u00E2\x16C\u00B8\u00F9\u009D\x1F\u00C0\u00F5\u009FP \x12\ts%f\u00A0\u00A0n{(\x0B\u00E1\u00F7\u00D78]\x7Fn\u00AB\u00D3\u00C1\u008A6\u00DC\f\u008Fp\x0F/;p\u00C5\u00E8E\u00B3H\u00BE~\u00DC\u0096x\u00B46K\u00EAzd\u00DBE\u00CEC\u00DCJ\u00E8c\u00A0\x1B\tU\u00E19z\u0093\u00DF[.\u0084\u00BA9\u00E0\x11\x19\u009981\u00FAY\u008A\\\u0090\u00DA\u00C6\u00B3{]FS%\u00EA\u00A9\u00FD\rF\x0E\u00DA\u00BC\u00E6Bkd\u00B8\u0095\u00A1\u00AE\u0095G7\u0080\u00BEk\x00C\u0090\x13\u00B0\u00D12\u00FB\u00E0\u00B0a\x19>k\x18\u0098\u00D4\u00E9\x1D\u0091\x04\u00E5\u0083\u00D2\u00CE\u0082\u00C8\u00E7\u009C\x19\u0093\u009F\u0088\u009C\x022\u00E0\u00BD\x10\u00CA\u00A8\u0085\u009FO\u00CE\u00B1\u00DA\x01,\x17\u00BD\u00B9a\u00FAAb\u0092~/\x0E\u00A2ur\u00D2\u00F5s=9\x0B\u00D7\u00D0;C\u00F5!\x18\b\r\u0082\x1A\u0082m\u00E9\u00FAt\u00868\u00CB\u00BA\u00EFS\u00F1\n\u0088\u00FB\x1E\u0081`l\"7\u00EF\x1D\u00B0@\x0B\x1CG\u00DAc'\u00DA\u00EA\u00908\u00C9\u00C5\x1A\u008F\u00E7\u00F0\x005'\x03\u00A2\u00C2\u00AC\u00DDQ\u00FBo\u00A4\u00C1\u00D5\u00D8\x1Fk\u00E7\u0098,\u00DC\tL\u009E\u00F8\u00D7\u009F\u00FD\x01\u00DD.\x19\u00C2W\u00AE_\u00F8>7e7\x16\x11\u00FD\u00D1\u00BE\b\u00A9\u00B0\x01\u00B8\u008FH6:\x13<\u00FF\u00EE\u00BA\u00B1\u008C\u008D~\u009B\u00E8MF\u00B4s\x1B\u00E7\x1C\u0080\u00BC?-\u00B5\x06\u00BC\u0086\r_\u0081\u00E1\u00BEE\u00DD\x04\u00ED\x13\x14F\u00C3\u00C8\u00D6?\u00BCX\u008D\u008C\u0086\u00B1wdH7\x19\x15o\u00C8\u00E4\x14\u0087\u00A0\u00FEt\u00AFB\u00A6\u00E8\u0082Q\u0088\u00A88\u00BDH\u0085\x0E\u00AF\u0084\u00E4pW!\u009C\u008C\u00CC]\u00E5\u00DDc\u009C\\\u00E2\bT\u00A7@\u008A\x04\x00\x00 \x00IDAT\u00C5\u00DF\u00C8\u00BC\u00CAR\x0E\u0098\u0095A-\u00E6\u0087\u0090\\sfB\x04E\u0098\u00AE2iMj\u00E7K\x014\u008E\u008Cp\\\x11E\u0087\u00F4Hi&tcy\u00E1@\u00ED\u00A9\x10\u00CF\u00D8\x16\u00C9[\u00CC\u00DEM\u0086\u00CB\x16U\u0099\u00AE\u00CF2\u00FC%\u0093I\u00DF\u00BD\u00C6eK4\u00A6\u00DD)}i\u00DA\u00F5\u0089\u00AA=\u0080ZK\x1Ak[S\u0096\x15\u0099t\x02\x11\u0080DA\u0081\u009B\u00BA\u00D72\u00CE\u00D6\u00B6\u00B71%\u00D3\f\x06\u009B\u00EB\u00CA\u00DB\u00F8rA\t\u0089\u008Cv\u00BD\x15(\u00CB>O\x1C\u00AF\u00BE\u00FE}\u00D5{\x00\u009F\u00F3\x17\u00DE\u00F5{\u00F3w\u009E\u00FB\u00E3-\u00B5\u00BE\x01\u00FE\x00\u00C3\u009F\u0086\u00F9\u00D3\x00\u00EE\u00C3\u00F1\x00\u00F0\x07\u0080\u00DF\x03\u00FC\n\u00C0\u008E\u009E?\x7F\u00CB\u00AF\x0E\u00E0\u008C\x18j\u00F1\u00B7W\u00B3\u00C4\u00AF\f\u00A4?\u00B4\u00A8B\u00FC\r\x07\u00BE\u00E2\u0086G\u00BE\u00E3\u00B1ox\u00E8\x1B\x1E\u00FB\u008E\u00C7\u00D8\u00F1\bWxl;nl\u00E4\u00FB\u0082\u0081\x1B\x03n\fx\u00CC\u00BF\u00C3\x18H\x15\x02R\x17D\u00C8\x15\u0096\u00AC2\u00ED\x077\u009F\t\u00B5\u0083oh\u00A7i\u00C5\u00B0\u00A9\u00DEc\u00B0\u00A8If\x13F\u00C60\n.IDRXZ\u00A8\u00B5\x18\u0089I\x1D\x11\u00E3L\u00D5\u008CjX\x1A\x0E\x17VKU\u00AD\u00BBV\u00DB|\x12%X\x12Z\x19\u00EEn\u00D9r\u00DA\u00F4\u00C7\u00B3Q\u0082\u0094-\u00A7\x14hQ\x1F\u00D9\u008Fdt]\u00A0\u0088)\u00CE$\x00\u00CD\u00F7*\x10\x1A\u00D1\u00E7\u00F76\x07\u00D2\u00C7\u00BB\r&\tJ\u00EB\u0085B\u00C99\x1F\u00DEB\u00E0\f\u00D5\u00EE\u00C2\u00A6\x151hK$\u00A2\x1C\u00CF+\u0083U\u00BF\u00C44\u00E2\u009Fr\u0082\u00AA\u00D5Q\u00FD\u00F0& [\u009F\u00A5\":\u0099\u0081/\u00F7\u0089\u0095\u00B9\x7F\u00E1\u00F3\u00CF\u00F9\u00EF\u00FC\u00E6\u00BB\x00\"\u0084\u0087\u00B0\u00EF\u00FD\u00ED\u00F1/\u00D1\u00CE\u00FC#zQ\"c\x0B\u00E2\u00B7k\u00A8(H\u00EE\u00E3\u0097\u00BB2\r.\u00E2^$\u00A5G\x11\x02\u0099}\u00D6\u008F\u00A1\u00AD\u009D;_Z\x18*\u00CB\u00D5$\x0E\u00C2{\u00F0\u00B2\x03O\x00\u00D8|`\u00B3\u0089G\u0092\u00B2\by\u00D1\x1F\u00B4\x02\u009D6\u008FH\u00D6\x1B(\u00847\u00D0x\u009C!5\"\u00DE\u008A?\u0088\u00AC\u00CAZ\x10[\u00BB\u008F\u00BC\x0B\x002\x19*\u00AA@\u00D7\u00EB\u00E0\x1C\x1D}n=T\x07\x10\u00F5\u00C0\u009C\u00D2b\u00A3\u00E6\u00D5\x12\u00AE\\\u00BBJ\u0099\u00A2}\u00A1-\u00E7\u00AA\u0090\u0091\u00E5\u00BC\u00C6\u009C\u008F\u0092\u00AAF\u00FD\u009B\u00D5\u0099cj\u0084H8\u00B7Q\u00C6y\u00F1\u00AFG T\u00E8\t\x11\u008E;\u0097\u00A5\u00E7Z\u00C8w2\x7FO\x02\u009Es\u00B6\u00E71\x1A\x11\x11s\u00B9\u00B2\x1CWC]Iw\u00AD)\u0086P\u00BB\u00A3\u00D4S\"\u00A4\u00CC\x00=\u00EA\u00BAY\u00D1\u0096\u00B5U\u00DE\u0089v\u00C8@\u00B4\u00A5\x1A\x1C-\u00E6\u00A3\u00ADC\u0097*@&1i\u00B8\u0094\u00BDb\u00DA\x1Dm7u@1\u00F1\u009Da-\u00A7\x13\u00E5P\u00BD\u00F0\u00D9\u00F7y\u0088\u00F3\u00B7\u0097^\u00C2+?\u00FF\x0B\u00DF\x0B\u00E0\x0B;\x00\u00FC\u00C2k\u00BF\u00F9g^\u00BB\u00FAFM\u00F8\x1F\u00EAK\u00D0kC\u0096Q\u00C7\x15\f\x0F\u00E0\u00B8\u00E2X\u00E3\u00D8`\x1A\u00EE\\\u00D4\u0081\u00BD]_AG\u00EE\u0092b\u00FD\u00DD\f\u0092}\u00E2\u00AD,\x00+B\u00E8RC\u00B6\u008A\u0081G\x06|\x15\x07\u00AE1\u00B01\x1FrO\u00B7\u00DFl[\u00C7\x07A\x1D\u00EE\u00B8 \x16\u00C9D\u00B8\b\x07\u0099\u008B\u0081y\x10$p[\\z\u00C0\x15\u009Ca\u00CBA\x02e#\x0E\u0089\u00A2\u00FA\u008AR)\x0E\u0084\u00F4\u009D)\u00917\x14\x18\u008Ex\u00C6\u0090\u00D6X$_n\x06K\u00A3\u009DBr\u00E5\u00E2\u00CB\u00B8\x00o\u00D3\u00E3[-\u0089\u00E4\b\u00FA\u0083\u00C4\u00BE$\u00FE\x14Z\u00A86\u009B\x1D#\u00F5x\x05\u00F6\u00B4\u0086]\u00D9\u008AvZ\u00D4\u00DD\x1F_\u00CC<\bL\x12\u00D1C\u00A0\u00F8\rR\u00AC\u008A\x01e\x1B\u0093:\u00B4\x18\x07\u008D\u00A0KVb{;Pp\u00BB\u008D9a\u00BD<\x1E\u0082\u00EA\rI\u00E8\u00EC;\u00D0M \u00A2 h\u00CF\u00FC\b19\u00E54\u00A8\x1B1\u00DE<\x078uSk\u00DE\u00D7{w\u008FI\u00F7\u00AE\u00A8O\x1A\u009F\x0F`\x02W\x07\u00F0\u00F0\u00E3\u00BF\u00F2g\x00\u00FC\u00A3\x1D\x00>5~\u00FD{\x06.\u0098\u00EE\u00DFB\u00BA\u00FEA_\u00E4N\u00D8`\u00B8_\u00D2\u00DE\u00AF\u00E1\x16;8'\u00B13\u00AB1\u00BD\fK\u00C9,\x11\u00AC~\u00EB\u0088Ae\u00BCF\u00BB^\x13\u00C2\u00AA:X\u00890^\u00CA\u00A3\u00EF\u00A8\u0083\x10\u00D3\u0081\u0097\u00CD\u00B1Q\u00F2\u00EDn\u00B8\u00C2\u0086*\u008C\u00A6jM\u00D1\u00CEN\u00C6\u00A0`\u00A4\u00D8N>\u00DA\u00DB\u0081T\x19\u00CA\u008E#\u00DB\u00C1m;B &1\x1B\u00C1W\x16\x7Fu\x05>\x11q\u00E88\u00F5\u00DCn\u00AF\ba\u00DD\x18\x1D\u00CAh\u00B6\x14%\x05\u00FD\x01\x14\u00DA\x19\u00C8\x04TT!\u0098\u00D3\u0091\u00AA\u00D8\u00D0\u00CA\u00AA\u009C\u0085|\u00E4\u00AA\u009B03h\u00C7\u00A4#s\u0091\x062St!8\u00FA\u00C1\u00C9\t\u00A3[FD\u0082\u00AAJcM{Q&\u00E3t\u00F5R\u00B0\\h\u00AA\u00A4vx\x19K\x1B\u00F5d\u009A\x0E\u008C\x16\u00E6Jf\x01x\u00C6\x00,`\x00\u0092\u0080\u00CDXg\n\u00B7\x15w\u00D1\u0089d \u00B9\u0093\u00B2\u00AEQk\u00A6\u0089\u008Fs'PQ\u0083\u008E\x15%\u009C\u008F\u00E9\u00A5\u00E8E\x1A6\u00C9\b|\n\x05\u00A0\u00FA\u00C9\u00A1\u0099\u00DCz\u0082\u00E5\u00A9\u00877\x15&\u00F7\u0087\u00B0UJ\u00AB\u00DF\x1A\u00EFb\u00DD?\u008D\u00EB\u0096T\x17\u00DAh\b\u0087\u00E7\u00D6\u009E\u009E\u009Dq\u00A0\u0098L\u00A2'\u00DE\u00A3\u00AB\fh\u00E7\u00F4\bI\u00AA\x16b\x06\x19\u00E3\x00\u00CF8\u008C\u00F9\u00CA7>\x04\u0090!\u00BC\u008C\u00AF<\u00EF\u00D6&\u00EB\u00DF\u00FA\x15\x04\x19j\u00C1u,:\x17s\u00D8`\u00B8\u0086\u00F2\u00FC\u00CB^\u00D0\u00A5\u00FE\u009A?Pp\u00BF3\x04\x19\u0092J\u0095X\u00CA\u00AC-\x05>\u00CF\u00AFv\u00DE\u009D}\u008FE\u00F7\b\u0086/9\x03\u008F-\u00AE\u0089\u00AB&\u0086E]\u00C6\x0B<\u00F7\u0082\x149\x1B\x03i\x06\u00A2&\u00C2`\x1E\u0086B\u009F\x0F[\u00FB\u00A2\u00B1.\u00EEI\u00E2;\u0095\u0089\u00A9\u00A8\u0086b'\x15\x1E\u00CD\x14%sd\u00BC\x03U\u008A\x10\u00FEc\x11&\x159X\u008C\x06\u00D2\u009F\u00D1\u00C8\u00D4\u00FB\n,\u00DB\x03l6\u00B4P\u00BE\u00EE\u00CC\u00C30Gn\u00C0\"\u00D6(co\u00BA\x16\u00CFs?0\u00CD\u00D3`Y\u0084?\x1A!PZ\u00BA\x18\u00C2\u00FA\u00DC*\u00F6b\r\u00F4)\u0082U\u009B\t# F\u00AC\x04\u00A2\u00BAg\u00F5\u00BD\u00A4m\u00BB\u00DD\"\u0081\u00C5\u00FA\u00F5\u00F4\u00CE\f(\u00DA\x121.F\u00CB\u00F4+\u0089\u00C1\u0096\u00A8)\x06\u00D2\u00EF\u00D9\u00A6\u00D5\u0085\u008386\u00A7\u00AD\x06\u008D\u00A9\t\x1D\u00F8\u00CA\x104<\u00B3\u00E0\u00A1W\u00AF\u00BC\u00F6<\x00\u00EC\u0097\u00E3\u00F1\u0093\x7F\u00FE\u00F2\u00A3\u00CF\u00E1\u00DF\u00FA%\"e\u00E9\u00F4D\x05\u00C1\x04`\x1B\u00DC\u00AFQq\u00FD\x0600\u00C7\u0093\t\u0088\u00E8\u008BQ\u00DC\u0096\u00FA!\u00A5\u00B5o\u00E2\\\u00EE]\b#c\u00DEq\u00F60lm\u0092\u00AD\u00DE\u00A7\u00C2*bB\u00AF\u00C2\u00F1\x15l\u00DC@\u00D6\u00B2^\u00C2\x15\f\x17\x1F\x186pL\u0095/\u0093V\u00CF\u00BD\x1C`\u00B8\u00B4 \u00AA\u00D1\u00A4\u00FAX\u00D4\u0085JZR\u00C4\u00E3A\u00DB\u0083\u009B\u00EA5\u00D6\u00F9\u00CA\u00A84DN\u00C5A\x06\u00A0\u00EF\u009B\u00957!^#-\u00E1\u00AB\u00FB5\x16\u00C6\u0098\u0083,%\u00DC\u00B9\u0086Iz\u0093\u00B4s\u00C0\u009Ar\u00E3\x05}'\u00801\x1C8\x18\u00DB\u00D8k d\u00CC\u00FF\u0084\u00CD\x19\u00CAB/\u00BCB\u00C9\u00EDd2c\u00C6\u00B9KYu\u00DB\u00A1\u00A8<\u00CB\b\u00BF#\bx\x0E\x1A\u00C9\u00C8 &\u00EF)~\u00C1\u00C8\u00C0,\u00B2\u00EA\u00CC\x15q\u0083Mn\u00E1\x0Ea6\u008B\u00F32\u00D0\u00D0\u009A\u00DF\x7F\u00D6\u00D85\u00A7\u008B\x04\x17\u0083\u00E3\u00BD\u00D2\u0088\u0089\u00AC\x1F\u00A1 #\u00D5V\u0080\u00EA\x19\u00F0o;\u00C8\\foS\u00E8,\u00C6#\u00E3\u00A4\"+\u00E5\u00EAM\x16\u0097\u00A8Gv\x1B\u00CF6\u00CD\u00A5\u0092]\u008Aq\u00CC\u0098{\x1B\u008E\u00F1\u00F5\u00AF>\u00E7_\u00FC\u00EC\u0093\u00FB\u00A7\u00C7\u00A3\u00EF\u00F8\u00A2\x7F\u00FE\x0F\x01\x1A\u0088\u00F8w \u008A\u0094\u00C1\u00A9&\u00C8m\u00A8\u00B0\u00DEr\x05m(/B#j\x18b\u00CB\u00F7b\x06Ys\x00\u00C5@\u00EA:\x1A\u00A3\u00D2\u00EE\u0080\u00DB\u00BF/oq`\u00E9\u00D7\u00FD\u00BC\u00D5\x009\u00CD\u00F05\x18\x1E\u00D0\u008E\u00B0\u00DBZ\u00A9\u00C1a\u00F4&\u00C4\u00FB\u00B2\u00DCE\u009E\u0085 \u00F2KJ!\u00D9\x1F\u00C4\u0088\u008AY\x053(r\u0096\x17#\u00A2t\x15\u00B6\x1Cm\u008B\x11\u0084\u00CD!\u00C6=\u00DB}\x13\x05\u0084\u00D9\u00BEIP=\u00EE8\u00ABB\u00AE:\u00FE\x00\u00C4\bJ\u00B4\u0080\x0B^\u0092-\u00B6\u009F)\u0089\u00DD\u00C5\u0097\u00B5\b\u00C2\u00F0\u00B4D\u00A0\u00A2\x16\u00BB\u00AE\u00EBbW\u008B\u00BC!\u0080\u00F4\u00B1c\u00E9w1\x1E\u009D\u00DFavk/\tx\"\u00ED\x05]2w\u00C2\u00D6Ks\u0096(b\u00A0vE\u00EA\u00C7\x1A\u008A\u00C8\u00FEKZ{^n\u00D9\u00DE\x1D\u00AF\u00C5`\u00D8\u00D1\u0088\u00A4|\u00FD\u00AD\u00FD\u00BA\r\u00ED\x19L\u00F6M]!#\x17\u00D3H\u008FMGG\u0099\u00F8D\x0F\u00C8\x04n\u00BE\u00F0\u0092\u00DD\u00FF\u00C4\u00A7\u00BFc\u00FF<>\u00FB\u00FE/\u00F9\x17\u00EF\u00EE\u00EC\u00B7|IrQ\x1D\u00F0\x07\u008D\u00C8O6\x02/\u0089\x1F:q7\b6\u00EF\u0081\b$\u0089[\u0099\u0081\"\u00D6\x1E\u00DELF\u0090\x0F\u00BE\x18B\u00A1\u0082~\u00AEBxuNg\x06\u009C\u00F8\u008C\x1D\u00AD\u00C5t\u00C0\u00F1\x12.\u0098\u0088\u008A\u00CCW\x1E[\u00C2)\x1D9\u008Dv\u0090\u00F6^\u00FDm\u00A4\u0085^\x19\u00C9@wb\x12\u00A1X\u0091\u00DA\x03\u00C3\u00A6\u0091\u00C7\f(\u0086\u00E0#\u00C3\u009E\x15\u00E2\u00EC(\u0086\x03\x18v\u00EF\x006\u0098\u008Fc\u00CBEb\u00CAl\u00D4\u00FAu\u00D4\x02\x1A\u0088]\u0093\u0086\u0091/H\u00E4\u00B5\u00CAG1\u008A6\x7F\u00BC\x0F\u00A5tm\u00D3.\x04\"f\u00AF2\u00B6@\x11~\u00BF^\u00F3\x0F\u00DA\x00R\x06V\u00FB\u00BA\u00D6\x00WPOJ\u00EC\u00B6D\r\u00D0\u00EEN\u00B9;\u00B6\u00B7D\u00A6\u0084\u00DE\u00ED>\u00CD\x1EP\x04\u00AD\u00A0\x1E\x06f\u00BB\u0096JS\u008D\x1C\u00C9^\x01@\tDRE\\\x1E\u0086[/^\u0091\u00FDg\x1Fd\u00D4\u00F4B\u00BC\u00F5;r\f\u00C6s+\u00C7\x03\u00AB\u0087#\x19R\u00C4\u00B1\x18Z\u00B1\x19\u00A2\u008E\u00ABG7x\u00F5W\x7F\u00ED\u00FD\u00FBg/\u00BF\u00FD\u00BE\u0087\u00FBk\u00B9\b\u00DF\u00D4\u00CB\u00B50\u00AE\x11U\u00826D \u00D1\x15\u00E0\u00D7X\u00F5w\x12~\x0B\"\u00A9\u00C1\u00B5\x1D\u009C\u0093\x19\u00A8\\Z@\u00ED\u00DA\x01I\u0093/\u00D5\"\u00CE\u00ED{2\u0096\u0085\u00BDK\u00DD\u00CEpl\u00F1,\u00B8\x01*d\u00EAP\u00AAu\u009A\u00F5\u00EAA!\n\u00A7|\u00CD\x1DO\u00C0\u00B1g\u0089\u00B6\u00E8\u00C5\u00EE\x11\u00BA\u00AC\u00F4\u00E9\b\x16r\x1C\u00A0\u00C7\u00C0T\u00CE\u00BDBe&\u00FFR:u\u0094/pL\u00D7\u00B6\u00B1u\u00B6\u00DESnH\x10\t\u00CC\u00B0mD\u00FE\x04\u00F3\b,\u0097'\u00F9\u009B!\u00C2\u008Fe)7\u00AA7q\u0082\x10\u00861\u00F0 G\u00ED@n7\u009F-\u00D2\u00C2\u00DD\u00D2\u00A9\u00C52k\u00FD\u0094\u00F45\u00B7Zx\u0090\x7F}\u00A2j\":\r\u00E8R#\u0088\u00D1\x13:\u00D3\u00BB`\x07b\u00EF\b\x0F\u0089\u0096(\u00B0\u00A0yA\u00E4r\u00DB%\u00E9Ir6\u00D8\x1D\u00C7\u00E2|m\u00C9\u00EE\u00C3aG\u00EB\x03\u00DD\u008AF\u0088mB\nn\x11\u00ADi\u00CE*\u00F1TA&\u00A0\x023\u00C6\u00EF\u0091\u00BB0\u00819\u00A9Ry\u00FE\x1DoKFU\u00B1\x131\u00E42$\u00F2\u00F9%\u00C3\u0098\u00A7\u00B1\u00AB_\u0089;\u00D7E\u00C0\u0083>g\u00C4\u00C8\u00A4Z\u00E59?\u00F7\u00E6\r^\u00FE\u00FC\u00E7\u00DE\u00B7?|\u00FC\u00D2{\u00E6\u00BD?\u00C8V\u00EF\u0082\u00D9\u00D7\x00\x1E Kx\u00F3m\u00A6\u009D\u009Ae\u00DD\u00BE\x02\x16\u0098\u00DF\u00DC\u00840\u0094j\u00D0Q\x03\u00DA\u00B9=B\u00B1\u009F\u00D7\u00A2\u00D0\u00F2S\u008B\u00E5\u00BC\u00CB\u0093\u00D4\rk\u00F7\u00B76\u0096\u00DEn\x1B\u00A7\x10\u008AK\u00C2\u0084A\u00F0u\u00D3]Fco\u00AB\u0084\x16\u0083\x1A\u0088b\u00AE\x0E\u00A4\u00FD\u00E1b%\u00F5uMh\u0083\x03\u00C3\x02\x11\u00A9\u00A2s~w\u00E6G4\u00B5\u00C3\u00C8\f\u00A2\u00D2\x12U2\u00DA\x1D\u00E4\u00BA4\u009B\u0090)tAD\t\u009D\u00C1\u00C5\x16+\u00A8\u008B\u0085UD4h\u00DC\u0092\u00A9j\u00DEY\x7F0\x11B${\u00AF\u00D7\u0091\u009F\u00F4\\\u0085^\fU\x0B\u00B5\u00FB\u00FE;\u00B17Cb\u00EA\u00D0\u00DD\u00AA/i\u0098]n\\!\u00F5\u00F8Q\u00B6\x05\u009F\u00CD\u00D0\u00D7\u00AF\u00EF#W\u00FF\x1B\u008CR{b~D\n\u00A6\u00A4\"U\u008D\u00EE\x1E\u0083\u00DE\u00C6R#\u00A1\u00882\u00E7\u00B3\u00CF\x031G\u00CD\u0099~\x17s\u00E1\u00FD\u00D2\u00D5\u00D8\u00E6LjKc\u0088\u0098-Xj2/\u0085v\u008EG/\u00FD\u00FE{\u00F6O\u00F9+\u00EF\u009Eo:\u00E5yC0\x01\x1A\rMq\x04\n8\"3p\u00C1\u00FA\r\u00A6\u0092h9!\u00A3P\u00C1\u00ADHD\u009D\x13\u00F0vv\u0086\u0090\u008Bp\u00AC\u00ED5\u0082\u00B7\u00EC\u00E3\u008E\u0082\u009D\u00B4\x00\u00F7\u00FC\u0086\u0096\x058\u009B11\u00F5{\u0097\u00F7b\u00B57h\u0087\u0081\u00CD\u0081a\u00DCW\u0081B\u00E2\u0086\u0090~\u00A3WasK\u009D\u00D9\x11\u00A6\u00D6\r\u00ABGA\u00F7\x1CP\r\u0082\x0E\u00FD\u00F5\u00AB\u00E5\\\u00E9\u00E5\u00CE]\u00A2\u00BA\u00BB\n\u008EK\u009Eb\u0080\u0089\u00DCc\x1E\x07\u008C\x05\u0089\u009A\u009D\u00C5-\u0093\x1D\u00E5%Lz\u0092\u0094\x06\x00G\u00ED\u00C6\u00C4\x13K75\x04\x02\u00EBk\u00C8\u00D9\x16\u008D\u0096\u00EAS\u00E1\u008F|\u0096f\x1B\u00A15Z\u009C\u00FE\u0089\x19d\u0092\x16W6\u00F5\u00DE\u00E9\u009EO\u00BD\u0090\t\u00E1\u00F4\u00D4\u00B3t:Q\x18\u00B5\bo\u00FD\x11CQ\f\u0081%a)y)\u00F7A\u00D05\u00D4\u00C5}\u0081\u00E9\u00BC\u00F5\x1C\u00C0lR\u00DE\x03\x04X\u00CF\u009E\u00F4>\x0FA\u00C0\x15\u00F5\u00D8\u00C7_\u00F7*\u00E2/\u00F5\x05\u00ED\x1E]\u00B5(\u00A60\u00D9?2\u00C1\u00F4\u00864\u00A6\u00A6\u00A7\u00C1\u00B6\u009E\u00FA\u00CA\u00D7\u00DE\u00BD;^~\u008E\u00A7}\u008B\u00D7\x15\x02\x15\u0084\u00C10\u0088\u00EE\x1A\u00A5\u00E7Sjg\u00ECz\x10\u00A6\u00DBJ\u00EC\u00B5\u00AF_?n\u00AD\u009DA\u00C9\u00B9\u00EA\u00FEk\u00C2R\x19\x19\u00E3\u00D5\u0099\x06\u00D3\u00A3\u00CD\u00DA\x02\x13Zimb\u0090n\u00D4\u00AE\x16\u009C\u0098A\u008D)\u00C8\r,\u00DE\u00EE\u00DCR\u00BET\u0097\u0091\x12W\x11\u0086b\u00C6m\u009Bx\u00D3Vp\u00C6\rdK\u00BD\u00E831\x01\x19\u00B811\u00D3\u00AD(\u00CF\u00CC$\u00F3\u00C8\u00E4\u00A6T-\u00E2)N\u008F\u0080\u009F0:V\u0095\u00E7$\u0083\u00AC\u00D8\u00CC\x05\u00A1\x07o\r\u0096\u0082\u00D9\u0092,\u00A2*\x0B{2\x01\u0084z\u00E4\u00A6\x055P\x16q\x11P,J-8x\u0099I]\u0090\x17\bk\u00BB\x18\u00CA\u00C9\u00D3#\u00E5K\u00CC\u00A1\u00EA\x19\x02n\n\u00C1\u00F5bJ\u009D\u0099\u00F9d\u00DB^\u00DE\u0089\u00DE\u0097DH\"\u00E8\u00D9$7\u00C8\x14\x1A\u0081\nb\u0093I\u0098\u0098\u008ES\u0086\u00BB\u00E7\u00DC\x01\u00C5X\u00D2\u008A\u00D4\x19\x0F\u00E7\u00ABl\x00\u00EDY8\u00D0\x0B\u00A1\u0094\x04G1\x13\u00CECg$\x19T\x06+F!f\u00E1\u00F5N\x03\u00E7\u00D43\x15rr\u00EC\u00AF\u00FBs\u00FB\u00EF]\u00BF\u00FC\u00CE76\x1F\x18$\u00DB\"\u00A6`Gls\u00B2\u00C2\u00FF5\x16\u00A0\u00DB\x0B\u00E8BL\u00CB\u00B6\u00AE\x0BY\u00EB\u009D\u00A0}\u00A06\x10\u00ED\u0092\\\u00FC\u00BC\x1B\x13\x0B\x15tDQjDW\x11\u00C4\u0088\u00F4\u0080\u00E3>\u00B5z\u00D4\u00AF\"\u00FE\u0090\\T=\x04\x07\u00CD\u00B1\u00DB\u0086\u00E1\u008E\u00E1{\u00C9x\x0B\u00F7\u00E0P\u00A6\x1E\u00F6\b-\u0086\x12\u009AT;1<\x10]!\u009A\u00C6\u008D^|\u00D0Uit\x0F\x1A.\u00AD?\x1A\u0091\u0092\u00A2\u00B8\u0099z\u00FC\u00E2\u00D1\x7F7\u009A_\u008D\u00BA;\u00E3<\u00CC\u0094!IF\u00BA\x18\x05{\u00F0\u0090\u00DA\u0094e\x1A\u00F0\u00BE\u00A2\u00F2\u00FC&\u00C1\r%m\u00D2(\u0088|\u00E6\u00B1(e\x11\x07R\u00DA\u0081\x16\x7F\u00BD8\u0086\u00D2\u00DD5C\u0088s\x17c\u009F\u00EENt\u00E0\u00FDw\x11\x1A\u00AF\u00EF}\u00C3\u00865kR\u00C7G\x0EG\x03H\u00EF~\x0F\x06\"\u0083\u00ABk\u00D5w\u0096L\u00A3\u00A1T\u00C6<'s,5\r\u00C8\x1C\u0085\u008Cv\x14\u0083\u00CB\u00C6\u009AAP\x03\u00ED\u008CVcT\x07t\f\u00E8\u008CF\u00CC\u00CCN}-F\x11c\u00A9jN\u00C1\\\u00E6\u00CD\u00F1\u00CE}\u00C7\u00E5\u00ED\u00B1L/X_\u0086@\x03\x0F\u0090\u009B\u00A4`\x07p\x1F]\u00E7\u00D6\u00C6\u00ABE\u00C8*E.c\u00A3\x16,?\u00DB\u00E2\f\u00E9ZFG\u00B9\u00CE\u00C2\u00D8\u00D8\u0089\u00FCl/\u00E8de\u00E8\u00E1\u00C7J\x7F.\u00EB\u00FF\u00DE\u00AE\x03\u00D6\u008AI\rnz\u00DB\u00AD\u00B8\u00E5>8\t\u00E5\n\x03W\u00D8\u00B1\u00D9\u00C4\u00E6;v\u00CC\u0088K\x00\u00F7uH\u0099OF\u0097\x1E\x05\u008DA\u00C9O\u00F1\u00BA\u00A9\x1E\u0087\u00E1\f\u0091\u00FC\u00DD\u0093\u0087\u00D6 \x1D=\u00D7b\u0086\u0096\u00AADy+\u00C2\u00EB \u00B7c\u0095Z\u0093d\u009F\u00EE\x18C\u00F3\u00D7\u0088\u00D85_\u00B1\u00D0Ls\t@\u00F5\x12\u00D9@#\u00D87R5\u009B$C\u00A4\u00FDj\u00E1f\u00FD\u00C2)\u00E2'#\u00CD\u00E2\u00A7lw!\u008AQ\u00DF\u00F5\u00C4\u00D2-W\u00AB]\u00F6\u0080,4\u0092HH\u00E3\u0092pJ\b\u00B7H_\u00C5(\u00C0Uu\u00BA\u00F5\u00A7\u00EE\u009CR5U\u00A6\u00C9\x1D\u00AB\u00E4\nmFI\u00F5\u00AD\f\u00A5\u00D5W\u0099I\u00CC{_\u00BC\u008D\u00B53\x13\u00CEIG\x0BT\u009D\u0084\x0E\u00DC\u00F5]H\u00AE1\x1C?\u00BD\u00F9|=\u00D5$\u00C7\u00E5\u00F1\u00ABo\u00DF\u00E1\u008F\u00DE6M\u00C0\u00D4['\u00AE\x11\u00F9\x07\x11[\x10\u008B\u00BC\u00D2k\u009Dh`\u00A2\x16h7\u00C4I\u00C2gFb\u00CBE(\u008F\u00C0\u00EA\u0092\u00AC\x1A\x07\u00E5\u00BE\u00F3\u00A5\u00FD\u0093n/\x0EkM\u00A5\u00B0\u0086,Nj\u00C6\u00AAj\b\u0095\u00F4\u0089\u00D7\u00BD\u00E3X!\u008C\u008Dx'R\u009D\u00E2\u0092\u00D8E\u00CAhK\u0080\u00CB\u00FDW)\u00C0\u00D0o\u00F9x\u009AM\x00\u00E1a\u00F0\f(*5\u00E2B\x06(\u0095\u00C5x.,f\u00EF@\u00CDc\n\u00EAT\x1F\u00E45Q\u00B95@EZ\u00D4\u00BB\"\u0094Q\u0084\u0092\u0084\x03\u0094\x18N\u00F1X\u0084)I\u00B9\\\u00D7(5\u00D1\x03\x19\u008C\u00AF\u0086\u00CA\u0080\u00D3\u0092\u00CA\u008A\u0082hm5x[\x018\u008D\u00B8\u00FA\u00EBdsX\n:'\x1C\u00A7\u00D1o\u00F6q7\u00A9\u009C\x12\u00D6\x01g0X7\u00DA-p\x1Dd\x06\u00EC-\u00DB\x15sr\x12\u00ECZ7\x01\u0089\br]pU\u00F4\u00B1v\u00E9\u00DE\u00D1A\u00ADs!\x1EM\u00CE<\u009DKD\u00A09\u009B\u00A76\u00DB\u009E\u0090i\x7F\u0098\u0086\u00AE\u00E6\u0099\u00FB\u00DB\u00F6/\u00CEG\u00CF\u0098S2I\u00BF\u00C7= \u0093\u009168\x17\u00FF\u00C0\u0086HS\u00EE.\u00C2\"P[\u00D4\x04\u00C2\u00C0\u0085\u00D8*\"\u00D1\u0093\u00F8\u00B6\u00F5\u00BC\u00D4\u00F3\u00B1\u00A0\u0082$d/\u00E2N\u00A2\u00F5-\u00D5\u0080\u0094\u00A2\u00D9\u00BF\u00CE\b\u0080\u0085\x19\u00F4\u00E3V\u008C\u00C8\u00FBy\x00\u0080-\x1D\u008D\u00AB_\u00A0\u00F7GD\x1A\u00D7f\u00FEA{\u00F70%\u00CD\u0091\u0082\u0081\u00B6\u00A6\u00E6D\u0095e@E\u00C9\u00E2X\\3\u00C1 %\u00AE3c\u00D8\u00F4\u00C4\u00A0\u00AA2pX\u00CD\u00CD\u0086\u00B2Y$\u00EAZ\f[T\x03d\u00B8\u00E0K\u00E5\u00D0\u0082\u00A8\u009C\x0BZ\u00BA>o\u009E\u00B0\\\u0084v\u00BB\u00D2OJ+;/p\u00A1\u0093\ri\x02o\u0084\u0094a\u00D2\u00A9\x1B\u00FBz\u00DDd\u00F8\u00B4\\\u0098$ \u00DDf)E\u0096\u00D1\x7FXxWyV\u00E4\u00C6\x0B\u00C2\u00B3D\x19\u009Di\x18\x19\u00C5\u0091\u008Cx\u0089*\u00840\u0098l-\r\u00D1\u00A4\u00CE\u00DE\x11C!D\u009F#*\"\u009D\u008C\u0082\u00B59-n3F\x11\u00BDxs3\u00B6\u00BE\u0091\u00B7!\x19JC\x12u=\u00B0=\u00BCyf\x7F\x1D\u00AFmS\u00FA2\u00EEC\tIB\x06)\u00BDIx\u008EkT\u00F8k\u00CFV\u0094\u00B4\x152\u00E8\x04\u00D9\t]a\u00C7\u00ED\u00BA\u0085iti~\x1B}\u0094zPRX\u00DF\u00CDV\u00BB\u00C1\u00DA\u0086\x18\x14\u00892\u0083\u00A3\u0092_\u00C7\u00C3\u00B9C51\f\u00EC\x0En\u00CDN7$\u0089+\u00D2\u009B\u00AB\u00ACz\u00B4\u00AAH\u0082\u00DA\u00C2E\x7F[~G\u00A8\x04&\u00B5\u00A9\u0098h\u00852\u008B\u00D8\x01\x05\u00CF\u00EA\u00BAD\bdB\"\u00BA\u00B346p\u00E3\u0098&ae\x14\u008DS\u00A4\u00D6y<&\u00D7\u0095y6\u009F\u009F\bVL`\u00A2\x16<\u009F{\u00A78Z\u00F4\u00D3\n>u\u008E\u00EC\x10\u0094\u0094\\\u00A8\u00DE$kAi=\u00E7\u00F5xy\x02f\u009E\u00A7\u0082\u00A8\u00F2(\u00A8\u00ED@\x19\u00B3]\x1F\fN<$\u00CF\u00F7\u00D6\x17Il\x00\u00C9\u00A8\x14c\u0080fsX\u00D4\u008D\u00D6_(\x00\u00C8\u008B\u00B1\b\u00BDt\x067\u00AB?\u0080\u00FA\u00AA9\u00AD\u00FE\x04\u00A1\u00CF\u00AAe\u00C0P\u0089\u00B2\x07\u00F8\x12\u00B3\u00B00\x1E\x04\u0093\u00AB@\u00ACv^\u00DA\x10\u00E25^\x7Fe\u00DB_\u00B5\u0087\x18\u00B8\u008F\u00E9\x0F`\u00B8\n\u0088\u00EF*\u0081\u00BE\"\u0080i\"\u00E0\u0093\u00E4\u00F7\u00FA\u00F4,(q:\u00AF\x1B\x16\u0097\u00CDTn\x13lq\u00DB\u00C6\f\u00BC3\x17\x0END\u00DDR|;C\u00A9\u00EF\u00DD\u009Eayn\u00FAw\r\u00B8\x1D\u00D3\u00B0\"\f\u00E5\x11\x02\u0083EXO\u009E\x0E\x03\u008A\x01\u009D\u00D1\u00C0\u00E0}*\u00EAR5\x04\x07\u0090\u00C7\u00F5\u00F0:Z\u0091\n\u0093\u00FB4x\u0086\u00D10OB\u0085\u00B9\u00E8\u0089p\u0087<\x06\u008CIc\u00EC\u0082\x18\x07\u0099\u0092\u00F5\x05\u00AC\u0085\u00C4\u00A1\u00A8\u0084Y\x1E\u00D2\"\x12%\u0088X\n\u00C2\x06AtH+\u00F8Z\u00A5W\u00EB\u0092\u00C6\u00B6|\x04\u00CCNHOi\u009B\x0B\u0096Ld1\u0080\x19\x1Cs%\bJ\u00CC4\u0094y\u00BF\u00D7@\u00A6'/\u00F7\u00D6\u0083\x0BE\u00AC\u00FA.b\u00B3\u00A6\u00DE\x00\u00DAt%!7\f\u00C9YZ\u00CA\u00B2\u00A1\u00D56\u00E2\u009Cx\x1F\u00BB\x1B\u00B2^C\u00AB\u0095X.E1N_\u00AE1\x18\u0094\u009D)\u00E6$1\x11\u00ED\x0B\u00BDx\u00A9\x06sf\u00FE\u0084\u00EB\u00BE\u009C\u00A7\u00F0\u00C0\x14\u00F3\u00D8_\x7F\u008C\u00FDw\u00AF^\u0081\u00F9\x13\u0088\u00A8C\x11\u00FC\u0080T\u0083a\u00FBj'\u00B0\u00C6$(\u0095a\u00BDv`\u00A0\r\u00E5.\u0088\u00F0|\u00D1\u00E7\x1B\u0083H\u00BBBG\x07\u00FA\x04\x16\u0084\u00A2\u00C5`\u00E5\u00BD0\u0093\u00C1\x12\u0089\x0En\u0087-\u00F3X\x0BB\u00EA\u00F9\n\u00C5Pz`T\u00FF\u00BD\b\u00BC\b^\u00E3\u00E3\u00B9\x0E\u0084aT\u00FD\u00DC2\u00A48\u00E2\u00F8k>\u00AC1\u00A5\u00F5\x1C}\u00E3\u00BD|5\x1A\x02\u008A\u00F2'Q\u00FB\u00A4\u00ED \u0096\\\u00C4\u00DC\x05\u00E3\u00AB:\t@\u00B7'\fhWjFCz\u00A9\x06\u008B\u00C4`\u0084`\u00FD\u008Ez^\u008Cjt\u009F\u00CDY \u00C2\u00D4\u009F\u00C6\"\u00AE[$\u00F1\u00A4\u00D8g\u00DB<\u00A4'w\u00FB\u009B\b\u00A3\u00FAd4\u00AC\u0095*\u0082$H1\u0087\u00B9\u0094!?Z\u009F\u0094\x03\u0080\u00B4'd$\u00A1\u00A2\x1Fy\u00BE\u00A9#\t\u00BFQL\u00C0CZg\u00A2\u0091\u00E6M\u00F7\u0091Q\u00CF\u00C1\u0098\x04\u00A4\u00E1\u00CF%\u00E53\u00DD\u00BAT\u009DDI\x19\u00FB1\u00A2\u00AD\u00E3(\x03\u00A8n \x14\u0093%\u00E4\u00C5L\x06\u00E0\x17\u009E\x1F\u00CCL\u00F75%y\u00B1\x7F\u00A3\x1B.i\u00D0\u00B4\u00CB\r\u00F6\u008B=\u00C2a\x0F\u0082\u0087\u009B$\u00F1\u0080\u00BC\x04k\u00E0\u00D0\u008E\x0E\u00E3k\u00FF\u00C5N\u00CC\x05\u0092\x01y\x0E\x1Aq)\u00A2\u00CE\u00BA\x0E\u00AFs\x1C+\u00C3 Ax\u009A\u00C3Je\u00F0\x1E\x06-\x02VnEh\u00CFKTbC\x05\u00F5\u00A9\u00DC\u0086\u008E\b\u00C6\u00D2\u009E\u00D6c\x10\u00E9\u00C6\u00C5\u00A2\u00F6\n\u00AEG\u00BD\u008E\u00DA\u00EA\u00CD\u00BAjs\u008Ai\u00E8o\x15N\u00D5}\u00CB0\u00B9\u00A1*\x1A\u0097$7\x14\u00A3\t\u00A3\\\u008D'\u00CA\u00C0\u00C7\u00DF\x17\u0088}X\u00CE\u00EC\u00EE#\u00B20\u00AD\x10G\x19@\u0081\u00B2\tt$P\u00C5\x0F\u00C0\x0F\u00E6\u00F4\u00CB\u0088\u00E7\u00CB\"\u00CD\u00EF\u00DC\u00AF\x00\u00CE'6\u008F\u00B1\u00DE\u00B338 \u00C7\u00B4\u00B6\u00D9\u0088\u009E\x10ZRZ\u00A1\u00B8\u00BA\u00B7\b\u00BBB\u0089;\u00F3\u00AA\u00F7\u00D9\x13R\b\n\u00ED\u009CB\x1F\x15\u00E2\u00DA\u00E6\"\u00D5#$\u00C3\x0En\x7F\u00F7\u00DCd\u009F\x18tu\u00B4\u00DF\u00B6\x06\x04\x16\u00E9\u00DA\u0099A\u00FEnPH\u00B2R}\u009D\u00AB'\u00A5?\ne\u0094\u00BB\fm#\x11\u0090N9&\u00EA\u00D3\u0096\u00CC\u00C3\u00E0MeX\u00AA&w}\x1D\u00E5A(C\x1C\x19\u00BF\x0B\u00B2{k\u00B7\u008FO\u00D0\u00B9\u0090Cm\u00F7&)\u00DA\u00FA+i\n\u00ACs\"i\u00DB\x11M\u008B\x17.\u0084\u0081\u00EAgJ\u00E8\r\u00E5Z\u00D4\u00F9\x1AKC4hm\u00A7\u00D1\u0091\u00F7q\u00CF\u00AB\x01\u00CE7\u00D6\u0082\u00ED\u00D5\u00D7\x1Ag=\u00ABz\u0099;\u00F6\u00F2&\x10\u00EAZ\u008B3\u00F0N\u00C0\u00D2\u00C9iSh6\u0080\u0095\u00D8\u008B8V\x03\u00DEh\u00BF\u00AD\u0086\u00C2(\u00FE\u00C0\u00EF=\u00F3q\u00F1\u0099\u00DF\u0086\u00DD+\u00D3i\u0086IC\u00B6}\u009B\u00F8\x1A\u00D3\u00D0\u00BD\x16\u00B8\x1B\bia\u0080\u0086\u00C6\x14\u0089\x1A:C\u00B0>\u00B6\u0090\u00D6JbN\u00C6`\x1D\t4\u00B5\u00C4:\u00E3\x00\u00AA\u00DEC\x11\u00B4[p\u00FE2\u00A06\u00F4chc\u00D4\u00B8\u00CFh\u00A7\x10\u009B\u0082\u0094\u0092q%\u00E1\x17iW\u009F<\x17J\u00FCNK\u00BC$\u00E0ls;\u00AFR\"{JAk\u00EE\u00B0\x18\u00AF\u0082~R=\u00C88\x04C\u00E8\u00C1\u00A3I\u00C7\tO\u00EF\u0092\x0E\x02i'\u0090;S)\u00C6\x1D\x0E{\u00FB\u008D\u00D22\u00E3\u00F6\x1BS0\u00CE\u0099{\u00B5+\tj\u00D9_\u00D6\u0093\u00CCpl\u009E3\x0F,AH\u0089\u008A\u0090\u00CC\u00A8\x18\x0E\u00C0\x1D\u0086O\u00CCc *@\u00A9oV\u00F7Y\bY\u00E7\x04\u00E37\u00DEn\u0099\x07^\x13)\u00E5\x03!\u00D4{\u00D4g\x13n\u00CB\u00F7I\u00E9\u009D\x15\u00A3f\u00CCa\"\u008B\x18gHp\u00AA1I\u0093\u00AA\x18=\u0081\u00A9m\u0083\u00F5,jz\u00CA\u009D|i\u00AA\u0092\u00CE\u00A5\x10rC\u00D6\x0172\x06\x18v\u00C3\u00D3p\u00BC\u0086\u00F2\u00D5\u008BH\u00EFH42Y\u00F6\u00CF\x04\u00A6\u00C9\u00EC\f\u00E4,\u0095\u0081\u00D5hhK\u00DB\u00D9\u00A6\u00A4Z+\u0096R\u008Cde(\u008B\u0094O\"9Cr\u00D4\u00B8\x14\x1F\u00B1\x18\fW\x02[s\x1Ft}\u00EB;\x1CU\u00C6M\u00C7\u0081u\u008C\u008D\u0090\u00DB\u00B1@\u0081M\u0092g\u0088\u00F5y>8\u00FF\u008B\u00AA\u00D6\u00C7X\u00FD^\r\u00B75\u008En\u00C8\\6\u00B4q\u00A5\u009DG;\u00C7\x04F\u00A3\u0087\u00DA\x01\b)\u00D5\u00D7\u00A4\x1EJq8*\u00E3\u00B0\u00E5\x0E$\u0081s\u00B1q\u00E1\u00BB_P6\u0088\u008E8\u008Cs\u00AAx\u0085K.\u00CE0\x18N\u00C4\u00EE\u00C9$R\x17c\u00D0b\u0096\u009D \u00CE\u008B>6\u00FB\x01\u00A3'=\tJ\u00D7n\u00F5\u00BB\x18\u009D\u0088\u00D4[\u00FB\x18\b\u00DB\u0081\u0098{C!b`\u00CE\u00FD,\u00F3\u00DE[\u00EB\u00CFl\u00ED\u00F5\u00ECM\u00D9I.\u00EC\u00D3V\u00EB\u00C0\u00F5tf\u00FE\u00BD0\x10\u00D5[H\u00E9?\u0090\u00B9HY_\x02\u0081\x10\u00CE\u00F3\u00A5k0\u00E1Y\u00B3\u00E2&\u00E6\u00D1\f\u00BB\u00F9\x13p{\u008C\u00C8](\"\u00A8\x14f-Z\u00E9\u00AC\u00DDfp&\u009A\nI^\u00A0q?\u00B7\u00BB\x13\u00B5\u0098E\u00FC\x0Bt\u00D7\x04\x01\u00E9\u00AAL\x03\u009A&n\u00CFI\x14\x1F\\\u00DC\u008A-7\x02\x19\x07\u00B0\u00A1x\u00A61\u00BAqE\x18\u00854jl\u00B91K\u00FE\u00C6\u00BE\u00B8\u0082BH\u0084\u00E7LJG\u008EC.AW\u00F2V\x1B\u008B\u00E7\u00F9\u00B4\x0Bd\x7F\u00DA+\x11\u008F^\u009DY\u00C4\u00F5\x13*\u00ED62\x0EA\u00F1\f\u0086\b\u0081\u008E\u0080,\u0086\x0ByT\u0082\x0E\u00C1S9\u00F6\x15\u00B02\x1A\u00A1Sh\u0098\u00C7b\u00B2\x03>[\u00A5\u00E1\u00D4\u00ED\u00D1\u00E6R\x12-qs|\u00FA\u008E\u0089\r\u00C3\x0E\u00C08\u00B3\x0E8v>\u008A\t\u008C\u0090\u00E21\u00C7A\u0094Q\u00D2\u00ED\u00C8\u00F1$\u00F15Cd>\u00CBD8!\u00AB]\f\u00C0\x0E\u00B8\u008A\u00C6\u009A%\u008A\u008859\u00AB\u00DF\"H\u00F5'%\u00BA\x18\u00CFF\u00E8\u00ADJ\u009AD\x15\u00D6\u00F7\u00FE>\u00C88\x1D*\x18\u00EBv\u00C4F\u00B9\u00A9rq\u00D2\u00FDB\x06G\u00D5,\x11\u00DFd7\u00CE\u008CH\u00EA\x16\u00E9t\x1C\u00A8\u00CAI\u009C\u00F7dH\u00D1\u008Fb\u00A2\u0091n\u00EE\u0089\u00D4.\u00F0}\u00C3>\u00FC-\u0098x5&\u009A\x0F\u00B2$J!\x04[\x18A\u00FD\u00DEc\u00F3o\u00FF~\u0092\u00D0:O\x12\u00C0z\u00FB\u008DI\x106.\u0081?\"\x1EB\u00B1\x18\f\u008A\u0090\x00\u00DCfT\u0092\u00BEg\u00E6e\u00F9\u00DB\u0099\x19h_e\u00EFR\u00D7\x10\u00D2\u009AR>\u00FAM\"\u00B0\u00B0$[O\u00AA\x02\u008A\u00DB7\u00A8\x1E\x0B\u009E\f\u00D1\u00BB\u00F1Q\u00F3R\u0084\u00AB\u00E7057h\u0086A\u0097qp\u009C$\u00FEj\u00D0T\u00F9\u0090\u00F2\x12\u00898L\u0086g\u00C0\u008D\u009F\x01\u00BBG\u00D2m\u00E8\u009CA_q\u009F\n\u00F6!JH.\u00ACE}\u00C0\u0099~-\t\u00CF\t\u00E3\u00B3\u0093t\u00F3x\u00B6)M/(\b/D\x00\u0082\u0089\"pK\u00E9\bd\u008CC\u00C2l\u00AD_y\x05\u00D8'!\u0097\u00A6n\u00B8\fo6I\u00E7b\u0090Z\x1B\u00ABj\x14\x0B@\u00C6\u00CB#\u009E\x7F\u00D6\u0085\u009C\u00C8\u00F8\x1C!\u0082\u00F6\u0092Z\x06\u00CCl-\u00C7\u0092\b\u00A4I}Ix\"\x15\u00B7\u00A6\x1A\u0098\u00A4;\u009F\u0089]\u00F8y \u00D3\f\u009C\u00CFhr\x1E\u008D\u00B9'\x14\x02\u00EA\u00A3\x00\u00DF\u00A2\u00E6\u00EF\u00D7\u00D8\u00DF=\u009F\u00C5\u00BF\u00D9_\u00E4$(W\x00(\u0088,\u00F8\u00D9\u00D0\x02\f&c\u00CF\u009D\u0085N\u0080\u00B2G4x\u009F\u008FD\u00AAC\u00AB\u00B8l\u00ED:\u00C3\u00C2hV5\u00A11\x1C\u008B\u00F3K\u0092\u00EB\u00DCv\u008D\u00EE\u0097\u00D2U\u00D7v\u00C4\"\u0086s\x1B\u009E/\u00E3q\u00A9\f[\u00B9\x11\u00B3\x1FE\u00A4\u0082\u00BF1w\u00C5XJ\u00BF\u008F\x07\x1ALA\u009F\u0080v|\u00CE\u00D4i\x17\u00E3;\u00ABa\u00BC\x1F\x06k,\x0E\u00DA\u00F9d\u00C8\u00EC\u00DF\u0089N@\u00C9\u00CF\u00AD\u00D8\u00C5\f\u00E0\u00F2\u00E8\x19\u00B4\x11\u00CB\u0096\x06C\u00DEILB\u00EA\u0084k>\u009C\u00CF\u00F0\x12\x12\x06@\u00AE4\x12\u00A0t\u00E8\u00B5\u009C\u009A$\x17\u0089/\u00E1{\u00F4:R\u0090\u00C5t\x1C\u00A52 \u00EE\u00B3\u0084\u00F6\x1E@\u00AFS\u00ED\u0092\u00B0\u00C6\u00CF=\u00A4\u00A0\u00E2\x07\x16Uc\u00C0-$\u00B1\u00A2'\x0BY\x18\u00F9\t\x05\u0094ww\u00A8\u00D6\u00D6\u0081\u00CEF\u0096\u00D2f\u0098|\u00AE\u00CC$\u00A6\u009B\x16\u0086e\x0F\u009BZ\u0093\u009CS1\x0E\u00F7Z\u009F2V\u00E2\x06\u00B5?x\u00F7Nh\x1E/\x10b\u00E8q0\x19\x0B1\u00D5\u00FF\x15\u00D5\u00C7<\x1D\u00B8\\=\u0089\u00FD-\u0097\u00A7\x1E\u00DDN\u00DE\x00\x00 \x00IDAT\u00F1\u00BB\u00BB\fL\u00B5\x11J\u00ED\u00B8\u00AC\x12\u00DF\u00AB\u00E4W}\u0083U\u00BA\u008E[\u00C7\u0096\x14hM&\u008D<\x0Bj\x00P\x04\u00D3\u00A5z\u00F5\x07\u00AD\x1D\x11\u00D0mD\u00D2uz\u00DD\x13y^\u00D5*\u00A0\u00AE\x7F\u0087\r\u00E2\u008Cp\x1C\u00C0AC\u00CC\u00E4#\u009BV*\x04\u00CBg\x06\u00E1\u00F2\u00BCE\u00F2C^\x07\u00E4xT|uRzn\u00A97\u00F7\u00F9C\u00F6\u00C5y\u00CF-\u008F\x15\n\u0098\x10\u00BB)\u00A4T\x1E\u0085x2\rNaN`\x10\x19d\u0099/\u0099\bk\u0094L\"\u00A4\u00C9\u00D3\u00A5\x1B\u00EBaI\u00AF\u00F6\u00D6\u00F7\u00F8{\u00A9]`\u0093\u00F5!b\u0081\u0097QO\u00C7b-\u00B8]\u00E0C#\x0F\u00E2\u00B4\u0083\x062\x11\u00B8\u00ED!ai$\u00B4\u00B4\u00BC\x1D\u00C0T\x7F\u00D0\u0088\u0098\x10\u00DC\x1C>\u008E\u00C83@\u0084\u009D\u00C3z\u0081\u00FD\u0099\u00E0#\u00B4\x0B\u00A3\u00BCi6\x020\u008E\u00C4\u00E5Z<\u00F2:]\u00EC\x12~\u00C3\u00E3^D\n\u00B1\u008E\u008Ed \u0081\x00\x0E\u00C0\u00E9\u00C9i\u00AE\u00D6\u00F0\u00D6\x1C\b;\x00i$\u00A8\u00BF\x18\u00B8\u0091\u00F1\u008DIM\u0081\u00E3\u00CD\x02\u00AF1\u00AEy\u00EF\x19\u00EC\u00D7v\u00EF0\u00EC[-\u00BC2\u00AA-F\u00C5\u0093\u00AAp\u00F7q\u00CEPOD\"\u00F2H\x04 \u00A2N\u00E9p&@\u00B5S\tI\u0096H\u0080\u00CB\u00DB5\u00E8\u008E\x04z\u00DF\u00F8\u00DB\x12dt\u008A\u009C\u00F4\u00DB\u00CC\u00E0.t 2;\u00E4\u00A2V\u00C4\u009F\x02\u0092\x02\u00F6#!\u00BE\u00F2\x0E\u00BC3\r\u008D\u00B3y'\u0082\u009E\x14\u00845R\u00AD\u00AA\x10k\u00A9\b\x1Di\u00E9\u00DFb@\x07F\u00DA\x10\u0084\u009CD\u00F8\"tAqkLAE\u0084\u008D\u00F41g\u009B\t\u00AD\u00F1\u0094\u009C\u0092Z$\u00EA\u009CoI5\u00B9\x1D\x19\u00B0\u00B4\u00B8\u00E6\u00AER\u00EA\u0097>n\u00EA\x14*\u00ED8\"h5\u00D7\u00850t/\u00F5g\x12\x1E\x13\u00C63mX^\x12\u00EBF5\x0F\u00C4\x12*X\u00D5\u009DR\u00AB]\x00\x14\u0092\u00A1\u00B0\u00B2=\u00DAm\x06\u00DAtK\u009E\u00FBF\u009D\u00BFl/D8\u0089z\u009A\u00D1\u00D1UR.\u0098\u0099LD\u00B2\x1D$\"\u00A0\u00D1/\u00D7h\u00A2\u00B3\u00A62\u00A5q\u00F4\u00E0:\u0092\x11Q\u00CF\u00A6\f\u0099I\u00A3i\x006\x1C\u00D7\u00F7\u008F\u00FDm\u00E3\u00FE\u00D7\u00CD\u00F6\u00B7\n\u00A2O\u00EC)a\u00CE\u0092>\r%-\u0087\u00A1\u00A4\u00FAI\u00B2\u00B1\u00BE\u0082+\u00966\t\u00B1!\x04=X\u00EB\u00B6\bU\\\u0092*\u00D1\t\u00B4\x19\x0BA\u0083\u00DEyS\u00D8\u009C\u009C\x13a\u00AB\u00CF\u00DE\x1F\u00A6E\u00F1\u00D0&Y\u00CF\x16{\u00F5\u00E3\u00B0\u00C9\u00EB\u00A92\u0088\u00E0\u008C\u00BBG\u00D9`\u00C1\u0093\u00D2\u00F5E\u00DC\u00F2\u00F9O\u0093{\u0090\x0B\u00DD\u00CB6\u00A0\u00B1U\u009D\bd\x1B\u0089\x10P\u00F5\x1A\u00A6\u00D3]i{\u00DE/\u00B2\x0E\u0082a\u008E6\u00BF\u00EE\u00E1M\x00\u0099\x02\u00BC\u0098\u0084+j\u0090\u00BE\u00F7aB\x10|4\x0E\u008C\u008C\u008C\x03\u00FBY\u00D1vK5\u00E0)\u009D\u00DC\u00A1\u00F8yo\x121\u00D6\u0085\u00D3\x1F/\u009B\u0080`>\tc\x16\u00B3\u00E9B&\u00B2\x1B=\x16s\u00EA\u00DE`?6\u00C0o\u0088j:\u0081\n\u00F6\u0084\u008A\u00E0\u00C9h\u00DA\u00DA\x13\u0094O\x042\x11\u00C8Dc\u00D5\u00B3!\u00D7\u00C4\u0085\u00CB\u008B\x0Ec\u00F7\u0088sp!\u0088#\u00EF\u0095\u00C8\u0085\u00AB+.\x14S\u00B8\u00D4\u00FD\u0098\u00C3a|\u00E6\u00F5)b\u00A7A\u00D7y\u00FF\u00B4?hN\u00B5\u0084\x1Bs6Gz>8V\u00938cL\u00CB\u00E4\u00D6\u00C4\u00C4\u0090\u00C0\u00FD{_\u00DF\u00AFa/O\u00C7[{|\u00FEm\x02+i\u00EAw\x11\u00DFI\u00C7\u0097q0 \u00D5\u00C6\x07\x06fF\u009E\u00DC\u0082\u00E9{o\u00EDf\u00C1\u00CC\x15\u00A9\x14\u0091i\u00D0gTq\x1B\x15\u00E8\u00BC\x1E\u00E3\x1B\u0092hX\x17\u00D3I\u00B4\u00DE\u00CA\u009D\u00A5\u00BD\u00A33\u0083b\x14\u00E9\u00E2K&\u00A3u\u00DDvJ\u00EA\u0082\u008A\x04I\u00B3-\u00A5:\u00D7\u0092\u00A9\x1D\u00A9%Z\u00F74n\u0082\u00D0\u00DFG\u00EB\u009F\u00DEZ\u009B\u00B2\u00BBL\u0084\x01\u00B7?U\u00F5Qs\u00A0\u00B1\r\x18.\u00E4\u00FEuO\u00F8\rF\x06\u0085\x05Z\u00BBl\u00F7_\u00DE_\u00C3\u0093_\x06\u00AE?P\u0092\u00AC\x11\u0099w\u0082\u00EAj@'\"\u0085\x17sj\u00F3\x1A>hS\u00C4\u00E1\u0099P%%\u00BA\u00F1O\u00EA\x06\u00D6~t&\u00B0\u00F4\u00A1\u00A9/KlA\u00FB-\u00FB\u00D1\b\u00DE\u00CE}\u00E9\u00E39\u00C7\x15\u00C42<|\u00CFi\u008E\u00E2\u00A8\u00A1.\u00B8\u008F\u00F6H\f\u00B7J\u0098\u00F9\u00A0\u00B4\x16\u009D\fLZ\u00A53\u00C1\b\u00C5(tLRbM+\u00AF\nK\u00B2\u00F9%\x12O\u00A6\u00B0G\x7F&p\u0099\x1C\u0085P\x01b\u008D\u008Eiw \x044\"\u00E3gg(\u0084\u00E0~\u00BAq\u00EEUH\u00C4\u00B5Z\u00F7\u00E99\u00C8\u0085\u00ED\u0094\u00C8\x07Ty\u00B9\x16\u00B2\x18\u0087\u00A4\u00DC\u00D1\u009E\u00A9\u008ESM\u00A1\x1A\u00E2i\u00C7\u00E8*CAe\u00F3~\u009D\f\u0097V\u009F\u00B2\u00A2j0\x0B\u0083j\u00C4\u00A8\u00BE\u00CF\u00F2\u00B0\x18&\u00D2\u00DB``_\x19\u00F3\u0090\u00A8\u00A3o\u008A\u00AB\u0095D\u00F4#\u00A3\u00B4;\u00C7\u00D2\u008C\u00A8\u008D\u00B0\u008B1\u00A9\u00EFV\u00E3\u00C9{L\u00D8\u0094\u00D7\u00E3\u0080\u00D3\u00F6bhh\u00AB#\u0092|\u00C6\u00CEg\u00B4\x018\u00B0\u008F\u00AB/\u00EF\u00CF\x1D\u00CF\u00BE\u0084k-b$A\u0084kO\u0092\u00F9.\u00DD\u00FA\u00C44`\t{\x04\u0095\u00CBp\x18\u0084\u00E9\u00CB\u00B5'i\f\x04sH$\x02t\u00C8v\u008B\x01\u00F4\u00F7\u0089\u00D9X\u008F\u00CA\u00F3\u00B1\u00DE\u00D3\u00B0\x10Xg\b\u00E3\x1C\u00F5\u00A8\u00E8C\u00DFh\x00Dn\u00A8\u00AA\u008DP\u0090S<\u00A0\u00AD\u00BC\u008B8\u00B38W\u008E%=\n\r\u00B5\u00F4c=\x0E\u00C1\u00AD3\u0083\u00EEv\u00C4\u0082\u00C2\n(\x0E\x1C\u00EE\u00B4bKN:\u00B6T\x11\f\u00F3@Z\u00B9\x0F\t1G\u00E6\x0E\u0089\\<\u00AFAJd\x03\u00DD\u0092\u00B31\u0088\u00B4\x17\x00KJq\u00C0\u00C3\u00B6\u0090I\u00C8$\u0088\u009C\u00B9<\x0F\x15m\u00A7\x05\u00EB\x06k\u00C4\u00E9\u00E9q\x10\x10\u009E\\\u00E8\u008C%@\u00B3\u00EF\u00B0\u00BF\u00D2\u00F1\u00B5\"B\"\u0087\x0F\u00DE\u009A\u00C4\u00F5|\u009A\x16\u00C6\u00C7\u008C\x13\u00E1\u00BArURB\u00F5=\u0091\x02\u00BDn\\\u00EB.\"%\u00B3*$\u00A8I\u00EE\u00F3\u00E6\u00C1\x14\x18\u009E^\u00ABFj\u0091T\x1C\u008E\u00D7d_:`\u00B8\u00D0\u0088\u00ED9'A\u00B3\u00B3\u00BE\u00AB\x1Ax\u00AAb\x07*\u00F6 tC\u0085D_\u00AE\u00AF_\u00DA\u00AFn\x1E\u00BC\u00E8\x0F\u009Ad\u00CC0\u00D7\u00AE\x1A\u009CR\u009F\x11\u00D0\x1B\u00BEU,Q\u00BA\u00C86J\u0095-\u00F4\u00FBn\b\u00C9\x7F\u008B\u00DB\u00AD\b\u00A1\x11\u008E\u00EE\u00D1\u008E\u00DF\u00A5\u00CA\u00DC\u008Az\u00ECD\u00E4\u00AD\u00AF\u00C9\u00A7\u00EFj\u00E7\u00AE7\u00E7\u0084D>\x01<\x060\u00AD,\u00FEQ\x12\u00BDvY\u00DA\u00B1a\u00D2\u0096\u00A09\x14$\x17*qF \u00A6G\x02\u008A7\u00A0\u009B\u00D0\u0094\u00C2\\\u00E5\u00D3\u00CBKA\u00C3\u00A1\u009E=\x1F\u00AD\x02i\u00E1\u00C0&\u00A2\x04m\x01\b\u00C2\u00DF(\u00D9e\n\x18\x0El\"b\tQ\u00A7\u00B1\u009BD,\u00CF\u00C3\u00C1\u00DF\u0086\x18\x04\u0080J8\x02\u00E9\u00DA\u0080\u00C6\x1C\n\r\b-\x00\u008Bz\u00B0d#\u008A0\u00B5\u0096t\u00AE\x0E\u0088\u00F17\u00BD9\u00D7P#\u0080\u00FCI\u00C2J\u00C4E+}\u00CC\x00*\u00BA\u00F0\u00EC\u00AAT\u00BBjC(eFP\u00CF\u0082\x1E\x1A\u00EA\u00F5\u00AD\u00AC\u00F5\x1C\u00D7r_\u00D7\u00BA\u00EE\u0091\u0092\u00ECKC'1\u00A2f\x07\u00D0\x10\x15\u00C0\u0094FC!\x06y\u00E0@\u00B4\u00A3\u00DF\u0091\u00CCW\u008C\u00CE\u00C7\b\x1B\x0F\x06r\x1F\f\x06@E\x0F6\u00F8\u00F6\u00C4\u008B\u00FB\x07\u00F6g~?R\u009C\u00F9\x10\u00D2g\u00DF\u00A5q'\x1E1\x0E\u00E35\u008D\u0098\x15\u00DA\u00ECa\u00B4P6^\u00A9\x07\u00FA\u00DEl\x0E\u00B6\x12\u00BD/\u00D7\u0094G\u00A0$\u00B6\u00CEGNtF56w\u00E2\u00A2B$\u00B3\u00AA\u00BET\u00FB\u008E\u00BB\u0099\x03%2%\u0084\u00C1\u00F0\u00C8\x1D7VL\x00\u00B0|\u00C4Q\u0081\u00BA\n\u00A4H\u008FW\t\u0095\u00A8\u00B1\u00D7\u00BC\x05yN\u00F3\x17\u00EBoC^\u00BFVP6-aLlY\u00A99%7%v\u00D8\t\"\x02^\u00C1E\u0092n\x13M\u00E2\u008B&[j\u00EC\x007{\u00C9\u00A7\u00E2i\u0080\u00D55\u0083\u00CC@9\u00FB\u0099\u00DF\x0Fkk\\\u008CA\u00CFI\u00CF\u008C\u00CF]\u009D\u00F2\x1B\x14,\x16\u00B3\x00J\u008D\u00B8\x0B\u00CA\u00AB\u00DD\u00A6\u00E3\u00E7w]\u00D3U\x11\u009D/\u00EB~\u00BDs\x13Z\u00A9\x1C\u0099\n,\u00F4\u00B2\u00BA\u0090\x13\u00B1\u00A0$7\u00D0}Ozi\u00DD\u00CA \u00DA\u00D5\x10\u00A0\u0082\u00B1\u00D2\u0090\u00C3\u00F9ij\x16,\u00CE3\u00CD\u00CBy.v\u00C0/0y\x1B\u00D2{\x13\u00F3\x1CZ\u00C1%\u00FB\u00EB\u0090%KQ\u00C1D\x0ED:\u00AF>\u00F3\u00CC\u00EF\u00EFo\x1Do\u00FB=;\u00EE\x01\u00FB\r\u00BA\u00AD\u00A0b\nDDEL\u00B91\u00AA\x1B\"vAS1\u00928\x0Ba\u00E8\u00D7Fhs0\x7F\x7F;\u00B5\u00DBU\x04\x12\u00A9:\u00DE\u00F5\u00FE\\`\u00F4\x1E\u009Cb\u00F5\x03\u00EA\u00D5\u00FD\x15\x1B\u00B0\x04?\u00F1\u00FCq\u00BE\u009F\x18\u0081\x16\u00B8U<\u00C6a\u00A5\u009D\x1D\x1E\u00B1\t{\u00DA\x11\x14\u00C9\u00B9%\u008C\u00B7\u00BC\u00F7\u0096\f$\u0090\u00C1\u00C6\u00CA\u00C9e#0\u00A2\x101\x14A\u00D6\u00BEE{\u00CD#\u00AD\u00D2\x19\u00F3 \u00A1a\u0090\u00A4\u00EF\u00C2\x07m\u009D\b\u009A\u00BB{,\x11\x0F\u008F\u008B\u00BC\x03a\u00EF\u008A67g\u008F\u00E9\u00B3\u00CE\u00B6\u00A6P\x02\x19\x11\u0089.\u00DC\u00F0Z\u00D8:\u009F\u009F\x07\u0090\u00A9\u00CE\b\u00B9d\u00CE\u0080\u00A1\u00B6\u00D7b\u00BDF\u00DD,\t\u00B0\u0090e\u00D4/\x10\u008A\u00E9\u0088\u00B3\u0090\u0087\u00DB\u00803\tHi\u00C1u\u009FK\u00AD%\u008E\u00B3\u008C\x7FL.b\u0096TT\u00AF:\u00E0\u0098\u00E4\u00A2\x1A[1\r\u00A3@\u008D0\u00E8\u0089\u00A8\nMF\u00C15l\u00A6:V\x13\u00DA\u00C0x\u00D8`\u00D7\u00C94l\x0B{\u0082]8O\u00D71Of\u0088pkn\u0098\u00CB\u0087\u0091\u00D0_\u0091\u0093\u008AC\u00B0#\u00AA\x1BD$\u00FBt\u00EE\u00DDh\u00B1\u00D1\u00AB\u00B6n\u008F}\x12\u00AA\x16B\u00EE\u00A1\u0080\u00F0V\u00C8\u00AD(\u00BB\u00C4\u00C1\u00FB\x1E\u009C7\u0095r\x17\u00969\u00E0\u00DCg!\u0088+\u0089\u0093\u00EFd\n$\u00A2\u00C3\u0081\u00CD\u009D\u0085sbQ\u0087!\u00D1\u00C3\u00AD\u0098UxCj\u008F\u0089\u00F4r\x04c\x18!\u00F4e\u0088\u009ChFJ\u0084\u0097\u0082k>\u00E8\u00AA\x13\u00F0\u0099\x19T;\u00B9\u0096\u00F4|\u00FC\u00B22\u0095\u0084\u00FB\u009D0\u00BB\u00FE\u00AC6$\u00F5\u008F:\x1FjG\u00D7v\u00C8\u00DDaw\u00CFI\u00A0\x14\u009DB&\u0092\u00EC\x1D\u00D2\u008Bi\u00CC\u0090\u00BC\u008DH\u00B3?i_`\x1E\u00C1\f}\u00DDR\u00E7\u00AF\x1C\u00880\u00B0^\x1A\u0093\u00E9\u00CC\u00AE\"K\x16\u00E9\u009EL\u00D2s\u00CD\u008A)\u00AE^\u008C\x1E\u0089\x19\u00F1\x06\u00DER\u00B9\u00CBs\x11\u00DF_\u00BF\u00DE\u00F0\u00CC\u00F7\x7F\u00FF\u00EF\u00EC\u00DF\u00EDW\u009F{\u00CE\u00DE\u00E6\u009F\u00C7\u0097\u00CCN\u0084\x13\u00D2WD\u00B2\u0086\x0E\u00DF\u0085\b\u00ECD@uLL\x03\u00D9~\u00A9\x07\u00C8\u00F3U\u009C\x05\u00BAg\u00DA)Z\u009B>\u0080q\"\u00EEqF\x05\u00EC\u00D7\u00A2\"4{DC'\u00A9\u00E6\u00C0V;Vcj\u00F2\x1A\x18\x19\u00C0\u008D\x1B\u00EE\u0091x\x0F\u00C4\u00CE\u00CF\u00831\b\u00E5k\x0FUBh\u00C1A\u0081\u00E8H\x15&\u0093\u0094,\x18\u008AQ\u00D5: i-\u00E6\u00A6\u00D8t0\x0F\u00A1\fz\u0087;\u00B6\\\u00B3\u0096h =j$z\u00B9\u00E9\u00B2|V\u00EA\u00FE\u00D1\u00A9\u0083\x06\u00C19-#\x7F\x01_\u0099MC\x06b6zml3\u00D1\u0082\u00D6\u00BD\u00DE@\x11\u00F2\u00B4\u008A~>\x06\u00F0:\f\u00F71p\x10\x05\u0084aMR~\u00B0\u00F4=U\x05\u00E5<\u00B8\u00BC\x04\u008C3\u00B0\u00B6\u009B3\u00DBQ\u00C9\x14\x00\u00A9JH\u00CD\u00D0k\u008A\u00F0\b\u00DF\u0093&$\u00C4\u00B8\x10f IHJ\u008FYR?a<\u0089\u00D1\x0E$c\u00B0Yl0\u00D7\u00BE\u00DA\x012\x11j\u00B0\u00AD\u0083\u00C7\u00D3\u00D8\u00B8TH\x02\u00D6\u008E\u00C7\u00FD\u00E2\u00FE\u00D6\x10\u00EBh\u009FM\x1A\u00EB\x128l\u0091\u00EC\u0082\u00C3\u00DD\u00D0\u00A6k\x1Ba&\u00D4\u0097\x14\u00A7\u0084\x16\x03\u00CA\u00F9\x1Ad\x1E4\u00BEI\u00E7\u0097\u00AD&\u008D\u0094\u0092\u00BE\r\u008E{\u00CB\x02\u009D\u00DDS1\u00B0\u00D8=|o\u00E3\u00D2\u00B5^\u008CA\u00EAH\u00F6U\u00A2\u00A4\x19/S]Rx6\u00DB\u00C8\u0089\u008A\u00F9\u00B1^/a\u00A1Y\u00A9&\u00BE\u00B4mp\u00DC{\u00F2\u0099\x17\u00ED\x03O\u00BD\u00BA\x03\u00C0\u0093\u00FE\u00E03\u00C0\u00FE\u00EE\u00AA/\u00D0uvC\x05\u00F5H\u0097m\u00A5\u00BC\u00A8\x0B\x17\u00F1\u00DC\u00A5\u00A7\x17\u00F2\u00E8\x16\u00F6\u0085\x11\u009C\u0083\u0087\x12\u0081\u0088@\u00CBh\u00B7\u00A8.K;w\u00C3\u00FD*w\x06\u00F4\u00E2\u00A8\u00F34\u00A6\u00BE\u00FDZ\u00E9y\u00C5\u00C5\x1D\x03\x17\x00\u008F\u00A0\u00C8\u00C5\u00B0\u00F4\x1FV\u00D1\u0081\u00B1\u00ED\u00FBP\u00AF\u00A1\u00E0\u00A2d\f\u00A6\u00DD\u0098\u00C2V\x10\x19\u00F3UeIp\u00DD\u00C4,\u00C0\u00D0hg0\u00AB\u00ECZ)\u00B1=\u0093\u0093\u00FA\x1Bn\x18s\u00F2\u00B1S\u00DEM\u00C31\x01;\u0082\u00C0\u00E6\u0094\"C\u00B67\r\u00F3p\u00C0,\u008Dp\u00CA\u008A\x17})U\u009A]\nd\u00E0\u0080O\u00C3\u00D1\u0098\u0081\u00D8\u00B3\u008B1\u00F1\u00FA\u00CE\u00B4\u00C4p\u0096\u00C8CHB\n\x0E\u008B\u00E8\u0081e\u00B3\x15\u00BD\u009B\x1B\u00B1\u00CEkR\x1F\u0088\u00B5\u00EA\u00CA\"\x14\x01v\u00DB\u0085\u00B8\u00A3\u00DA\u0094\rB\u008C\u00CA\u00EB\\\u00AD\u00AB\fzj*L2 \u00ED\u0092\u00E1\u0080_\u00C1z\u00DFx\u009DCi\u00C84\u0084v.\u00DA\u00ED\"BF\x0B\x13\u008C\u00B9P\x1B5\u00EE\x01\u00D8\rJ\u00BDo\x13\u009ELS\u00C7\x15P\x15(\u00E6\u00F1\u00BDg?\x03D\u00E2\x00\u00DE\u00E6\u00EF\u00FC-\u00F3\u00AB\u00FF0Cd\u00E5Ah\u00D23\u009E\\\u00AF\u008B\u00D0\u00B8\u00A8e`k\x12TO:\u00EA1\rk\u00AArSQ\u00EEHG\u00EE\u00E9\u00CA\u00E5%(\u00CF\u0084e;\u009D\u00C1(\u00B0\u00AA\b_\x0E\u00CFz\x15cZ34\u0089\u0088\u00B2=\u00DC\u00D9\u00A7G6p\u00E3\u0083\x06\u00C4 \u00E8\u00C3\u00C2\u0096p\u00806\x04>\u00E6\u0083\f \u00C3M<\u00A2\f\u00E5a\u0098\x1EhA\u00A6&\x19\x1DG_&'\u00EFA\u00B7\u00B9i\u008DM\x12a\u00DA\u00C0P\u00814N\x06Q\u0081F\u0096\u00C1E\u00DD\u00B8\u00A8\bF\u00E7q-\u00D1\f\x04Jf\x13m\x0F\x00\u0098\u0091\u00A9)\u00D4!\x17dn 2{\x1F\u00B40k\u00ED\u00C7\u00EF\u00BC\u00D9\u0082.\u0082p\u0087[X\u00EByN\x19\u00FBZ[\\\u009F\u0095\x1BA7\u00AF+\u009DZ\u00D7!t\u00FA\u0094\u00C6\x17(|+\u0089\u0099\u00CF_\u008CB\x15\u00A1J=\u0096\x0E\u00CF\u0088\u00C5\u00B4A\u0088V\u00C4\u00B1\x15)(D\u00A2\u00F3\u0080>\u00FE\u00A4\u00B5zp\u00CB\u00BA\u008E99\u008A\x1E\u0092\u00A1\u0095\u00D8P\u0088\u00B4\u00FB%b\fR\u00E7\x13s\x0Btc4>z\u00B8|8\u00CE`]7\u00CF\u00DC\u00FB-\u0080\f\u00E1;\u00E7;?\u00BDM\u00C3\u00DC|!\u00DE\u00D0\u00D7\u00B7\u009C\u00A8\u00D5#\u00D0\u00E3\x15z~\u0082-\u00C7o\x13l'4C\u00ED\x04e\u00ED>\u00D4\x053\u00F3\u00B23\u00A0\u0080\u00F6\u0096i\u009Et\u0083\u009E\x19L\x12\u00BB\u00DA\u0094\u00AAQ\u00F6\x02\u00F5S[\x7FW\t\x00\u00E3sk*Q\x1A\u008E\u0080G\x03x\u00DD\f\x0F\u00B0\u00E1\u00C6\"\u009B\u00E0\u00A0\n\u00B1\u00A11\u0083\u0094\u00F0\u00F1\x1EtgM(\u00E2@\u00F9\b\u00F4@44\u0096\u00E6+\x1A\t\x1DXlj\u00D3\u00C1\u00EC\u00C5\u0090\u00FA\u009E\u0092\f\u0099\u0093 \"\u00E8\u0086\u00C79\u00B5f\u00A9v\u00A0\u00CE\u009D\u00EE8<\\\u0089\u0083\u00F4\x19\f\u00C8\x0B\u00B9\u00CC\u0098\u009F\u00C1\u00FEH5\u0091w\u00C2i(I\x06\u00A0\u00CDX\u00D2 \u00BE2\u0084[\x04\u0082bH\u009A{m\u00BE\u00BA0\x00\x11rJz\x11qAi\u00C1{KI\u00DA\u00A5\u00BC>\u00BD\u00AD\u00BDhgIv\u00D2\u009AHBT8qC\x12\x1C\u0084\u0083kR\u0097\u0085o\u00B8\u00EE\u00D5=\x10\u00EA[2\x02\u0096i[<,\x13\u00BEx\x19\u00E2\u0098a\u00D6\u00FCr\f\u00F1\u00DF\u0080\u00C9H\u0099\u00E8b\u00AF\u00FB\u00BAvyo\u00F3\u00CE\u00CE\u008Eg\u009E\u00FD4@\u0086\u00F0\x1F=\u00F9\u0081O\u00FE\u00AF7\u00F7\u00F1xp\x05\u00C7Aubs\u00C3f#5\u00BF\u00CDA\u00A2G\x04k%\u00BC\u008C{o\\\\\u00B1\u00D6=\x17Q\x12\u009F\u00D7\x1A\u00E9\u00DB\x13\x18\u00D7\u00CC\u00CC\u008E\u00AD#\u008E5\x15\u008B\u00DD\u00A7\u00D5\u00B9\u00B2\x1F\u00E82\u00D2HT\u00D5\u00B2(\u00A3\u00D6\u00DA\x01=\x14\u00C2Y\u00DDk \u00C4\u0090\u00F6\nh\f\u0084\u00C2D\t[g\x02\u00B3}vt\u00A0\u009BNp\x7F\u0087\u00FA\u00BB$\u00BC\x04\u008E\x17gL\u00A8\u008F *T\u00FF\ny\x04AL\u00D6h\u00A814\"\x17SH\u0095A\u00F7\u00E9u\t\u00F5\u00DCnP5 \u00AC\u00EE\u0093\u00D1\u008E\u0086\u00CA5\u00B8\u00E8\u0089\u00C4\u00BA2\u00E1ON\u0082_h{\u00D8\u00D6{\u00E78v\u00DC\u00AE\u00C4\x14\u00A82B\u00FDew\u00F0\u00D6\u00FFH\u00EFN\x1BC\u00DA=\x06\x1C\x17\u00A2\u00BET\u00EApc\x13\u00C7\u00F7}\u00D7'\u00F13d\b\u00EF\u00C03\u00BF\u00F9\x1D7\u00EF\u00C7\u00A7\u00F7\u00CFB\u00D5{\u0093\u008B%\u0091v\u0088]Du\u0097\u008D\u00C1s9\u00E9\u00A6g\u00DD\u00BE\u00C1\u00F0;U\u0084~^cP9\u00D9\u00FD\u00DC\u00BB\u00FAV\x13\u00A7\x18\nW\u00FB\x19\u00B8THe\n-,}U\u00BB^\x7F\x1B\u00B2\u00FD\u0087\u00EEx\b\u00E0\n\x03;\x0E\u00EE\u0095\x1D}r\u00A7aQ\x01Q\nU\u00E6xB\u00C8\t\t\u00B0\u0090\x06,\u00F4u\u00EA\u00AD}\u00CD\u00A7\u008B\u00AF3\x07.\x11\u00E5\x16\x00@\u00ED\x1C\u0084\"\u00E2N\u00C0\\d\u00B9\u00A1\u00C8A\u00A6\u00E1\u0096R\x1E\u00B3?\u00E1\u00F8\u00ED\u00F0\x16SI/D!\u0094b\n\u00EE\u00CE$)2X\x17r\b\u0082It\u00D0R\u00A9\u00B9&qr\u00F1\u00D4wO<\u00A2A\"P\u0080H\u008CD\r\u00CD\u009D\u0092x\u00BC\u008E#\u00D0\u0082y\u0095\u008AO\u00FBDN^\u00BBq\x164\u00E5D'z\u0090\u00E4\u00BEB&\x1E\u00A5\u00B7@\u00C8\x04\u00C8\u00BC\x01\u00F6\u0081\u00D6\u009F\u00EAS\u0089wT\u00AC\u00CBD\x16\u0083\u0091\n\u0092O\u0099\u00E8\x07\u00ED\u009D\u00AE\u00C3\"\u00EC\\\u00AB\u00F2\u00CA\u00A4-\u0084c\u00B4`p\u0096\u00DE\u0094(U\u00E7\u00CF<\u00C0\u00DB~\u00EC\u0087~\x13\u00FF\x0B\x19\u00C2\x07l\u00FB\u00C2\x7F\u00FC\u00E8\u00FF~\u00F1S6\u009E+X]\u009DM}\u00C5\u0094\x11)\"!|o\u00D2\u00F6\u0096\u008D`a0\u0094\u00E4Y\x0Fad\u00DBqE\u00E9\u00F6\u00D9\x0F2\u009CE\u00A7\u00CF\u00F6\u00D7D\u00A7\u00F2 \u00D4\u00C3Mf\u00C0v\u00D4\u00CF\u00C8\x06\u0095\u00E5c\x14?pF?vx\u00DA\u00CA\u0094\u00C9xz\u00B1@\t\u00F7a\u00B8\u00F1\u0081\u00C7\x00\u0086\u00E7\u00EE\u008F\u00D0>\f7\u00ECS\u0094 \u00A7\u00A11\x13\u0093b'\u00E92>\x16\u00D1\x06\u00D4\u00F7\u00ACc\u00A0\u009D\u00A2S\u00A0\u00BA\u00B6fkk\u0086k\u00ED\u00A0\u009A\u00A1\u009A\u009AZ\u0087\u00C9J\u00A2\u00F3)\u0092QT@\u00945B\u00D5X\u00AD\u00EC\x16\u00CB\x1E\u008B\x1C\u00BB\u00C60\u0089\x14\u00B8\u00D3r\u008D\u00CF\u00B1\x06(\u00A1\x11\x0F\u009Fa&Tu\x1D\u00BC\u00C1x\x07!\u00B7\u0084@\u00B4\u00A5\f\u00CE\u00B0E\u00CCbP\u00BAG\u0086]k\u00ECr\u00FF\u0089\u00F0\u00F7\u00EC\u0097\u00A5\u008A \u0098$\u009Ap0\u00C2\x04f\x17z\x0ED\u00C4m]\u00B4\u00B5\u00BE\u00BC\x1C\u00A8\u00BD34~]\u00A1\u00B9\u00E6\u00DF\u0099y{pz\x1C\u0097\u00E7\u00DE\u00F6\u00A2\u00FD\u00E0\u00BB\u00BE\x00\u0090!\x00\u00C0[\u008E\u00A7\u00FE\x19\x1C?\x12\u00C4z\u00CA(4\u0085\u00C6D\x03=y\u00C8F\u00C5\x1AT\x1E\x02\u0089\u00D3\u00B5\u00F8)m[\u00F4\u00DF\u0082\f\u00B2\u00EB\u00ABZb\u0094\u00EAk\u0080\u00D4\u008AHFg K{\n'\u00E6\u00FDN\x1E\u0084\u00F4\"\u00901 \u00ED\x12\u00A3\x18x2.\u00E4\u00B8\u0090\u00E3\x1A\u00F8\x06\u0080\u00FB\x00\u00AEh\x14\u00BC\u00B1\u0081\u00DD\u00A3'\x1B\u0098\u0080jat\u009BpL\u0097\x0B\u0091nJ\u00B3&\x17\u00BCT\u0082\u00C6\x1AK\u00A8\u009C\u00A2\x12i\u00F0R4\u00A1\u00898I\u00DC\u0092\u00E0\u00A0\x17B%\u00D3\u00CAR\x191\x07\x00Je\u00F0\u0088n\u00DCH\u009C\\^\u008C\u00A0\u0094j\u00C0\u00CC\u00BC\u0086\n\u00DC\u00A3\x0E\u00E3\u0080\u00A5\u00BD\u00C3y\u00FF\u00890\u00A4f\u00F1V\u008E.\x11\u0081\u0090\u00BF\x16\u00F6lK\u00B8\u008D\u00DB\u008EB6\u00EB\u00F3n\u0093\u0084\x01\u00CCk6\u00AA\u0098\u00FE\u0093\u00C4o\u00E1\u00C6\u00D1\u0087\u00EE~l\x1DZB\u00A6;\u00A1q\u0080\"\u00F4d}\u008A \x04\u00D2;\u00A1~\u00E4}*V\u00A0{A\u00D2\x16\u0092\f\u00E2R\u00E3\u00C9\u00F6\u00B6\u00B5_\u00E9\u00A2T\x1F\u00B5P\u0080\u00F2\u00B2\u0088\u00F9\u0089\u00C9\t5\x1C\x00\u00A3\u0080\u00DD.\x18O\u00DC\u00FFg\u00EAI2\u0084\x0F\u00D8;\u00FF)\u00FC\u0089\x1F\x01K%9\u00AB<\u00FA\u00DD\x1B\u0093i\u00EA\x0BP\x0BU\u00FD[\x18M\u00FD-\x17\u00E4+nx\x02\x03\u008F\x11Pzo\u00E1]Y\x18\u0085\x06V\u00A5\u00D2z\"\u00AA\u00E8S_\u00F8\x11X\x14=\u008B-\x07-U\x00\u00BD\u00E1h\x01C\x1EL\u0081D\u00E73\u00A4\u00F9\u0090\u008B\u0091\u00D27\u00A4\u00BFC1\f\u00EE\u0091\u008F\u0091u\x10BH\u00E1\u00D2\u00DA\u008F$\u00A7r\u0083&AK\u00BD`;)\u00AD\u00D5gt4\u0092\u0082\b\u00B2\u00DAo\u00F4r\u00A0\u00D3\x04\u00C7R\u008C\u00C2\u0093a \u00CB\u00C3[ \u0088Ts\u00880s\u009F\u00C3T\u00A4\u00C2\u009B\u00C0D\u00A5\u00A8\u009F\u00D0`F\x0E\x18$\x1C\u00D9\x03\x1C\x151Y\u00CC\u00DF\\\u009CZD\u0086F\u00D4'\x06\u0092\u00D1gg\u00E6\u00B3J\u00EA\\\x07\u00A9z\u00B4k2UY\u0084\u00DF\u00DAj\u00C6\u00C1X\u00BB=\u00A1K\x13&f\b\x1E\x13\ni\u00B4\u0091\u008Cd\u00E0\u0095\u00E7\u009E\u00FE\u00A7z\f\u00C9\x10\u00BE\u00FF\u00DE\u009F\u00FE\u00B5'\x1F\u00FD\"^\u00BB\u00F7\b\u009D\u00D0\u008B\u00FB!\u00A1\u00AE\u00A1\x13h/\x03\x06,\u00C4z\u00B2-\u00DC\u0082<\u008A\u00CE\x13\u008C\x17\u00B19\u0090Qg@#jMB\x1C\x1B\u00D96\u00D6\u00B6=\u0098\u0089'\u00A7\u0096\u00CD\u00A0\u00A3\x07\u00DDCVlF\u00EE\x199\u00BE\n\u00BB\u00C8\u00D8\u00E3\x00\u0088\u0086BPD\u00DF\x1E\u009A\u00E1U\u0084\u00FD\u00E0\u00CA\u00C3\u00D2;\x19y\u00B8A5\f*\bIy\n\u0086\u00B2\u00E6\u00870\u00A1\u00B4\u00D6:\u00A5\u00D5_H \u0098BA|\x07R\u00FF\u0097\u00B4\x06%\u00BB\"\x01\u00A3b\u0092W`\u00D2$\x13\u00A0%}6bN\u0095\u00D9\u00CB\u00FD\x18\u00A8\t\x19\u00B5(\x04\u00A2\u00E5\bGl\u00DE\n\u00D1d\x10\u00BAT\x1B\u00A5_\u0097A3\u00C6\u009Cq\x13\u0085\x1A,\u009Fl\x1E6\x02\u00DE\"\u00D9B\x1A-\u00D3&\u0090\b\u00B7\u00D4\u0082F\u00E4\"0\u00C5\x14\u00A4t\u00A7Tw\x0F\x02\u00DFR\x1A\u00C7=\u00BA\u00EBR\u00A877Q:\x1AA\u00F2S\u00C6\u00BF\u00AA\x1F\u00C4>\u008B05\x16\u00E7\u00BD:\"H)Y}\u00D6\u00BDG\u00BB\x0F\u009C*\u00D5\\\u008F\u00F5\u009D\u0098\u00D3\u008E#U\u00A71\u00C1\u00BE\u00A3t\x11\x14\u008A\u00B97\u00D5\u00C3\x16b\x01\u0096*\u00C4\u00A9\x16\u00E8\x1C\u00BD%}\x19\u00AE\u009F\u00FAz\u00D3\u00FDS\u009A\u00AB\u00B8js\u00EF\u00E1\u0092\u00F7\u00EF\x10]\u00F5!Cu\u00DB`\u00CE\u00CDl\u00BB\x0BuQA4\x0E\x11\u00B9\u0090\u0081~\x13\u00C7\u00F4\u00EC\u00C3:6\u00A9\x1B\u00CD~!\u00E6#Zy\u00FB[?c\x1Fy\u00CB\u0097D)\u00C9\x10\x00\u00E0\u00BD\u00FE\u00F6_2\u00B7\x0F\u008Ah3\u008A\u00CFD\b@\u00A1\x07 \u00FD\u00F4\u00A0\u00CF\u0099\x06\u00C9\u0099\u0093`yM\u00955\x0B\u00FEtk\x0F\u0087[\x05L\u008A \u0097\u00D0\u00E3\x055D{\u00B3\u009D\u0087\u0093j\u00D0c\x0B:\u00C3pI\u0096\u00AC\x16\u00B2\u0096+\x13*\u00E8\u00C6\u00C7\u008A\u0094\u00F4\u00E5\u00FE\u0087\x01\u00AF\u00B8\u00E3\u00DA\f\u00BB\x19v\x0F\u00C6p\x03$:\x00h\u00AD\u00EFk\x7Fz\u00956s\x12\u00E2\u008C~\u00DA\x01\u00AA\f\"\x18K\u00AF\u00C2\u00A1.O\u00A1\u00DFF\u00B0d\x12\x10s\u00F0 \u00A8\u0083D\u0099\x16}\u009E\u00DFK\u00B0\u00FBD\u00C4\x00\u00E8\u00E5\u00C0\u00B0\u00C6\u0090\x01\x05\u00BB\u00B8\u00BEr\\\u00FCM\u00ED\u00E6\u00EF\u00CD\u00CE\u0090\u00A8\u00C2\u00EA\x1Egd\u00A1\u00F3'\u00DA\u0084\u0087 \x7F\u00BC\x01\u00F6\u00FEw\u00FFb#\u0086\u0095!|\u00F4\u00FE\u00BB~\u00E1}\u00AF\u00BF\x03\u00BF}\u00F5\u00E5vt\u0095\u00C6\u009E\u00C7:\u00DC\x1F\u00C8-\u00C7\u00FC\u00FC;\u00FFn\u00C4\x1F>\u00DD \u00CC,n\u0092\u00CC\u00E0\u008D\x18\u00C2\u008A\x1ATqF\u00D7\u00A4m\u00C3\n\u00AA\u00A9\n\u00D1r\u00AD\u00B7<\u0085\u00B4\x17l\u00B7\u00EE\x1B\u0083\x1D\u008D\x19l\u00CB\u00FD\u00FB\u00F6\u00EF\u00B1L\f\u00DFp\u00E0\x1Evlp\u00EC\x18\u00D8<\u0082\u008D.\x1E\u00E5\u00CC\u00A4\x16\x04\u0093\u008E\u00E4\"-M\u00D5\x18H\x15\x01Z\u00ABA\u00D4\x07\x17\u00D0\u00D1\u00A4\u00A2\b9\u00D2\u009A\u00D9e\x14\u0081\u00E4\u008ELd\x00Z\u0087C\u00D2\u00B7\u00A1\n\x1D\u00D3\u0086\u00AFB$\u00C3%\u0093\u00C2\u00FBdIG\u00B1\u008F\u00C2\u0086-=\x1E:\u00B7\u00EE\u00CB>u\u00D5g\x16\"\u00A8\u00BC\b>=\x07\"\u008B\u008F\ts\x0B\u00E1\u00AB\u00CF'\u00A2!1;\x12_\u00AC\u00AF8\u0091\u009D\x10[\u00A7:\u00F1t(\u009E\u00E9\u00CD\u00BD\u00AD\u008E\"\u00B6\u00D3\u00F1\u00DB\u00EF\u00DB\u009B\u00C4\u00C4\u00F7\u00E1\u0083s\u00C6\u00A4%\u00FD\u00A6\u00CC/-\u00A6\x1E1\u0099{ET?\u00D3^\u0080vn2\u0081\r\u0089.\u00AC\u0098\u00CD:f\u00C7C\x18\u00BEj\x03\u00FB\x04\u00EE9\x0B\u00A5R\u008A\u00B1FN\x12\u00F4\u00A4J\u00A0\u00C8>\u00C0\u00D2((&!\u00D5\u00C2\u0088\u00DD\u008F\x19.\u00D2M\u00FA\u00BF\x0Bq`\u00B1!dfb'tIq\u00AE\u00A5(\u0092\u00EA\u00CC\x1Dp8\u0089o\u00CCbJ{5Q\x11\u008D a\u00B1\u008Fi\u008Bh\u00FD\u00D7\u00A2\u00B6\u00F6]R\u00DE\t\u00D5\x1Dq\u009F\u0091q5\u0085|\u00DC\x11a\u00FAn,\x04\u0082$t\u009F\u0091\u00BE\u00ED\u00D2\u00ED3\x14:\u00A4q\x06Z\u00E5\u00B9\u0096L\u00B1\u0092\u00AB(\u00A4\u00BA\u0084NC]\t\u0084 rI\u00EA\u00BBb\x06&m#\u009D@\u00DBy\u00B7tz\u00D4y\u00ECo\u00ACC]\u0083Z\u00AF\u00F9\u00BD\u00DFW*\u00C2D\u00EE\u00A9\u00B0\u00C4\"\u00F4s\r\u00E6\x17T\u00887\u00F2\x1E\u00E6\x1B\u008Eo{\u00FAgqz\u008D\u00F3\u0081\u00FF\u00E0\u00FEw\u00FD\u00C3g\x1F\u00DD\u00C7\u0098w\u00D4QDd&\u009A]a\u00D8\x0E\x187iI\u00FD\u00BC%7\u0099\u00D0C\u0087\u00E3\"\u00C8\u00E4\x1B\u00B5A\x00\x00 \x00IDAT*\u00E6\x1A.\u00C2\u00BD\u00A1\x07\x15\r\u00EBz}\u00B4\u00E3\u00CB\u00DF\u00CDGl\x1CJ\u00BAU\u00E4\u00FA\u00B3\u00E6\u00A9!\u00E13|9\u008C\u00A0[\"\x1C\u00A91\u00E9eX\u00DE,^\u00D2B\u009F\u0085z\u00AA\u00F2\u0093\u008C\u0097\x03\u00AF{\x04*\x1Dn\u00B8x\u00F8\u00FB\u00C3F\u00E0\u008B'\u00A1\u00DE\u008E\u00C9E\u00ADu\")/f//\u00C1\u009C\u0091[p\u00F0\u009A9\u0083\u0090\u00E7\u00E9\u00AD\u00B5\u00AAuz\u00F0^B\u00C8\x19\u00DF3\x19\u00EF0\u0091\x04\x16*J]w\u00CC~\u008DS\u00F5\u0089\u00C0\u00A7c:n\u00DC\u0097\x02IP\x7FI\x0E\x1D!\u00EB\u00DA\u00E9V(\u00A9\u00CD\u0083\u00CF@I*\u00FD\u00BE@b\u00D7*%\u0093\u00F6\n\u009A\x1A@\u0096\u0083[\u00DD\u009B\u0085\x18neZfM\u00C7\r\u00F0\x1D\u0098;07\u00F8l\u00C7\u00F2S\x1B!\u00C7\u00DF\u00A6\u00E8A\u00EC\u00A8\u00AD\u00D8u\u00DEu\u009E\x17\u00EE\u00CD\u00ABjK\x05\u0088\u00F4\u00EE\u00D7\u00EB\x1A\u00EDk\u00BA\u00D0^[\u00FB\u00DA}\u00BA\u00F5\u00CF\u00FB\u00F5\u00DE\u00CE\u00CF\u00FB_5Z\x1C\u00B8l\x03\u00E3\u00FB\u00DF\u00F7\x0F\u00CF\u00F4\x7F\x0B!\u00FCy{\u00F6\u00E7\u00FE]\u00BC\u00E7\u00D1\u00AF\u00DA\u00EF\u00DE\u00EB\u00B0\u00B8\u0088zG\x16\u00FAL\x02\x04\x1F\u008B\u00A1P\u0085\u00A44P\u00D27\u00AEY\u00C2\u0099\u00F9\u00C0+\u00D9H\u009F\u00ED\u00E1;\u00D1\u00C1\u00B2\x07\u00A4\u00E5\u00B92\x1C\u00F6\u00C0\u00A9RE\u00D8Fk?@b\x0F\u00A1V7\u00FA\u00C4\x03\u00C5\\\u00BA\u00BA\u00A4>j\f\u008E\u00B6$\u0089\x13\x1C\x17g\x1E\u0085#\u00BD\tA\u00DC\u00D4yi\x1B\u0088JJ\n>\u00F2B\x04\u0094\u0094\u0087\x16\u00F8\u008C\b?\u009Fq\u0097\u00CE$J\u00AA:#\x15u\x1FKB\u00CC\x1C\x05\u009D?\u00CB \u00A9\u00DC\x07\u0097D%\x172X\u00AA1Q\u0088K^\x10!\x02\u00B2E\u00A7\u00AD]\u0089Y3f\x19^\x06\u00C5\u0090\u00B4\u00D1\t\u00C1\u00F7\u00C12\u00EE\u00E9\x01\u00A14W\u0094\u00A3\x10s\"\u009DE\x05\u00AA\u00EFe\u0098;3\u008E\u00F6J&P\u00DF\u00EB\u0089\u00EA:\u00A3T\u00D5X\x1CY*=\u00DB\x10\u00F4\u00E8\u00A1\u00C4\n\x18\x02T\u00D2,\u008D\u0094\u00D3\u00E1\u00C9@\u0094:}\u00E4*\u00F2D%\u00CCjT?:\u00A2\u0080\u00A4\u00BF\x10E\x1B\u00A3;j\u00C3]\u00F6\x07\u00EC'\u008D\u008F\u00F2x\u0098\u00E0\u009A9n\u00DE\u00FB\u00F4\u00A3\u00A7\u00FE\u00BB\u00BF\u00F0s\u00F8\u0089u\u009An1\u0084\u00E7l\x7F\u00E5\u00BF|\u00F8s\u00BF\u00E86~\u00B8\u008E\x0E\u009E*C\u00C5\u00A8\x0E\u00A5\u00CAP\u00C5RB\u00B7\u00E7r\u00D1\u0080\u0086\u008C~\u00DDx\u00A7c\x01\u00BFWVP\u00F5\x0B\u009C\u00C3Z`?V\x02\u00F7$\u00EE\x16\u00FF\u0090\u00C8@j\u0081\u00AE\u00DB\u00E0]e\u00C8qX\u009B\x12\u00E3\u00BF\u00C5\u00F4\x16F\u00D7\x18agnN\x11yxHP\x11\u00BD\x13*O!\x06\x1A\x15\u00A7\x1E\x19\u00AF\u00D5nJ\u00C3\x11\u00D5\u0090\u00C8\x14@\u00B5A\x19\u0086\u008E\u00D2\u00FB\x15\u008E\u009C;(u&\u00D1\u0088\u00DD\u0080\u00DC\u00D9I\x11\u008D8\u00BC\u00DC\u009E-\u00F3\u00D1!b\u00B6\x1Ce\u00E4^h\u00B1\u00B3\r\x0B\u00C2\x0E\x1E\x12\u008B0\u0092\u0098|\u0089\u00A3\b&`\x00fTnj\u00AE\u00C1n\u00EB0\u00F6\u00CFip\u00D5\x18\x143\u00A1\x07\x11\f\u00816\u008B\u0084\u00DE\u00FC\u009C\u00F5\u00B7\u00C3\x19\u00E2\u008Cb*qi2\u009Ae\u00D3\u0099\u00CC\u00C2\u00CD\u0089F\u0096Ws\u008B\u008E\u00E4\u00C6\u00AB\u0084\u00ED\u00D3\u00B1Z\u00F8y.K\u00B1+\u00DE!\u0093\u00962\u00B0J6\x01^\u00DF\u00C2\u00AD\u0093\u00DB\u00FB\x01\u00CCKk\u00B7\u00F5#!%\x10\x1B\bKl\u00B5\u00E8Z8*J\u00F1\n\u00C0\u0084\u009B\u00E3x\u00F7\x13\u00BFh\u00FF\u009E\u00BD\u0082\u00D3\u00EB\x16C\x00\u0080\u00BF\u00E0\u00DF\u00F5\x0F>v\u00F9\u00FF~\u00F8f\u00D7\u00CD\u00A5\u00FF\x17\u00A1\u00E8e\u00F2\u00DF\u00B3F`\x11\x19\u0089\u00C4\u0080\u008A18C 0\u0083\u00F2.\u00BB\x02=\t\u008B~\u00DF\u0091\n+\x17\u00C7\u00D2E7\x1E\u00CAJ^5\x1D\u00A4N\u00C4\u00C4\u00DD2&.\u0086I\u00B4\u00F6;\u00E3\x11S\x18\u00CB1Y\u00B6\u0095\u00C9\u00E7,2\u00F8h\x1An\x1ATO\u00D8\u00EC\u0096\x06F\x00\u00CCh\f5@\u0086\u00C0L0\x02\x16\x03\u009A\b\u00C4dg\u0090\u00AE\u00CF\u00B5\u0093\u00C4\u00E4\x15\u00B9\u00E8It\u008C\x18\u0099u\x1D\u00846\u00DA\u00B1@3\u00B1\u00FD\u00DB!\x15\u008A\u008B.\ri\u009C\u0081m\x063\u00BF\u00C0\u00B1\x13\u008EOg\u00D19\x0Fu \u00D9*\u0089=\x19\x1Bp\x19\u00C0\u00CDw\u00BE\u00FD\x1F\u00E0\u009F\u00E0\u00D6\u00EB\u0096\r\x01\x00\u00FE\u0093\u00FB\u00EF\u00FD\u00D8\x07\u00E6;|\u00CCU\u008F\u00AE\b>\x12ZfE\u008E;\u00DE\"\u00C0~\u00AB\u00B3M\u00A1\b\u00AA\u00AE\u00DB\x11[\u00D2K\u00AF:\x13&JE\u00A0\u00B1/\f~\u00E2\u00EC\u00D4\u00B1ny\x10\x06\u00A2tv\u00BB\u00FF9\u00FE u\u00C4\u00DB\u009E\u0084*\u00F4\u00D2\u00DA\u00CB{\u00C6;\u009F\u00E74\\(\u00D9\u00F5\u00CC\u00F3;\u00A5c\u00EA\u00CF\u0093L\u00C1\u0095Oa\u00A9\u00EE$\u00E4\u00EF\u00C2Az\u00BD\x17\u00C1\u00CF\u00A3\u00E9\u00E6\u00A9\u00DB\u00CB\u00E6@\u009B\x02\x17N!\u0096B\x1F\u0093\u00E7\x1FG\u00BC'\u00EB#\u00CAF0\u00B3-\u00ABX\u0089n\x0F\u0098#\u008D\u009D\u00C1\u008C\u00C8\u0090P\u00B6\u0082 \u00A2\u00F8\u009C\x138\x0Ek}\u00D4\u00FCx\u00DA=\x0E\tH\u00BD\x1D\u00CB8\u009C\u00C6\tsh\u0093\u008C|{\x12\x1B\u00EEx'w\x03\u00AB\u00E1\u009E\u00D4\x11\u00CB\x18\u0093e-S\u008D\u0090g\u00A7J\u00B9\u00C5zr\u00A1S\u00DFB\u00D27;\u0081\u00B9\u00EC\x0E\u00D7\u0080_\x03\u00F3:\u00EC\x15\u008B\u00DE\u00AF\u00B2\u00EE\u00ED\u009D\u00F7\x1E\u00ED<}\u00B2\x1D\u00D9\x07\u00E65l\u00B6\u00F6}\x0F\u00BA\u0090\u00DD\x0F;l\u00EEp\f\u00DC\u00BC\u00E5\u00CA\u009F\u00F9o>\u00FC\u00B1\u00BBh\u00FFN\u0084\u00F0A\u00DB~\u00F7\u00BF~\u00F8K\x1F\u00FFW\u00FE\u00D5\u008F\u00CC\u00A5nA\x10\u00AEe\x0EB\u00B9%m!\u00B23\f/+\u00FDZ\u00DB\u00E0,\u00F5\x19l\u0094\x04\u00DC\u00EB&\u00A2\u00A1\x00\u009D\x1B&HG\x11\x11 \u0097\u00A6\u00FA\u008D\u00ECWff\u00BA\x173XB\u00A9\u00FB8\u00D1\u00EE\u00D3\x19K\u00EF;\u009A\x0BO\x12&\u00A4\u00CD\r3\x07':J\u00B0\u008A\u00CEu\u00E0\u009C\u00C9\x18Q\u0088\u0094\u00F2\u00D0o\x11\u0085\u0098\u0082%\u00D1E;N\u00E2\u00A9\x00$\u00CF\u00F6A\u00C4\u0090:\u00F3\u008C\bFg\x00P\u00EE\u00FE\u00EC\u008C\u00E4\u00F3\u00AA\u00BB\x10\u00B6\x03/\u00CF\x01\u00CA\u00D87\u00E0\u0090{V\u0099\u0091@\u00FB\x1B\u00CA\u00B3@Ju\x17\u0082\u0090\u00CA\u00D2\u00E6m\u00B4\u00B9\x03\u00D1VO\u00BA\u0082\u00AB&\u00A4\u00B7\x18\x05e?\u00A2\u00A9\x1D\u00D1`\x0F\u00DB\u00C6\u00F2\u00DB\u00E9\u00D8<}w\u00F0\u0081\u0090\u00C1\x1B#\x0F}T\u00C9x\u00D9\r\x14\u00A3 \u00AEE\u008B\u00BFv\u00A7\x06c*\u00EAw\u00D9\x11\u00C8\u00B4R\u00FA\u00CB\u00BE\u00E2\u0088HJM\x16\u00E0SnI\u00B95\u00E3\u00D9G\u00ACB<\u00D0r[:J\r\t\u00E1\x1A\u00DB\u00BC\u00D5\u00F6\u00F06\x07\u00E6\u009Fz\u00FA\u00E3W\x7F\u00E5\u00B9\u00DF\u00C5\x1D\u00AF;\x19\x02\x00\u00FC\x00\u00DE\u00F9S\x1F\u00B3\x7F\u00FD\u0091\u00AAfUDy[\u00C2\x07\u0087\u00B4\u00D4\u00CBA\u0082\x04:\u0087\x1DY\x7FQ\u00EDm\u00D9\u00AE\u009F\u0099\u00C1be\rh;{{I\u00DC@VC\u0082\x01v\u00F2\u008E\x18\x00\u00A2\b=\u00E0\u00DB\u00DB\u00C1\u00F7\u00B2pg\x15\x01\u00D5Vg^\r\u00A2NJ*\u0083\u00D5\u00A2\x02p\x03\u00C7\r\u0089T\u0096{\u0085/\u008B\t\u008CR7\u00C38\u00D7\bG>{\x05\u00FA\fG\x06\x0B\x01\u00F1\u00DB\u0085\u0084\u00B4\u00CFb*N5\u00C3\u00F8\u0099q\x0B@\u00EA\u00F5\x1A\u009C\u0098\u0098\u00F4v\x19\x1F\u00BB\u00F1o\u00BAs\u0099\u00D5\u0098\u00C3U\u00CA4m\u00AF1\u009B\u00CF\u00A62 \u00F5~#\u00C3\x19\u008C\x19\x18d\f\x19\u00FC$\u00E64G\u00AA\n@\u00AF\u00CD\u00C0\x152\u0095m\u008A\u00AA\u00CE\u00D4\b\u00BE\x04\u0083\x06\u00D9\u00C6\u00AAx\u0085\u00C6\u00BC\u00CE\u00E7d\u00ECB\u00DA'\u0082).\u00A1\u00D2\x13\u008D\u00B9lM\u00AD\u00F0\x12(\u00F9}\u00AE7\u00E8\u00AEE\u00D9 \u00A4\u00DFg\u00CE\x01 [\u0081)\x122C\u0093\x072E[}N\u009BF\u00CF]\x10zi\u00CC\u00C2\x01\u00C7\u00C4\u00FCw\u009E\u00FA)\u00FC:\u00EE|\u00DD\u00A92\x00\u00C0\u008F\u00DE\u00FB\u00E0O}\u00F0\u00E6-\u00BE\x10\u0081`\u00B3 \u00CCbl$l61\x03\x11<\u00DF\x19\u00C0\u00D4a7\u00BB\u00E0;\u0099A\x18\x11\u00ED\u00D69\u00E7p\u00E9jG\u008B#N;K\u00F2\u00DEO;\u00FD^\u00FD\u00B1\u00E5\x1A\u00AC}\u00EB\u00EA\u0092\u00EE+#\x1E%SE\u00F9\u00A1`\u00EB\x04\x1EM\u00C7\r@\x17\u00A1\u0098\u0080K\u00FDL{\u00D4\u00CC\u009C\x16K\x1B\u0083O\u00C3<,az\u00BEy\u00CC\u008F\u0080\u00F5B\x1D\u00F9NhO(~4\u00F5\u00E1\u00A0\n\u0090\u00AA\u0081G{\x07\u00DD\u009ErW\u00EAw^{L\u00F0\u00BE\u00C5\u00A0\x0E\u00DA\x1Az\u00DF|:\u00D5\u0085~\u00CC\u00B8e\u0081T\u008F\u00F35\u00D5\u00EF\u00EE\x02\u009D\u00D3\u00DB=J]\u0099\u00AE~G\u00BFr\u00D76\u0097:ABey\u00B8\u0088\u00AD\u00A8\u00DFJ\r\u0093\x04\u00D6\x066\u00BC\u0096\u00EB\u00C9\u00D4Tz]\u0096\u0085F\u00C6P\u00AA\u00A6\u00DDrU\u0096*\u00E0R\t\u00F2-\u0098\u00AF\u00BF\u00EFP\u00B9\u00FD\u00B4\u0096{\u00DBrUN\u00B9\x14\u00AF\x01\u00BF\u00C7\u00F75\x7F\u0097\u009BQ;\u00A0E\u00B1\u00A0\u00D7\u00DF\u00BE\u00F93\u00FF\u00C5\u009F\u00FD\u00A97 \u00FB7F\b\x7F\u00DA\u00EC\u0085\x1F\x7F\u00FDW~\u00F9_\u00E0\u0095\u008F\u00C2YJ\u00AAy\nn\u0085\x14\u00B7\u00FA\u0081\u00E7\u00A2$\u008A:\\#\x1D\x01\u00E9\u00EB\u00B3\u00B9\x0B\u00D3H\t\u00B9\x07\u0085 4I\u008Ct\u0084\u009E\u009D5\u00A9/]\x0B\u00AD\x0F@\x1A\x18\u00D1\u008E\u0091)\u00DC\u00AE\u00C3\u00B8A\u008F>$\u00A4T\x0B.\x07.\x0EA\u00D9\n\rnp\u0094R\u00F6r8\x0Es\u00CC9\u00B8\u00CFb\x15AI\u0084\u00C0\u00CB\u00F2;%|W#F;\u0096\x05Mx\u008D<\x12\x12|K*q\u00EB\u00A3\u00DC\u0097F\"\u00DCH\u0080\u0092z\u0087\u00EE\u00D5\u00AE-\u00A3=U\x01\u008D\x1F\u0092\u00F8H\u0097\u00A190\x19\u00DA,dQ\x11\u00C0U\x02\u00DE=\"\x13\u00D30*\u00F4\u0091\u00F7\x1F\x10\x021_\u00C7\u00BCTt\u0086\u00B3\u00DC\u00BDW(\u00F4\"\u00F5%\u00A9\u00DB|\b9,\u00A8\u00A2\u00A9*\u0089\u00F0|}\u00B62\u00C0\u00E6\u009C\u00B6\u00B61\u008A\u0091\u00A4\u00D1C\u00AE\u00C7\u0086\x0E\x16\u0086R\u00D0$\u009E\u0097\u00D0\u0085\u00AE\x15\u00E4?\u00A0\u00DCu\u00CF\u00FCu\u00F5O\u00E8ChH.M\u00A1W\"\x03\u00C5\x04\u00F9\u00C4\x1C\u00F7p\u00F3\u009DW\u00BFl\u00FF\u00ED;_\u00C0\x1B\u00BC\u00DE\u0090!\x00\u00C0G\u00ECO\u00FD\u00DD\u00BF\x7F\u00F3{\x1F}\u00BC]\x16\"\u00AF=\x12:q\u00F5c\u00C5\u00D9\u00AA\x0E\u00C0*\u00F5\u00B3\u00E8\u00E8\u00A9\\\u009B\u00B6\u00DD\u00AA\u0088\u00C0j#\u00A7\u00B1\x0F\u00B4\u00DF\u00FF.$\u0090v\u008B\u0095!\f\x17\u0091\u009FQAj[q\u00EF\u00BE/E.\x12\u00AC\x0BD\u00D0U\u00DFy\u00F8\u0082\u0081\u00C3A\x03c\x04\u00EF\x1C$\u00AC\u00E9U\u009D\u00C8QD==\x12j\x05SwJho\u00E7ed\u00A0W\u00E6\u00E3\u00A51\x0F\u00E88\u00FD\u00FAJ3\x16\u00C1\u00F7\u00A8FL\u00CE\u009A$hk[\x0B\u00FF\u00A0\u00E7@%\u00C2&G\u00E8\u008D\u00C8\u009D\u00E3rxf:b\x02\u009BE\u00F4\"\u00FA9\u00C9\u0080\x14\u00EBPm`\"c\x17\u00E4M\u00E8\u00CC\u00AD\u00CF\u00BDP\u0095\u00C6\t1D\u00AC\u00E3[?m\u00B5\x1B\u00DCq\u00CE\u00CA\u00ECQ\x04\u00B8x2\u00B8fRU\x00\u00B2&\x02\b\u00D1U\x1C\u008F\u00B1\x07\u0091'b\u00A8m\u00DF\u00FA\u00F5z\u00C8\u0082\u00FD:F\x18\u00E4\x07\u0096\u00ED\u00E0 \x15aba\x10d\x04A?\u00CC\u00A6\u00E4\u00E0|8\u00F0\u00DD\u00EF\u00F8\u00BB\u00F88\u00DE\u00F0\u00F5\u0086*\x03\x00\u00FC\u00A7\u00F7\u00DE\u00FB\u0093\x1F\u009E\u00EFx\x18\u00C4Qq\b\ti8 opz\u00F8\u0086\u00D1\u00AC\u00F4+\x1C\u0097\x0E\u00B4\u009F\u00DA\u00D3y\u0081\x16n\x1B\u00F1h\u0094LuE\u00CFF\u0088A\u00D1]c=\u0097\u0086\u00C9\u00DBpl\u0087\u009B\u00FA\u008D\u00EC\x03\u00D2h)\u00A4\u00D1l\x1Cm!\u00F4\u00A2\u009F\t==\u00D4\u0081\\\u00B03\u00DCv\u008F\x0E\u00C3\u008Dw\u00CF\u00C2\u00EA%\u0098h\x7F\x0B\u00E6;\u00D5\u0081YB'\u00ED\x10\u00B3\u009D\u00D7>/^P^P\u00DB\x1D8\u00E6\f\u0082\x16\u00C3Q{\u00BA\x7F\u00FB\u00EE\u00ED\u009E\u00A1J \u00A3\n\u00D3s\u00A0hH\u00AA\x15\x19U\u0098\u00D0\u009Fj\u008FGM\u00C9\u009B\u00D6\u00DF\u00F3\u00BB\u00E6\u00C4\u009AJ\u00C2m\u00D4\u00BDy7\u00BC\u00F7\u00B7\f\u00C8a\u00E0l\u00A5\u00E7\u00F8\u00EE\x04\u00EEd\u008Cg\u0086\u0082~\x1C\u00ED\u00B7\u00E4L\u00BE0)\u009D\u00B3\u00A8%\u00C9\x14\u00F8\u0096-`^#\u00EA\x1AF\u0084\u00A2\u00F9\x06\u00CC+\u00B8\u0087\u00F5\x7FQ\u00A53\u00E2\u00F1\u00A4\x0E\u00EBxF4n\u0080\u00BC\x14\u008A\u00AA<\u00AB\"\u00E9\u00B9 \u00CAV\u008A\x01\u00D5\u008C\u0087\u00DF\u00BE=|\u00F6\u00AF\x7F\u00EFO~3\u009A\u00FF\u00A6\f\u00E1\u00BB\u00CC\u00BE\u00F2!\x7F\u00EB\u00C7`{K\"\u00A2\u00F1P\u0095\u00833\b(\f\x19\u00D3\x00U,\u00AAP\u00A3u\u00A0\u00B2H\x1BTL\u00B5\u00D0\u00831\u00F6 \x02\u0087\u00C2]\x02l\u0084\u00AD\u00BC\u00EF8\u00D9#\\L\u0083;K\u00A5j\u00D1\u0099\x00\u00F2\u00F7^\u00E8%\u00D3\u00A5q\u00DB\u00FB\u0091\x15j\u00B5\u00C8\u00A6g\u00DC|H\u00E30\u0092i\u00B1\u0098\u00BE\u00F3Ca\u00BF\u00C7\u00F4 X\u00EF\u00E1\u00C5\u0080\u00C2\u008E1'\u00E6\x11\x15\u0096/\x13\u00B418\x0E\u00BE/\u00D4\u00EDU\u00C2_\x06\u00CA\u00EE\u00A1\x10\u00B1\x1E\u008D\u0080\u0093\u00A9t[@cHB\x1E\u00E1Z\u009C\u00D0\u00FE\u00C1\u00D3\u008D\f\u00AAl\n\u00EA\u00B3\u0098\u0095\x18\u0090\u00B3\u00E0\u0090\u00BE;\u00EF\u0083\u00A3\u00C6z\u0099\u009EnWW_$\f\u00B3]\u00B5QL\u00A2\u00E6O\u008C\u00C1\u00E9\u00A2\u008Dy\n\u0082\u00ED;\\\x05u\u008B\u0088+l]' \u00E3y4qFA[\u00BB\u00A2ibi\u00D0\u0093K\u0093}\u00CDm\u00EC\u00B5\u00EE\x16w+\u0088^\f\u0098#\x18\u00C1\u00B1\u00F1;\u00D5\u008EcPE\bB\u00CF\u00CD\u0088f\u00B9+\u00FD\x0E\u00B7\u00A5\u00DE>7\"\x0EC\x0F[\u008E>\u00D0\u00A6g;\x06\u00AE`\u00B6\u00C3,\u00B6]\u00F4a\u00C0{\u009F\u00FE\u0098}\u00F4\u00C1W\u00BE\x19\u00CD\x7FS\u0095\x01\x00\u00FE\u00CA\u00F5\x07\u00FE\u00F6O_\u00FE\u00CD_\u00FD\u00F2\u0095f\u00B7$wF\x1D\u009E\u0092\u0084\n~\u00F7\u0097\u0091\u00E8\u00B68\u00F5\u0096\x1A\x11\u00D7\u00CC\u00A4\u00A8R\x01\u0094*\r2\x1B\u00E49D*M\u00ED\b\u00A6}R!h8\u00CC\u009A\x04@\x12\u00FF\u00BC\x15\u00AFP\x0F\u00DB\x05Y\u00C5\x10\u00A8:\u00C8\x00%\x1D\\\u00D0\u00B9K\x0EG,\u0080\u00C7\x1E\u00BBCk\u00D7\u00E8\u00DD=k\x1B\u00CE\x19\u00FBB\x0E\u00BA\u00B8X\u00AEcI.\u00F2l\x0F\u00F2D\u00C59 \u00F4O\u0083\x19\x16U\"\u0089APZ\u00C7f\u00D9$\u00B2\u00BF\x13\t\u00A5\u009Djk\x1E\u00E3l\x01\u0080\u009B\u00A0i\u00CC\u00E8\u009C\u00C8=\x1A\u00A4\u00EF'\u00CC\u009F\u00B6\u00F6\u0093\u00CDHmI\x01-\u00FB\u0084#\x03\u0092\u00A4\u00C2H\u00F5H;Bs\u00D3f\u00FD\x05G\x1Av\x0F\u00D9r\u00A0:\x13~z>\u00D5\u008F86\u009A\u00A4oCms^\u0093\u00DF\u00D4\u00A8\u009Cs[\u00ED\n\u00D3s\u00BE\u00E3\u00D2\r\x19\u00D7\u0090\u0081G\x1E\u0084O.S\u00D5\u00A0f[{\u00EC\u00A07\u009AKw\u00B8\u00D4\f\u00A9%\x13\u0085\u00D69\u00B1T\u00DE\u00CA\u00E2z\u00C1\u00E3\u00AB\x1B\u00F8\u00BF\u00FFm\x7F\x1B\u00BF\u008Co\u00FA\u00FA\u0096\f\u00E1/\u008F\u00A7~\u00EE#7\u00EF\u00FC\u00EC\u00CF\u00E0\x0B\u00DF\u00D9\u0089\u00BFB\u0090\x15\x04\x04\f\u009C\x19\x02\x7F\u00A7\x04w%\x17%0\u00E9\u009F\u00F2\x18P\u0085PI\u00F4\u00D9\u009E\u00D6\x1B\u00DA-Z\u00FEB\u00DA::\f\u00B3\u00AC\\\u00E4\u00FDZ\u009C\u0083\u008D\u00F40\u00F5p\u0083\u00B0\u00B3\u00BA\x10\u00D0\u00A4\x0BO\u00F5R!\u00D2G,\x1F\u009F\x03\u008F\u00A7\u00E3\x06e\u0080;\u00DC\x18\x05\x18\u009Bt\u00D9\x01\u00EC\x13\u0094\u00CCqMU:\n\u00A9X\u0099\u008B\u00B18\u00E6\u00AC\u00C2*e{h\u00BA8U\x16K\x1Ff[\u00B8\u0094\u009C\u00C6v#Z\u00B06\u008C\x15\u00D2\u00B0\u00C9(B\x032C\u00E3\u00E4R3\tK1\"\u0080FB\x16f\u00E1\u00A9\u00AA\u00C4l@\u00DA3z\u00AD\x05w\u00CD\x01\x055\u00C7\u00A5\x10\u00EA\u00CA\u00DA\u008C\x1B\u00AAv\x04\x10\u00C7\u00D3\u0095\u00AAq\u00A3\x13\u00AC\u0097\u008A\u0090\u0084^\u0084\u009BL\u009F\u00EDed\u00A3\x18Bc\u00AAu\u008D-mZg\x06\u00B3\x11\u00B0\x03\u00ABZ\u00A0\x10dU[\u00AE\u00B9L\u00A9C\u00FB@\u00C6)\u00CC\u0081\u00AA\u00D1\u00A02h\u008D\u0089\u00B86wU5%\u00B4\u00DF\u00C4\x18\u00AEp<\x7F\u00FD\u00D9\u00A7\u00FF\u00A7\u00E7\x7F\x0E\u00FF\x1B\u00BE\u00E9\u00EB\u009B\u00AA\f\x00\u00F0\u00B4\u00D9\u00FC\u00C8|\u00EEo]\x1F\x01Q\x12\u00CE/\u00C4n\x18\u00BDNA\u00B2\u00C8P\x11\u00A2\x12\u00B1&\u00D4\u00DA\u00EF\x1A\u0082\n\u00B1m\u0091\u0081\u0088\u0088kp\x05\u00E0\u00A7\u009A\u00D0\u00F4\u00AE\u00B4\x1D\u00F0\x1E\u00CE\u00F3\u0096~\u00C4\x1D\u0082\x118f\u00E2\x0F*4\u00BEg\u00D4\u00D9\u00F2\u009F\u008E\u00F9Z\u009A\u00AC\u00A2NipL\u00A9\u00D1\u00E3\x10h\x01\u00A1;\u00EB\u00E2\u008EG\u0097\u0089\u008B\u00D4\u0080\u0093\u00CA\u0090P\u009Cn9\x1C\u00A5\u0093w\u0097\\@\u00E6\u00E6\u00AA\x13\u00FCOH\u00ED\u00B4\x1F\u0094}\u00E2\u00E2H\u00DD\x7F\u0085\u00DD\u00D4\u00DF\x1D\u00CD\u0085\x17\u00EE@EX\u008A\u0081\u00F5\u00FBkM*\x1AR\u00EE\u00D3y\x04\u0084?\u00A8\u00F6\u0094\u00AB\u0092\u00EA\u008A\u009F\u00FA\u009B}C\u00DA\u00CB\u00CE\u0091\u0089]\u008D\u0088\u00EF\u009E.V\u0085y\u00CFv^Fn\u00CA.\u00E1\u0096c\u00C5a\x01\u00F9\u00C5m\x14\u008F\u0080\u00CElPB\u0080j\u0080\x1D\u00FA\u00EE\u008BJ\u00D2\u00F1o\u00DA\x0E\u00C5\x00L\u00EB;\u00B8M\u00AA\x18\x13\u00E5\u009A\u0094^?\u00B7\"\u00F8)w\u00A4\u00D4\x04\u00ED4%\u00D5A\u00E7m\u00B0\u00B977\u00E75lR\u00A5P\u0096\u00A4m\u0080\u00B2\u0091m\u00C0\u0087\u00E1\u00D1w=\u00F1\u00B7\u00EC\u00DDU\u0094\u00EE\u008D^\u00DF\u0092!\x00\u00C0\u008F?x\u00DF\u00DF\u00F9\u009E\u009B\u00B7?,\x12\x161vC\u009F\u009D~\u00BB\u0082\u00FB\x0EW\n\u00F4\x1D\u0086\u0093\nF\u00EA\u00BA\u00BE8\u00EA\u00C9\u00D8\u00B2\u00F8j\u00E3\u00DE\u00A6{\u009F\u00DD\u008E\u00A8{\u00DA\u00E9\u009E]=\u00A9\u00FEJ5)\u00A2\u00EF\u00D24%\x0F\to\u00958\x12%\u00A0O[a\u00BA\x00\u00A8\x0F?\u0086\u00E1\x11\"\u00E6\u00FFp\x11\u008Dt\u00FC\u00B1\u0084!\u00CB\u00B7~\u00D1Bg\u00A8\u00F3b\u0094$\u00A38\x1C\x19\u0097p\x1CE 3u\u00FA5\u0094Y\be:\u00D5\u00E6\u00C6h\u0082\u0090*m\u00BA\u00EE\u00AF\u00F3\u00C2\u00C8\u00B8\x18&\u00F3\u00FA\u0095a-\u0084\u00DD\u0098[o\u00FB\x1C#\u00B1\u00F4\u009F\f\u00A9\u00DBJd+\u0088\u00A9/uj\u00E6\u00EF\u00EDoh\u00BC\u00B4\u00A7\u00F07x\u0095\u0099\u008B\x07\u0086\u00E5\u00B7\u00C5\u009B\u00C0\u009BIUY\x10\u0083\u00C8\u00CA\u009D5\x1B$\u00B1\u00F5\u00AEPmE\u008E\u0096\u00910\b\u00DB\u00E7\x06?\x18\u0082,C\u00A3\u008C\u0082\u00F9\u00EE\u00EB\u009E\u00B6\u0083\u009E6\u00ED\u00BAFo\x1A3q\x05\u00D9\x12\u00E0;\x1E}\u00FB\u00FE\u00F0\u00D9\u00BF\u00F6\u00A1\u00BF\u00F3fh\u00FD[\u00AA\f\x00\u00F0A\x1B/\u00FD\u00F5\u00D7>\u00F9\u00F7\u00FE9\u00BE\u00FA\u00DF\u009F\x0B\u00A3\u008C;\u00F6^\u00C8\u00ECC\u00EE\u00F8\u00B4\u0086 \u0087\x14\u008E9\u00ED\u00A9\u00D2[\u00D9\n\u00A42\u00C0\u00A8:\u008D<\x1E\u00BFm|v]E8C\u00FF^\u00BB@\u00CF\u009F\u00AA\u008B\u008EY\u00FBu6i\u0081\u00A6G\u00FBz\\a\u00B3g\u00BD]\r*\u00DC\u00B6*\x00\x01\u008F\u00CC\"\u0094\x19\u0086\u00CB\x04vI\u00B9i\u00B5A\u00AC\u0087\u00F1m\u00D3\"d\u00CFv\x07z\u00D5\u00E1\u0088;\u00A8\u0084&\u00A1\x13\u009F\u00EB\u00B6lZ\u00E3\u0087G\u00A8o\u00BA#\u00D9\u00BFHk\u00B6$\x06\u009B\u0081\u0086\u00E4\u0096\u008C\u0094f\u00A2\x1E\u00B6\x0B\x04mt\u00FD]\u0084\u0092\u00FB\x1A:\u00FB\u009E\u00E8)'\u00BF!\u00AA8t\x00-6A*R\u009D\u00A3B(\u0080e\\B\u00CE/\u0090\u00E3U\u00FF\u00F4\u009B!\u00FA8\u00C8p\u00C0\u00F6\u00C11\u00AEj@t\u00CE\u00F9\u00BB\u00EE\u00DD\u00ABUk\u008E\u00D3k\u0091s\u00A6\u00E7oy\u00AC\u00E7\u00B4\u00E4\u00B2\u00E8\u00F7\u009A\u00DA\x12N\u00C2\u00D49_\u00E2\u0098\x1Bl\x0E8\u00EB5z\"\x1A\n?fP\u00AArs\u00C6.\u00A4RF\u00F5.V+\u00DC&.\u00EF\u00BF\u00F7\u00F7\u009E\u00F8\u00CF\u009Fx\to\u00E2\u00F5\u00A6\x10\x02\x00\u00FC\u00C8\u0083\u00F7\u00FF\u00CD\u00F7\u00DF<\u0085\b\fVRQW\x11\u00A2C\u00DE\n\u0099\u00ACII\u00F5\u00D9\u00A3\x0E3\x01#\u008D&N\u00FA\u0097~\u00DF#\x1D{\br\u00B7\x13\x14\x17U\u00BF\u00AA\u00BE\u0082\u00F3\u00DF\u00D1\u00EE\u00D9\u00E2#\x16\u00CE\x0E41T\x0B\u00DEyXPu\u0091,@F\u00BFI\u00C5\u009B\u0088\u00AD\u00C7\u00F8\u00FD8\u0080\u009B\x19\u00EFC\u0089m\u00CDr\x1FR\u00D3R\x15\u00C9\u009C\u0087\u0094\u0098k\u00F4\u009FP\u0080\x13\u00D2V\x04\x1Fc\x1E\x1C\u0098\u0097RC\u00E6,(/F2\x19A\x18\u00EB\u00D0Jb\x1F\u00CA\u0083@F\x18\x1E\x07\u008B\u0096\u00A8\u009D\x03\u00B7\" \u00FD\u00F0j\u00CB;\u008C/\x17h\u00CE\u00A5\u00BC-\u00BE\u00BAC\u0085~\u00D2\u00BD\u00E9B\x1D5\u00B7\u00D3\x03a\\\u009A\u00E7\u00A4\u008F\u00CD\u0081\u00F4\\4 \u00B0\x18g\u00B1\x100\u009F\u00D7\u00AC\u00AC\u00C7s\u00BD\u00C9d\u008Ah\u00F8\u0092\fd\u00AA\u00ED\u00E9\u00CB}t}\u00A8\u00A3\u00DE:'\x06\u00D2\u00EA.\u00CC\u00EEy\u0090\x0B\u00F1\x1A\u00E6\u00D7Eg\x1E\u0095\u00CA\fJ\u0096:#k\u00EER\u00ED\u00FCN\u00DAx\u00F5\u0099k\u00DC\u00FF\u00D1\u00F7\u00FC\u00CD7K\u00E7o\n!\x00\u00C0\u008F\u00D9\u00D3\u00BF\u00F1W_\u00FF\u00C4?~a\u00DE\u00FC%\x1BgO\u0082ES^\u00F6\u0085\u00D0\u00C5\x03\x19\u00A4z\u0095\u00E8\u00A1\u00A9\x19D\x0F.\u00C9\u00D2\u0083\u008AT\u0084%#\x19\u00CF\f&\x18R$p\u00F4k\u00FB\u00EB\u00B6\u00E1Pq\x0E2\x02\u00F6\x12\u00E1\x19\u00BF\u00DE$\u0095\u00A4V\x04\u009E\u0085\x14\u0088`\u0098Z\x1C\u00A5n\u00B4\u00DCz\x18\u00C2\x1B\x11\u00DE\u0086\x0B\u00DF74,\u00CE\u00C9uC\x1D\x1A@\u00A9'(\t\u00D8%\u00B2\u00E0\u00B4\u00A4a\x1A\u00D3\u00DA\u00F7\u00F4&L\u00CB\u00FE\u00A9M\u00B5\u008FI\u0097)\u00BF\u0087\x0Bn4\u00A4TFC\u00ED\u00D1\bXz\f\f\u00C1%g\u00DAR\u00A2\u008C]&?9\x18x\u00E4u]RL\u00A1\u0085\u00990\u009D\u00FD\u00E4\u00E7\u0098\u008D\b\u009Bd\u009Em\u00ECzV\u00D3#ZQ\x06[m\u00A7&/P\u009FG]\u00A7<\u008F\u0090\u00FE\u0096\u00EDg9\u00B6Y\u0092\u00BE\u0090\x04\u008A\u00D0i[\u00B0\u00BE\u00DE\u00D2\u00B8\u00A8\u00F9+\u0086S\fA\u00CC\u00A0\u00AFQ\u00A9\u00C9\u00E2\u00C4\u00E2nz~jw\u00B6s$\u0081,\u00C7\x11\u00D6\u00E2cY\u00C0\u00F6\u0081\u00ED\x1F_\u00FF\u00CF\u00DF\u00F6\x1Bx\u0093\u00AF7\u00CD\x10\x00\u00E0?\u00DB\u00DF\u00F7\x13?{\u00F3\u00D5\u00BF\u00F4\u00D5{\x05M\u00E2E\u0097b\u00D6.\u00E8jD\f\u00C8\u00AC%'5\x17\u008A\u00AC\u00C1\u0090\u00F1\u00F0\x1CD\x04$\u00F3\u00A80\u00E5\u009E\x04E\u00E6c\u00AA\u00B0\u00DC_2\u00FEu\u00B7(\u00EF-\t\x00\u0084\u008E7\u00FB\u0083m\u00C4\x02-@\u00BF\u00E3\u00FB\u00AA>\u00A4\u00CB\u00AF?|\u00B6\u00F3\x18\u00C1\x14\x1E\x1C\x01\u0095/\u0088<\x07\u00A3\u00CF_\u00D6\u00F1\u00D4\u00A3\x1B\u00F1az\u00EE\u0087xq`\u009B\u008E\u008B\u00DC\u00A2\x1E\u00A1\u00C088#\u00B3\u00AEs\u00AB\u00FE\u00C8\u0095\u0089\u00C9\u00DD\u009C\u00DCr\u00BE\u00D4\u00CE\u0098m\u0083\x16W%\u00E75:q\u00A2\b\u00E5jJ\u00AD\u0088\u00F1O\u0094:\u00A3\u00E4\u00A0,\x18\u00CB{\x1Cd\u0092\u00C1P\x18\u00AB\u0092\u008C\u00AC\u0092\u00A5\u00AE\u008EZa\x07}\u00FC\x06\u0086\\\u0093\x01\\<\u0098\u00D5v\u00A86eA\u00FB!\u00BF?j\u0099\u00CA})\x0F\u00CC\u0098\u0094\u00FE\u00C9\x04\u009D0\u009D\u00CF]\u008C \u0099G\u00FB{A\u0091d\u00A8\u00CD\u00D8,\u00A6\u00D0\u00ED\n\u00B9\u00BC4g\u00BC\u0097\u00EADD?\u0085\u00BA'\u00B2|\u00FA\x042\x14Y.\x1BeWB\u00A8@\x0B\u0091\u00DE\f\x00\u008F\u00AE\x1E\u00C3\x7F\u00E8\u0099\u009F@\u00EE\u00DC\u00F8\u00AD_gq\u00FAM__p\u00B7\u00FF\u00F1\u00E1\u00BF\u00F8\u008D\u009F\u00BE\u00FF\u00F2\u0087c\u008EE\u00A8\x1D\u008E\u009F\u008Cx\u0092\u0094}#\x14\u00D9\x03\u00BAo\u00F5\rK\u00A2\u00A3\u00CEK/\x02\x11\x01\u00CF\u00A9\u00A8\u00C8\u00AC\u00AF\u008B\u008E\x04\u00EA\u009ChK\x10/\u0082\u008BJ:\u00A0\x11\u00B3\u00A4d\u00D7\x19\u0081UZ\u00A9\u00A8\u0088\fG\u00E5\x1A\u00E4\u00EF\u00ED\u0081\x0E\x07\u009Eq\u00E0-\u0087\u00E3\x01\u0080{0\u00DC\u009F\u00C0\u00B5\x03\u00F7\u008E\u00B0\x15\u00EC\b\u00F7\u00DB\u00EE\u00F1\u00B9\u0091HwJ\u00DC}rvf\x10\u00C66\u0099\x10>\u0083I\u0084W\u00C4*L9\t=\u00DAQ.\u00C38(\u00BD\x13-\x00v8\u00FD\u00F9\u0096\x12iL\u00C7\u0086\x11\u0095\u00A3\x01dL*\u00DDd\u00D7\u00B3\x14\u00C3m\x02c \u00E3\b6\u008Fcz\u008A;\u00DD\u0085\x0EVS\u00E28\x06\u00DB\u00AF\u009D\u009D\u0082\u00D8\u00AFy\u00AD\u00F3\x19mm,Q`\u00A5\u00C68fI\u00FD\u00A5\u00F8\u00AC\u00BE\u00EB^\u00B3\u00EE\u0093L\u0081RX\u00A8\u00A9\u00F6@Q\u00B6(V\u00E2g\x00S\u00E9\u008E\x03r9\u00CA\u00DD\u009B\x06\u008E\u00A3\u00AEW\x1E\u0086\x1D1\u00B7i\u00B3\u00D09\u00D2K\u0099b\x1D\u00C5o\u00BDt2\u00EA@~\u00A8D\u00FB\x05e\u00DD\u00E5\u00FD\u00A2Q8\u00E1\u00EE\u00EB\x1F~\u00F4\u0089'~\u00F6\u00F9?k\u00EF\\\u00F1\u00C87{\u00BDi\x1B\x02\x00\u00BC\u00CB\u00CC\x7Fx\u00FF\u00B6\u00BF\u00F1\u00E4\u00A5\u0092\u0095\x14\x15\u00A8B%\u00A1&4\u00A2dm\x02w\u00C3R\u00CC\u00C4\u008BX\u00A1b\u00A7\u00EDx\u0096a\u00EF\u00E7\u00C9\x0B\u0081\u00D2\u00BFz\u00B0\u0091\u00AE\u00CB<\u0089\u0093\u00CD\u00A0\u00B6O\u00F3|\u00C0\u0081\u00C4\u00BC8\u00B1\"\u00D6\u00E6\u00CA(\u00F4\u00C0U\u0088T\u00EF\u0092\u0086\r\u00EDH?\u00CC\u00C5\x13\u00F7y\x1D\u00C0CC\u00BA\u00F6z\x01\u0095\u00D9\u008E\u00F5\u00D0by\n\u00E0Ul\u00E4\u00A0\x15;P\"\u00ED\x0B\u00C7H\x17\u00E3\"\u00B8\u00B2-E0\x06\u00C4\u00CE(F\u008D+\u00C3\u0096U\u00B8\u00C5\u00E9\u00D9\u00C0\u00E2\x06\u00D4y\u00EE\u00A3\u00DC{i\u00C3P_*\x13\u00D3a\u00E5\u00D9`?\u009Czs\u00B4\u0081\u00C5~\u0090\x1E\u008F\u00E5]\u00E3\u0090\u009A$\u00D5\u00A9\u00FF\u00DD\u00DD\u009A\u00B7\u008A\u00D3\u009C\u00BC\x185'm\u00AE\u0093p\u0091\x02\u00A0G?:\t\u00B5\u00EF@\u009D\u009E%/4V\u00D9\u0095\u00ED=\u00D1\x10C\u00AC\u009D\u0085yt\u00C6##\"6D\x14\u00A2\u00EC\x02\u00F1vlp\u00BF\u0082\u00DFU\x00\u0096\u0086\u00FC\u009Bk\u00C7\u00CDG\u009E\u00FA\x1B\x7F\x10f\x00\u00FC\x01\x11\x02\x00|\u00D9}\u00FBk\x0F\x7F\u00FB\u0093\u00FF\u00EF\u00F5W>t\f@\u0084*&0\u00E8\x06\u009CwH\u00E8\u0098$\u00C1w\u00D9\b\u0090D,\u0084`\u00A7k\u00AB\u009B\u00C1|\x06\u00B4\tK\x1C\u00F7\u0085\u00AF\u009D\u00BC\r\x10\u00E3@F\u00E7\t\u00CA\u00A6\u00DE\u00CA\x18\u0091\u00E4\u00E6\u00FC.\tu\u00F66T<\u0082PC\u00B5\u0095\u00C5R\x1A\u00AC\u00D4b\x1A0\u00BC\u00D5\u0081g'\u00F0\u0084\x03\x0Ff8\u0088\u00EEM\u00E0j\x06L\x1E\b\u00E98< \u00F9\x15\u0083\u00906\u0084D\u00DB&35\u0088\x18\x14\u00F7puXIZ/\x14\u00E1\u00EE\u00D8\u008E\n\u00D0\u00D9fH(\x13b8\x06\u00B6\u00A3\u00A4\u00D98\x1CR\u00E5\u00C6\u00E1\u00CDL\x0B\fL\\90h\x19\u00DF<\u009E\u0086\x01\u00D8|\u0086\u00A9\u00B9\u00F5as`X\u00AC\u008C}VV\u00E2F\u0084`>R\u00C2\u0083c:\u00BFAuG\u0088 \x11\x00b,\u008AR\x14JP\u00E99!\x00\u00A9Q\u00FD\u00F7\u00B4\u00D3\u00B4~voEHr\u00AA;\u00ED\u00B8\u0093\u00AB\u0099PT\u00DA\b\u009A\x1A\u00AAR\x05D]\u0081*\u00EC\u00842\u00C3\x07\u00B8\"H+\x10\u00BD-\u00A9\u00E9I9\u00E5\u00A4)\u00E7b,J\u00C5a\u00BC~\u0099\u00E4\u00F8E\u00DC\u00DD\u00A6\u00FB\u00DA\u00FD\u00B2h\u00ADy\u00AEn\u00E9\u00C9UPMz.\u00B1\u00CE\u00EB\u0092\u00B2O(3\x07\u00B9\u00A4+0f\n/\u00C2\x06\u009F\u00D8\u00AAE\x10z}\u00AF\u0080\n\x1B\u00B1\u00F8\u0092!\u009Ao\u00A4\u00FB\u00BB%\x00\u00DA\u00FC\u00D1v\x17l\u00A68\u00A3\x0B3\u00F2\u00B92M\u008A\u00F2}Z\u00D6\x12\u0087\x03\u0093\u00F2\u00EAi\u00F5\u00A6WN\u00D6\u0090A\u00CB\u00B3\u00F1wA\u00F7\u00BAi\u00A6 \u00A3\u0081L(\x043I\u0083\u00F2\u00C6\x11\u009EA\u00D3:\u00E7$CE\x1A\x01\u00E2\x01\u00EEm\u00C4w|/~\u00F3\u0089\x1Bh\u00CC\u009Fc\x7F\u0088\u00E7\u0090\u008BS^jP\u009D)W|\u0089\x03\u0096\u00F3\u008E\u00C5c\u00F1\u00CA\x13U\x06\u00D3\u00B7}\x02\u00E3\x0B\u00BA\x18^\u00B4\u00F9\u00E9\u008F\u00BC}\u00FD\u0096\u0087,\u009B\u00A5\x19\u00DD?\u0080\u00A0\u00D9\u0082\u00A0H\u00D7\u00DF\u0098\u0084\u00C5\u00CA\u00B7\"\u00B4\u00D1)\u0099\\\u0085\u00BA\u00B0j\u00C1\n\u00FC\u00B3\u00D5^\u0087\u0088\u00F0@\u00FC\u0081\x14\u00BC\u00A0\x1B\u00AA\x10\u008A`Uh\u00FD%M\u0084?0\u0080\u00E2:\x16w/\u00F6\x05\u00C2\u00D7\u00CC\x05;}\x7F\x0F\x1B\x02\u00E7\u00E9y\u009E55\x0Fa\u008F*vw\u00C1\x1A\u00CCCX\u00EF6\x01\u00D7F\u00D8\u00DA\u0090\u00DD,\u00E9\u009Ag\n\u0086\x11\u0098+-\u00A4\u00FA\u008APn\u00FD\u00FC\u00F3\x16\u00F7c\x13w\u00E6!K\u00C4\u00CDj\u00C7i%\u00B6m]18\u00D3\u00AE{\u008CKv\u00A68.1\u0083\u00BD\u00B2\x06\u00BB\u009E\u00D65\u00B1\x03\u00A0`\f\u00C9'\x18\u0090\u00D6\u009A\u00D7e\u009EB\u00BE9Z\u00E7Yw\u00E6\u008A\u008Ay0\u00E58\u00D2\u00BB\x0B\u00AF\u00C4\u00B1\x1A\u00EF\u009Fx\u0089\u00DF[S5\u0080U\u00E1\u00CA\u0095\x19\u0090\x04\x1C\x07\u00EF\u00B7@\x0FJ\u00CA\u00BBi\u00E5o>\u00F3\u00C8.-\u00F9~\u0085\u00DAob\u00FDY6~\u008C\u00B5WD\x19\u0083yd\u00A6\u0090c\u009B\u00C0\x10\u00CA>\u00AB\u009F\u00BB\u00B7`J\u00BAC\"^r\u00ED\u00989h\x00\u00C0\u00D1\u0087\u008E\x1F\u00DF\u00FD\x1B\x07\x1E!\x0F;q\u0085p\u00C2\x1E\x02\x00\u00DCS\u00E6\u00E3kw\x0E\u00FE\u00D0\u00FF\x19\u008F^~s\u00AB\x00\u009E\u00CB-\u00B9\x02\u00E5sS\x04\u00C5\u00DA\u00D3k(\x05Q\x1A\u00D9\u0086\n.\u00C2~\u00C7*\u00CA\u00AB\u00CA\u00A0z#\u00A5i+s\u00CAD\u009Bu\u00E5\u0085izY\u0093\u0094\x1C\u00B5\u00B8 4=_\u00A0\u00D2\u008CUE2A\u0092\u00E1J\b\u00F1\u0082\u00EB9\u009B\x02;\u00AA8\u00D2\x15k\x00\u00E6\x0E\u0096Y\u0097e\u00EF]\u00E0\u00E7\u00E9n!\u00BA\u00FA\x1D\u00AAF\u00AE=\u00D2gL\u00CDi\u00C6\u00D7\u0083O(\u00C6\u00CESo\u00C2~:\u0080\u00ACe\u00E0\u00F5i(\u00CC\b\x7F\u00FC\u00F3.\x06~u!\u00C5Y\u00CB\u00DB\u00A1\x153o\u00A7\u00BB{\u00DF\u00F9\x19\u00CA\u00F9a\u00E0'\x1F\u00CF\u00A4E\x1C\u00DC;p7\x7F\u00D4$\x13\u00B1AK\u00EC\u00D8\u00D3\u0083\u00A9\u00DE\u0082yq\u00DE8\u00A5\u00A3x\x13\x02\u00AEX=IwvL<\u0085\u00CE\u00E7\u00A7\u00E4\x14\x14\u00B7\u009Es\u0089\u0083\u00DFQ\u0081\u00AC\u0086\x0F\u00FE\\\u00DD9,D'\u00C99\u00C1\u00FD15\x1C\u00AA9\x1F'\u00DE\u0082\x02\x1AM[\u00A9\u00A9\x04\u00C0\u00C2\x1D\x13\u00C1\u00CE\u00DA\x02x\u00FC\u00EC\u0087n\u008D2\u00C8\u00B7y+\u00C6-\u00AA\u00F2\u00DC\u009DO\u00BC\u00F7\u00F7\u00D6\u00B6\x1E\u0097\u0082\u00EF\u00F1:\u00D7l\u008C\x07\u00E8\u0082\u00DD\u00DC\u00A6(\u00C3\u0085\u00B2H+\u0095D`\t5T\u00A8\u00DD\u0099\u00EDxZ\u0095E\u0080\u0087vK\u00C7\u00B8g=_^6\u00D0\u00F0\u0085T\u0090/+&KW\u00D0E\u00D3N\u00E4\x1D`\\\x00\\\u00D04<\u008A\u00F0\"\u00F8}\u00BA\u00E15\u0093\u00C0\x14\u0093L44\u0095\x032^\u00E4dA\u00F1\f&\u00B9f\x13\u00F85(\u00CE\u00E9\u00C0Y*\u00D8\u00E8\u008A\u00F5\u00AEX\u0083`\u00DE\x05kjX\u0082hf\x10fj\u0096tN\u00A1W\u00B3\u00A0D\u00C8E\u00BD\x0E\u00C2\x05\u00BB\u008D\u0088\u009C\u00BD\u0091\u009A\u00E8!\u00F8z\u00C7=\x17Y\u00CD<>-\x1C\u0080\u00D1\u00B3\f\u009A\u00A8\u008C\u00C00\x10Q\u00F3\x10\u00CC30\u00A0\u0091*bp\x014k\u00EFX\u0083\u00FA[\u00F5{h\u00F4P\u0090\u0082>\u00A3\u0087\u00D0\u00E3\u00ED\u009B\x07\u00E4\u00CF\u0095\u00DB\u00E7=\u00E5s\u0080oKk\u00CF\u00E3\x0Eu\u00DF>\u00DD\u00DE\u00E9^\u00CF\x00\x00 \x00IDAT\u009F\u009C\u0084\x00\x18\u00C19\u00A2Q\u0092NrS\u00DD?\u0095\x00\u009C\u009EN+\u00C3\u00F0\u0092\u00F3`E!\u00F0\u00EFR\u00C1\x1C\u00DC\x07-\x1C\u0086\u0092\u00AAF1.\x18\u00CD\u00DBY\x05Y}\u00D2\u00A2Cq\u00F81\u0087\u00DE\u00BA\u00EF}\u00FB\u009F\u0089\u0093\x18'\u00C4C8\u00DE\u00F8Gk\x17\u00BE\u00F4\u00BE\u00CB\u00B5E\u00AE\u009E\u00E3\u0082\u00DA\u00DC\u00F5\u00AF\u0099\u0082P\x06\u00B9P\u00EA\u00DF\u00DC\u0087\u00D1\u00D8\u008DT\x06S%P\u008E\u00C9\u00C53\u00F8\x10'\x0F\x14\u00A1\u00A9\u00834T\u00E3\u00C2\u00F2\u00BD\u00D22N4\u00BA+\x17\x02I\u00DD\u00CC\x0FIK\x00\u00F2\u009E' Vz\x17S\x1C\u0081q \u00B0\u00E8\u008A\u00EDn\u00F5\r\u00CBnU\u008D\x0B5\u008EYt4\u00F2Sv\u00D5\u00B85\u00B6u\u00CF\u00D2h.\u00F6Z\u00F2\u00EF\u00AC'\x00\u00B9\n\u00AC3\x00\u00D8M\u00A9\u00E6\u00F5\u00AD{\u0091:\x7F@\u00A3\u00CEbY\u00AE\u0081\u00CF\u0084\x19\u00CA\u00B1\x1CgT\u00A0\u00C3R\u00CD\u00C6\u00AB\x11_\t\u00C0+(\x15\u00D3\u009F>\u00BD\u0087z\u00AF\u00BC\u00CE\u00E8\x1EU\x7F\u00C6\u00E9\u00F7\u00ECI\u0098@+0\u0099\u0090\u009E\u009ErA\x11>tz\x14\x14\u00F8\u00D1[\u008AGx\u0080p\x1Dc\u0081\u0095\u00A2\u00E9'/\x18\u0098Z\x06?\u008FY'\u00EFu\u00A8\u0082E\u00B7~\t#\n\u00C1\u0087\u0093\u0096\n\u00CA\u00BD\u0094\u00DA+1\n\u0086z\u00AE\u0094\\\u00E3L+\f\u0092\u0089\u00B0\u0090t\x13-\u00E1W~\u0082\u00E8\u00A4t\u00EB\u00CD\u0085\u00ED\u00FEy\u00F6&pr\u00CE\u0098\u0082be\u00D8\be\u00ECd;?&\tS\u0095p\u0084\x00=\u00B34\u00DA\x15\u009Bf\u008F\u0088\u00C9J\u00D5\x14\u00FA\u009E\x02?!v\x01HR\u0090N\u00AF\u00ADk(\u00CFT\x06\u009A\u008A\u0096\u00C2>\x02\x18]\u00D1)&\n\u00A1\u00D7s\u00B9qQ\u00E5\u00CA\x14\u00F9\u00EE9\u00C7\"\u00E4\\\t{\x10j\u00C24\u00CBj\u00B3\x15\x14\x0F\u00B3*\u008C8\x07\u0087\u0094\x10B\x04\u00CBG._\u00BB\u00FE\u009Fv]y\"\u00B2{\u00BCq\u00D2!\x03\x00|Hu\u00DF\u00BF\u00D8\u00FA\u00EC\u0095\u00EF__^h\x12C:3\u008B\u008E\u008A\u00DEQS\x1C\x13&!\u009B\u0099\u00CA\u00AA~\u00E2\u00A2+\u00A9 \u00C8\x17G\b5L`+\u00D0B\u00CE\u0080\u00A7\u00C7\u00A6\u00F1\u00B3_\u009F\x0B9\x00LR\u008AT\x12\u00AE(\u00A84\u00E2U\u00CA\x008E!\x03\u00C7s6\u00CE\u00BA\u00E2Y\u00D8\u00FBc\x1BK\x00\u008C\u0093\u00A4\u00F6_\u00B40\u00A2a@\u0093\u00A1\u0084\t\u0099u\u0098b\x06\u00E9a0\u00BE\u0095N\u00A2IZ\u00B5\u00DA\u00BB\u00A0E\u00A6#'9=\x01\u00EE\u0093\x15\u008D^f\u00EA\u00FB\u00D3\u00D2X|\u00D8\u00C0.:A&\x19\x052r-\u0086V\u00E2K\u0099Z\u00A5n\u0084\x17\u00B3\u00C6\x0E\u00A8\u00D1\u00B2\u00F07\u00EC\u00DA\x15\u0082-(\u00B6\u0094\x19\x07kz\u00BADv?\u00A2\x0B;]\u00E6\x1D\u0093,\x00\x01?\x02rK\u00B5\u0086\u00A9\x0B\u0094\u00EDK(\u00A0\u00B1\u009F$J\u00EF\u00F7\u00C9NL\x04\u00F9\u00CC\u00CDv\u00D7\x1D\u00D6\u00CBa\x02\u00DA\u00B9\x10N\u00D7\u009C\u00C8\u00AAN.\u00C2R\u00AF\u0093\u008CG-?]5\u00DC\u00FC\u00E8\u0084\u00E4 \u00AB}\u00EE l\x00\u00AA\x1Aa\u0084e!,|X\u00F6\x1E\u008DX\u00A7\u009D\u00A6\u00B2'\u00E5\u00B2#\u00C0\u00CC\u009A\u00E5\u00B0\u00BF\u00F3\u00D8\u00B9N&\u00AF7\u00DF\u00A7u\u00D4f\x18\"Xj\u0086Y\x15\u00E8\u00A6\u00FD\x02\x10^J0h\x1DxL%\u00E2Y3\x0F\x19\u00B8\u0092Y\u00E0\f~\u00E0\u008E\x11;\u008F\u00DE\u00FA\u00B1\u00FD?\u00BA\u00F7\u008AS$\u00BE6'O\u00E5\u00C1\x00\u00E0\u00AFT\u00E7/\u00D9\u00BE\u00E9\u00FD\u00EF\u009C/\x1E9\n[\u00B4W6\u00E1qx\x04\u00A5\x1E\u00C1:\u00EFL\u00AD;5ih~j\u00D4\x0Et\u00A4\u00A6\u00D5\x00\u00FDP,T\u00D9\u00DE\x7F\u00F7\u0089\x16w\u008D\x1CV\u00D4\u00DF\x1E\u00E9\u00B1(\u00C7u\u00E5a\u0096\u00CD&G\u00E4\u00AF\u00FD\u00FA\u008C\u0080\u00A38\u00A6\u00F6\u00C1'\u00C9j\u00ECh\x16@\u00B1\u00A1\u0082}#\u00B0\u00A1\u0082\r\u00F5>\t\u00DD~7\u00B5pa\u00EE\u00AE\u00EC\u008C.\u00AA[\u00C9\u00F9\u00D2\u009FfO\u00E0\u008B!\u0083\u00A8s\u00F2\u00B9\u00BD\u00BB\u00B2\u00D5\u00CB\u00A0G\x01\x15\fK\u008D\u00EB\u0095\u00B1\u00D4\x0F !\u00DE\x01F\u00B9f\u009F\x06\u0081_\x1B$\u00F8\x06\u00AB\u00F5\x0B\u00B6\x1F\u00C2Z[\x1F\u00C9\fI\u0092\u00DA\u00EC3B\x11\u00E7&\u00DD\x19J\u009EC\u0086\r\u0080fX\u00C1\u00D0G\u0093[ \u009D\u00E0\u00A6i.\u00D6J@\x05k\u00ACr\u00EDy\u00CD\u00E4.0\x1Ce\u00BDC\u00E5j\u00B4\u008Aa\u00F1\u0099\u00FB\u00F3\x1C\u00C8\u00ED\u00E0\u00F5\u00F5\u00E2u\u00A9=\u00D3I\u00DDC\u0084\x12\u00F6\u00BD\u008E9\u00DF'\u009E-\x10\u00F3\x11\u00D2\u00B1y\u00C9\u0091\x0F\u00EF\u00FE\u00CF{\x1E'\u00DF,\u008B\u00BFM\x1EOt\u009C\u00B2\u0090\u0081\u00E3\u00C1\"\u008B\u00FF\u00B2s\u00F4\u00F9W.\x0F\u00BE\u00F7\u00AA9\u00E6!\u00F8\u008A\u00B2b\u0092\u00BB\x7F@\u00FC_\u00948B*\u008Ax\x00\u00F1\u00920\x11\u00EC\x10*d,\t\u008F5k\x05c\u00C5\x02&\u00DDp\u00F8\x12\"\x04IA\x0E\"\x13?sO T\u00952\u008C\u0098^\x13\u00DB{GM<\u00EC\u00DC\u00E1\u00A9\u00F8i\u0098\u00BD\x10\u00FF~\u0084Yu\u0082T\u0083\u00DAa\u0097\x14\u00E2\u009ETa\u008C\u00D3x\u009Bno^O\u00D2\u0099\x19\u00AAD\x15`\u00B9\u00D6\u00DAX$Z\u0096\u00F1Z{y\u00FE\u00AA\x1E\x1AH\u0084\x04\u0093\u00D0\x05\u00D99it\u00E5A\u00A4^a\x169\\\u00D1nX\u00C3\u00E8\u00D7\x16\u00F5\x05\u00BE\x7F,\u00CE\x02\x0F\x05\u0090\u00EF^|Nt\u0098\u00C5\u009E9[\u009FF\u0082\u008A@\u00CA\u00BB\u00E1\u00EF\u00DE\u00F33\u00DE\u00D7\x18\u00F7\u0087l\x13\u00E7.:\u00B3.\u009D\u00DFu*\u00DD\x14V>'\x1A\x18q\u00EF\u008FF\u0088\u0082\u00DFz\u00EEW\rD\u0086\x0B\x1AaB8\u00FF+\u00CA \u00E6\x0E\x14[\u00E7\x1E]\u00C8S\u00DB\u00F3O\u00B52\x00Nq\u00C8\u00C0\u00F1\u00C2\u00B5\u00DD\x1F\u00FA\u0096\u00BE\u00EB\u0095k\u009D \u00A2\u00AD\u00B7\u00D0&\u00DEA\u00F2\x0B\u00AC\u00FD\x1A`@d\n\u00AE\x1C\u00EFg\u00CC\u00BFc\x02\u00BB&\x0E\x16\x19y\u00E3\u00AE$X\x0F_\u00B5\u00BC\u00F6\u00EE8\x02\u00BFg\u0098\u0080|\x11.(\x15\u00C0\"\u00FA|_\u00DA\u00FDR\u00A1\u00B6\x0E\u00B4\u00A5\u0086%&\u008D\u0099\u00DC\x03\x16[\u00D1\u009D\u009F\u00A9`\u0090\u0092\u00F9@\u00F2\x02\u0086\u00F2w4x\u0081_3\u00B3\x11\u00B4\u00BA\u009A\u00D9\u0083\b\x1DT\u0093\u009E\f\u00CD,\u008A\u00B6\u00B0\u00A2k\u00A3=K\x16R!0\u00A0\u00F4\u0098\u00E2\u00FF=\u00C9a\u00E8\x02\u0095\u00CC\u00D0\u00D8sS\x10\u009C\x1E\u00BA\u0084\u00EB\x0F\x14O(\u008E\u0085r\u00ACr\u00BE\u008E\u00C825\x05\u00DA\u0092\u00F3/\u0097\u0096\u009B4\u00A8!\u0088\u00DDK\x18\u00E1\u008A\u0085\x18B\u00E5\x1Btt\x1Cy\u00C8\u00E1\u00F7\u00EE\u00F9\u00A5\u00BDO\u0092\u00AF\u0095\u00E5\t\u0088\u00E3\u0097=Ny\u00C8\u00C0\u00F1P\u0091\u00E5\x1B\u00FA\u00E2y\u009FYn~\u00F0\u00CA\u00B9\u009E\u009D\u00CEv\u00A5*#?#xR\u0084\x7F\"\u00EC>y\u00BA:\u00D3\u008B\u009AT\u00B2\x12\u00CE\u00F6\u00F1\u00E3\u00D6*\u00B4\x0E\u0098\u0092\u00D0xA\x14\u00C2\u00EE\u00BF\x03\x04*iC\u00BAp\u0091)p\x173\u00B2\x18n\r\u00A8\fX\u008D\x06\u0094}9\u00C9c;qE\u00E3\u00E7u\u009FX}\u00E2o\u00BA\u00E0\x0Fn\u0099\x07\x17\u00D8@\u00C4{*(\u00F1,\b\u0095^\u0084\t]\u0082\u00DA\x1B\n\u00B1kL\u00DAT\u00AEN\u00CEr\u00E5A\x0B\x16\u009F\u00F93\u00ECJw\u00D5\u00AC\u00B0\x02V\u00B8\u00EA\u00F7\u00DCk\x00\u00D83t\b\f\x07)\u00F8\u00D1\u0097B\\A!\u0089`\u0082L5*\u00A4\u0084,F\u0081\u00B6\x10\u00C2\u00F1\x1Ca\u00F6$[\u00A13\x05\u00D8\u00E9\u00F9i\u00A58O\u00E7\t\u00C3\x01zk\u00DC\u00C7\x04\u00DD\u00F8\x06@n\u00CBP\u0086\u00EB\u00EB\u0093\u00A7L@\u008F3n\u00B3\u0090\u00A1\u008E\u00E7\u00EE\x1C~\u00C3o\r\u00F2\x1D\x0BY\x07 \x13\u008A@\u00E4\u00A7)<@\u00B8O\u00B5\u00F5y\x05\x05iU\u00A8\u00E5\u00CD\x05v\u00F7\u00BF\u00A2\u00B6.p\u00E6v\u00B5\u00CCR\u00C4\x04(\x00\u00A2z>\u009CV\u00A9\u00E7\u00DFD\u00E0#\u00DB\u00E0\u0096(\x1A\u009A\x14\u00AB\x1B\u00C0\x10\x15\u0089j\u00B8\u00B3\u00DA}\u00A5g\u00B0\\\u009Ai,\u00C0L\u009EY\u00B15U\u009C=\x02\x1B\n\u00EB\u00AA\u00D4\u00D3\u00BD\u009DuC\u00F4\x07\x18]\u00D9:+%uwp\x0F\u00A3uX\x7FD\u00BA\u00C1c>\u00C7\u00EC`\u00ACAUV\u009F\u00D9m\x14\f\u008E\u00A5p-D\u00D1\u00CC,\u00CC\x15IM\u0086F\x06\u0082\u00FD\x14\u008D\u00ACna\u00C1\u008C\u00E7\u0081\u00B9\u00E4\u00E1\u00C2{\x16imi/7\u00C3\x04\u00C1L\u00D3\u00927d\u0086 i\u00C2\x12\f\u00D4\x19\u00AD(\x18\u008E\u00AC\x10\u008B:\u00C3\u0081\u00E9\u00F9\u00E9\u00C50\u00A5<\u00F4\u009CO\u00B1\u0096Ex\\\u00C9\u00E7\x10d\x17%\u0086\u00B4\u00ADO)\u00CF|\x07@\u0086\x12\u00B5B2B\u00B7\u009E-\u00F3\u00F8\u008Cj\u0088R\u00A9\u00CB\u00A3(\x0E\x7F\u00ED\u00E17\u009E\u00F3\u00EE\u00BD\u00CF;!\u00C1\u00BB\x15\u00E36\x0B\x19\u00EA\u00F8W\u00F3\u00B3^\u00FC\u00D9\u00A3G\x1E\u00FB\u009E\u00F5\u00FE \x1Df\u00E1~\u00CAD \u00FD\x01\x14\u0081\u008A%\u00D1\u00FDe\u00A8\u00C9}\u0080v\u00DD_\u00BC\u00C2\u00E22z\x17&l\x1D\x19&4\x10\u00F5\u00B6\u00EF\u008B;\u00C8\u00F3\x15mL\u00AB\u0096D\u0093\u0095\u00EB\u00F4c\u00F0\u00DA\x18J\u00A4G\u00A0yl^\x7F\u00B7\u00C9l\nM\u008A\u00D2h\x06r\u0096s,\x14\u00D8D\u00C7L\x1B\u0096\u009C\u0098>\u0081:\u00CC\u00FAL\x14O\u00F9;p\nZ\x1E\u008F_\u00B53\u00BE6\u00EB\u00D8 \u00C17\u00E8\u00BCV\u00FE\u00BF\x1C\u0087\u00E4,q%\u00BC\x14\u00AF\u00C3\x00B0\u00FDQ\x068I\u00AF\u008EY\u0099\x16\u008A\x02\t\u00AA\u00C1\u00EEk\u00E6\x19'\u00C0\u00DE\u00E7RS\u00F0\u00C5-.\u00DB\u00A5Y\u00C8 \x11>VRQ5\x0E\x04\x7F\u00C5\u00CF\u00A3\u00FE\u00BE\x18\u00C2\u0091u)\u009D\u00DEN*\u0081t\u00D5\u00B3n\u0085\u0099\u0086\u00C8\u00C8h\u00F1|4\u0085\u009D^%\u00C3\x07Z\u00FFZc\u00D1\x03[r\x03\x03\u00F8j\u00E0\x00$C&\u009B\u00E8@oKl\u00DE\x7F\u00F3\u008A}\u00FFr\u00CF\u008B\u00F1\u00EE[#}'6n\x17\u0085\u00F0u\"\u0087\x7Fe\u00B1s\u00D9\u00F5\u00CB\u00F1\u00CF\u00FEZfg\u008D\u00E4\x19\u00C4\x0BP\u00B0\u00F5\u0098\x14\u00CD\u00C8\u0087\x1E3\u00A6hb0\u0096\u00F4\u0097\x17}\b\b\u00EE\u0085\u00DB\u00E5\x0F\u009F/'\x00I\u00A4\u00A7@\u0081\x02\u0092J\x1A\u00E7\u00D7\x10\n\u00F8$\u0099\u0080\u008BeB&\b\u0084\u00D8?\u00D9\x7F~\x1BJ\u00EFG\u00E2>\u00AA\u00A2\u00A1\x17\u00B4\u00A3\u0082-L\u00EB\u00FE[U\x1C\u00DA]\u00C1(\u00E0\u008D9\x06\u00BF\u009F\u00A5\u00D2\u009B\u0090P6\u00E1\u00C6\x17w\u0094q,\u00C3%\u0082\u00AA|\u008E=\u00C22o\u0094\u0082d\u00E9Q \x15\t\x1A\u00F2s\n.i\u00C2\u00E6r'\u00AD\u0099\x19\u0082\u00DE\u0081\u00D11\u00A0\u008A\x1B\u0090?\x10\u0082\u0085\x14n\nce\x05N\x18\u0081\u00E4\u0086\u00F0\u00F9#\u00BDB\n}\x02\u00C79\x07\u00EA1L\u00A1I\u0080\u00B044\u00AD\\;\u0085\u009Fn\x7F\u00E0AZK\u00E0\u00D3\u009B\u0088g\u00DE\u0099X\u00D7\u00C8@\u0091UY\u00E7\u00BB\u00DD\u00ABb\u00FB\u00DC\u00C5\u0091\u00E5S\x16\u0097\u00C9s\u00E5\u00F0\u00DF,a\u00A7n\u00DC.!\x03\u00C7\x0Fnm?\u00E7u\u00D2\x7F\u00FD\u00C6\u00F9FX\u00B5\u00C0\f\\\u00F8d\u00B4K\u009A(\u0083\u00D5\x1F`j\x195_\\Xh\x07\x07M\u00D8[\x1E\x0FSl\x00e\x7F\u0081B\u00DDm\u00A7\u00F5\bBIy\u00A1q}\u00E58i\u00A1\u008BBb&\u00A2O\u00CF3Qvq\x1F\u00EA\x12F\x0Bh\u00C4\u0099\u00B3\x15\u00D8\u00A5\u008A\u008D\u00D1\u009B\u00AC\u00AA-\f;S\u0089\u00D0 \u00C2\u00841\u00D1\u00FA\u00E6U\u008E\u008D\u00D5t>\u00F9\x06'1\x11\u009C\u00D4n\u00A1E\x00\u008C\u00DA\u00CC\u009A\u0095n@<\u00AE\u00887\u0080\u00D5\u00CC:\b\u009C(\x05\u00ADkrg}\x054\u00DB\u00B1\u00FBs\u008A\u0090E\u0081Ah\u00B1\x11\u00A1C\u00A0\u00FFE\u00A0'\u00D5\u008E\u00E5\u00F8\u00F1\u00B9\u0083y<6\u00CA\u00FE\f%\u00F8^\u00E9\u00FD\u00CDz\u00BE\x076\u009A\u0099Tb\u008Ei,\u009A{}\fE\x18:@\u00E9=tW\x12-\u00CE3x\u0096LF\u0086oTh\x06(G\u0095\u00AAf\u00D8C\x1EK\u0083b\u00B9k\u0081\u009D\u00A7\x1F}\u00EE\u00BE\u00DF<\u00F77n\u00BD\u00D4\u009D\u00D8\u00B8]\x15\x02\x00<\x7F\u00FB\u00C8\u00CF\u00FE:\u00D6\u00BEw\u00C4,d\u0086\x16i\u00E2~\x13\u00A1\x05Bp&\u00CB\u0083\x15aLP\x06\u0091t'\u00BAkB\u00DC\u008A@j\u00E0\x11t\x0B\u00AD-\u0098\u009F\u00D3\u0089\u00FA6\x11<\u00EE\x0F\r\u00EE\u00A9BZ\u0098\u00E3\b|]\u00E3\u0081\x16\u00825\u00FF\u00C7x:\x1E\u009F*\u0089\x02\x1DY2\u00EB\x13\u00DE\u00D6oP[\u00C3A\u00815\u00C7\x00\u00E6H\u00C1\x1F\u00D4\u00D2r\u00C3\b\u00B0\x0BsS\u00EF\u00BAT\u0094&\u00D4R\u008D\u0099\u00A5\u00F0\u00F3,M!\u00D4\u00C5C\u0086\u0091\x1E\u0083F\u00B8bBo1|\u0093d\x1E\u00CE\u00BA\u00E1\n\r\u00885\x17\x06%k1k4\x04H\\\u0081\u00CA\x01S\u00C1W\u00E4\u00CAUA`\u00D7\u00F4\b\u00A2;SG4\u00A6\u00AD\x05R\u00A1H4\u0085\u00BBi.e\x17)Cn\u00E7\u00F3mV\u00B8+\u00C1:,\u00EFp\u00D2]\u00C9\u009F\u00B5\"=\x05\u00D1\x1E\u00CF\u009E\u00F8R%\u0083\u00D5\u00B4%\rY\u00AClU\u0094W\u00CC\u00F96b\u00F3\u00D2\u00A3\u00AF\u00DA\u00FFG{\u00FF\u00DD\t\t\u00D8I\u008E\u00DB%d\u00A8\u00E3%k\u00BB_v\u00DD\u00D1\u00AD\u0087\u00BD}\u00C07J\u00B7\u00D3'\x1BP\x01\u00C6\u00D7!p\u0098\u00B8\u0086\x15\u00B5N\u00E5\x01D6!\x18a\u00C7\u00D2\u0098\u00A3\x1E=\u008E\u00EFB^\u00D2C\u00D9\tI\u00D3\u00F2\u00C3<\x03U\u0098\u00C0\n\u00DD\u00C5\u008C\u00FB'\u00E9\u00A5r\u008DUq\u00F0\u00B0qo\u00DC?\u00E8\u00AA\\\u00C6\u00DB\u008E?*\u00B0\u00A5\u00E6-4\u00A4\x0B-=Kn-\u00A4\x10g\u00C9\u00E9\x04\u008Cb\u00E8P'!3\x05\u00E1\u00CAr\u00E1\x11\u00AF\u00924\u00CCAb\u00DD\u00C4\u00C0\x12\u00EC\u00AA\x02=wq0\u00D7\u00B6\u00E7k`\u00EB{\x03N1q\u00DF\u009B8k\u00D1\u00DFE\u008D\u00FF\x13W\x02\x14\x12\u00E4\u00A9\u00DA\u00E0&R\u00BB\f\u00954\u00D7\u0086\u00ACJ/\x04]3L\u00E0\x1C\u00C1X\u00D6\u008EPs\u00F7!EI\u00F2Zy\u00FF\u00FE\u009B\u0085i\u008A\u00A2\u00DC\u008B\u00B0\x0F\u00DA\u00B28\u00AB\\3\x15}4\u0084\u00F5w\u00D3\u00D4l\x17\u00D9\u0098\x13\u0082\u00BF(\u00B6\x1F\u00BE\u00F3\u008Es^\u00B5\u00E7ex\u00C4\u00DF)R\u00A7t\u00DC\u00EE\n\u00E1Q\"\u00E3\u00DBT\u009F}\u00F3\u00E1\u00CD\u00FF\u00FB\u0081\u00D6.\x01$\x1E\x12 \u00FE\u00F0s\u00A5\u0087hP\u00C2\x17\u00EFnX\u00C4\u00DD\x10D\x1FEmeR\u00C81\x02\x1A\u00AC\u00C1\u00F0,\u00F2\u00E50\u00A5\u00A9\u00F5E\u00FB66\u00D15C\x04\u009E\u00DA5<\u00CA\u00FE\u00D3x\u00B6\u00A4\x0B\u0086\n\u00CB\u009Ea\u0081\u00A5\x05{\u009C\u0093\u0095\u00A2y\u00BF%\u00C3\u00E3/\u008D^\b\u00A7E\u00BC\u00BF\u00FA\x1E\u00FC\u00DE\u00C7\u00E2\u00E1q\x15(f\u00B4\u0080\u00F4`b>h\u00C1\x18\x14\u00A1\u009C[7\u00E6\u00A7\u0091\u00E0\u00FC\x19z\u00A6F\u00CBo\x00\u00E8}\u00C4\u00E2+\x0F_\u00B9\u00EFE\u00BB\u009F-\u008F\u00B8u\u00AD\u00D4Of\u00DC\u00EE\n\x01\x00\u009E&r\u00F3\u00AB\x17\u00DB\u00CF8tt\u00FB\u00CF>\u00D66\x0E\u00F0%\u0085\u00E0\u00A2Z\u00F6\u00D2\u0085\u0086\x13$\u00B6\u00D5\u00B0\u00C4\u00B4x\u00B5 )\u00ADr\x11\u00C0\x12f\u00C4q'\x1A_CYh9G\u0086\x19+\u00D6\u00C8\x15\x05_\u00F6$\x05\x19\u00D7\u00AFay\u00C8w\u00AF\x13PBy \t4\x11\x12\t\u0096\u00A3b\u00E1\x13)]\u00DE\u00AC\u00C3\u00E7\u00FA\x0B\u00A1\u00D8\u00FA\u00D4%>\u00E6\x1E\u00A9\u0098\u00A2\x17\u0080\x04:\x1F\x18\u0088\x13\u0093\b4Z\u008D\u0082#\u00EE*\u00DE\u00EC\u00C7\u0098\u008A\u00BD\x03\u00A1\u00F0\nV0bZ\u008A\u00DEt\u00F5=\u00DA\u00E7,~\u00A2\u00D5\u00B6\u00F7;}\u00DEI\u00FCq\u0090\u00D1\u00FF\u008E\u008CMy\u00E7\u00E4<4'-Qqg\u00EF\x0BW\u0088@d<\u0096\u009A \x1FT\x03\u0093H\x0F\u0086\x041;\u0099\u00FAs\x1F\u00E8\u0089N\u00DE\u00A9\u00960\u00C1\u008D\x12\x14u\u00DE\u00F1\u00B8\u00EE\u00A0\u00D8\u00B9\u00A4cy\u00AF\u00AD\u009B\u00E4\u0099\u00B3g\f/^\u00BB\u00F9\u00C4%\u00EB\u00E4\u00C7\x1D\u00A2\x10\x00\u00E0%\u00F3\u00F5O\u00FD\u00A7\u00AD\u009Do=\u00BC\u00B9\u00FC\u00C3\u00AB\u0086\u00D9F\x15\u009E\u00AC\t\u0097I\x18\u00C0\u0087m\u0093\u008FT\u00E3d~U%\u00C1c\x01\u00B0\t\u00E1\u009A=\x15\u0086\u00BB\u00C8\x13\u00C4\u00B9f\b4\u00CEy\u00BC\u00E2$(_6{(\u00F8\u00A9\x03\u0084\u00AC\u0093D&\u00C4\u00A6\u008ADW`r\u00F2\u00D3\u00F3X]\u009B)\x04\u00B5\u00DC\u00FF\u008E\x0Bt\u00E3*K\u00CA\"\u00A8\u00E3\x1C\u0097n/\x05h\u00AC\u00CA\u0082J\u00A0\u00D6kHxC\u00D1\u00ECe4\u00C1\u00E3\u00E3\u00A5@\u00AA\"V\u00C3c\u00A8\u00C7\u00EF\u00CC\u00BF\u00CB\f\u0082\u00F8kc\u00F8Q\u00F1\u00A1d$\u00A6\x17\x12\u0082\x03D\u00E8U?\u00D7r\x1E\x14%BA\u00E5\u00FD\u00A8\x7F\u00CF\u00D0#\u00C2.Me\u00AC\u00D0\u00C8\x14X\u00EC\u00EF}%}\u00DE\r\u00AE4l.\u00E5<\x0BP\u00B1\bx\u00ADUi\u00E5\u00BD\u00B7\be\u00F3\x19\u00D9\u0083H\x0Fa{\u00EF\u00E6\u00D6\u00DAS\u0096\u00DF\u00BA\u00FF\u00E7\u00CF\u00F9\u00D4\u0097#C\u00B7\u00C5\u00B8\u00DDA\u00C5\u00D5\u00F1\u00FD\u0087\u00B6.\u00FB\u00E5\u00A5\u00BC\u00E9\u00A0\u00CCm\u009D\u00D1\u00D1\\\u00C9I\x1F\u0082x\u00F1\u009A\x02\u00DD;Zw\u00A7\u00AD\u0082|\u00A5\u0096`\u00D5\u00AA\x0B\u00DC\u009A\u0085\u00D0\u0090R\u00AA\u00A1\x1CZ)~\u00A1\u00D5;f\u00B9-N\x06W2\u00ADX%\u009D\x1C\u00FF\u00D8\u00BF'\u00BF;\u008E\u00F1(2\u00BB\u0091\u00F1\u00A8\u00AA-\u00CD\u00BE\u00A6\u00C0n\x15\u00CC\u00D5\u0097\x7F\x1B\u00B9X\u008B\u00F74\u00EC$)e1W\x05\u00C2*:.\u008A\u00E0\u00DA\u00B3i\u008A\u00A8\u0081\u0094\u00EA\u00CAbX\u00A6\u0095c91\x17ba[\\\x02\u0085\\\u00C8e\x10\u0099\u00D46\u0088f\u00BBvZ\u00E5\u0086\\\u008A\u008E\u00E0\x1AC\x02\u00DBOJ\u00A9\u00F4\nP\u00E8\u008AAx\u00DD\u00FCL\u00E9A\u00D1\u00DBI\u00F4>j\x19\u00C0X\u00BE\u0086\u008A\x1A\u0099\u008D\n(\u00D6mf|\x0F\u00DD\u00B2;Tj\u00CC\u00D8X&\u00C6\u0095\u00DF\u0098\x00&\x17\u0096\u00D5r\u008D\u00F5>\x04\u0096e\u0081*\x16g\u00ED\u00F4\u00E1\x1F,\u009E}\u00D1\u00E5{.?I\u0091:\u00A9q\u0087+\x04\x00x\u00E1\u0097\u00B6\u00BF\u00FB\u00F2e{\u00F5!\f\u00E9\t\u00C0\u0080.s\u00B3\u00BD\u00E0\u0086BJ\u00A1\u00EC\x00\u00AAu\u00F6mk'\u00A5t\u00913\u00F4\u0098\u0084\x02L\r\u00ADz%\u008AH1\u00D6\u00F4&\u00B1\u0081\x10\u00F4\u00C2YXm\u00B0\x1Ay\u00FD*\u00F4+\u00C7Ze9\u00C66=\u00F3\u00DA4Om\u00EC\u00D8\u00E8\u0082]\x00\u00D6\u00BB`}\u00CC\u0095\u00A2C!t\x16>\u00D5\u00F0\x02\u0099\u0092\x1CY\u0091\u0089\u00F81\u00A5\u0090?P@GE[d\u00A3R\u00AE\u00CD\x10\u00A4$\u0098\u00A0\u00CF\u00D0r\u00B2\u00C3W\u008Bv\u0090\u00CEX\u0089\u00DE\x10\u0096\n\u00C1\u00B7#\x0BQ\u00B4d\x1E\u00E0\x19\x12\u0094^\x04(\b\u00BF\u0094\x15\u00AE\u00B9?\u00AC\x1E\u0080\u00AC\u00C2X\x03\u0092\x1E\x0F\x18\x16\u00A5r\x10?\x16\u0095\n\u00C0\u00E7u,\u0087\u0080d.\u00BE\u00F3\x19\u008B\u00AB\u00D4\u00FB4\u0094U\u00B7\u00C9n\u00E4\u00DFdM\u0082\u00D7\x00\u00DEg^[\u0083\u00A0\u00AF\u00ED\x00\u0097\x1E}\u00C9\u00BD\u00DE\u00B6\u00FF5\u00A7B\u009ENf\u009C\x16\n\x01\x00^t\u00CB\u00E6\u008F\u00BC\u00E1\u00A8\u00FC\u00C7\x1D\u0099\x03hnm]h]\u00E3G\u00E5\x17\x1F\u00B43\u00C9\u00C2\u00E5W$\u00E8X\x05?\u00D2i\u009A\x02\x16\u00F1&\x17T\u00B1s\x19kM#\u00ED\x18 b(!)\u00D7\x04\x18\u0093\u00AD\x1C\u00D7'\u0098)\u00A6\u00964l*\x11fS\u00FC\u00D8t\u008B\u00E9E\u00E4\u00F2]~\x7F\x00\u00D8[AF[\u00EAm\u0097\n6\u00C4R\u0090\u00EBN\u0085\u00AD\u009E\x02\u00C3\x03\u00AB\u0086\u0094\u00E8\u00B3h\u00FC\x02\x13\u009A\u00A1TG\u00D2#hK$\u00FBpt\x0FA\u0081X\x17\x11\u00DE=\u00D9\u0085w\u00A6\u00E6\x11\u0090\x1A\x1C\u00A9G\u0094&&\u00C8\u00CA\u00C7\x14bL<\u0084\u00B0\u00FA\u00FC\u00BC\u00E7\u00B6L\u00F9\u00F2\u00BBJC\u00B6\u00FD\u00F3\\\u00D0\u00E9\u00F1\u00AB+?I7\u00F6\u0082\u00E8\u008F+\u00DE\x06\u0089CE\u00B0M\u00C8\u00ED\u009D5\u008F\u0093\x04l\u009E\u0092\u00FD\x17\u00E3<\u009DJ\u00C8\x19\u009E\u00C8P\u00C9\u00B2\b\x12\u00F7\u00A0\u00C3\b\u00BDt\u00F3G/~\u00C7\u00BEW\u009C\x021:\u00E9q\u0087a\b\u00AB\u00E3\u00C7\u00F7l\u00BC\u00E2\u00D0\u00CE\u00E1}o\u00DEi/YHKk\t\x14a\u00AB(~\u0092\u008D\"\u00C5\u00E4\u00FFW\u00D4\u00CF+O@\u0082\u00F1\x16e\u00BF!\u00F4\x068\x11\u0095\u00AE\u00E0cZ\u008C\u00FC\u00DC\u0080.\x05J\u0096\u0084\n\u00C2\u00BC\u0085\u00CCC\x13S\u00C8\u00D0A\u00F2:QB\u0083h\u00B2\u0099%\u00AFZ\u00D8\u0089\u00B6\x00\n\u00B0\u00ADe;\u00AFu0\u00DE\u008B\x1D18\u00FE%nm^*\u00CC~\u008A\x1D)X\u00E2iO\u00A3\u0082k2\u00F4 N\u00DE\u00E9\x01\u00C4\x01\x1E\x1B\u00FB3dzp\x1E\u008AQ!\u00AE_\u0089\u0098\x11$n\u00AE\u0088#{\x00\u00A0\u00C9\u00B4\u0084=>\u00E7\u00ABG\u0089\u00FF\u0081\u00D8\u00D6\u0096Z\u0093\u00C9\u00AF\u00DF\u00F7\n\\\u00F4\u00E5H\u00C9m?N\x1B\u0085p\u009E\b>\u00AD\u00FA=;7n\u009D\u00F5;\u00DB\u00ED\x05#Z\bRX]\n\u00BC\u00CF\u008C\u0089;\u00DEsB1\u00EE>&\u00B3\u0080\u00F4\x1A\u0098R\u00C4X?\u0087\u0083K\u00C7Q2=\x15\r4\x17\x04\u00A9^G\u00E0\x18\u009A.y\x02\u0096\u00B9\x7F%)\u00D5\u00ED\u00ECo\x07HyM\u00BC\u00EF\x0E`4%\u00B4tr\x14\u00BB.\u008F\u008E\u00EC\t\x10\u0098K\u00F3\u0090c\u00E8Rp\r\x16\x0E\u0089O|\u0086\x04\u00F4V$B\"[\u008CE\x03\u00EB\u00B0\u0094\u00A2\u00ED\u00CF&\u00ABK8\x1E\u00E0\u00BC\u0081P\u00A6\u00C8\u00F6e$\x18(\x15\u0096\u00AA\x0B\u0097\x1Dz\x06\n^\n\x0F\u0095\x11\u0090\u00EF\u008E\u00E0!\u008Fk\u00AE\u00BD)N\u00AB\u00F0\u00B40 C1\r\u0081\x1CF\u00D8\\(\u00C7Su\u00E2TyG\u00CD\u00EB8\u00F8^\u009A\x1B\n\x05\"$\u00B1\x05]\u00EDb\u0082\u00A7\x10\u00FB\u00C3\u00B1$g\"\u00A24^u\u00D0U\x01H\x13`Xb\u00FE\u00D8\u00E5\u00AF\u00DC\u00FB\u00F5\u00FB\u00BEG.:m\x1C\u00F5\u00D3G!\x00\u00C0\u00FDD\u00F4\x13\u00AA/\u00C2\u00F5\u009B\u00B3\u00B7\u00EC\u00AC\u00FD\u00B3Q\u0087\u0089P\u00860u\u009F0\x13eP8\x07\x00&H>\u0090\u0093\u008A\u00E9\u00BD\u00C2O\u00E0\u00F7S \u00CF\u00AD\x050\u00C9\x04hy\u00C1\x14\u0094p\u00FD;\u00A2b1\u00EA\x17\u00A8m\"\u00FCI\u00A6\u00A3\u00E1\x04\u00D3\u00FB`\u00B8`\u00BB\u0099\u00B0NR\u0095]\u00C2\u009A-4\u009B\u0090p1\x17\u00E6\u00BCSY\u00B2\u00CE\u00C3\u00EEw\u00E6\u00A5\u00C49y\x19#'\u0088\u00DB=\u00AC!\u00EE\u00C24\x1A\u00DB\u00A7\u00C5\u00F4us\u00DEDaEGt\r\x10\u00D9\x18\u00EA\u00C8 \u0091\x05W\u0081\u00E8\u00BD\x1D-:L\u00F3=#\u00AD\u00BC\u00BA\u00F0\u00C7\u00F9\x19\u00EA\u00F8{k\u00AE\u00EC\u0098\u008D\u0088\u00E5\u00E74\u0081F\u00B6@\u00B3y\u0090\\\x0BhR\u00AD\u00BB\u00A6W\x11s\x00\u00A9\u00B4\r_\u00EA!\u00D8\u00AD\x18+\u00DE{\x16|\u00D1\u008B\u00F2g\x03x\u0093 {\x18k\u008F\u00DA\u00FE\u00B5{\u00FF\u00CC\u00DE\x17\u00C9W\u00C4\f=-\u00C6i\u00A5\x10\x00\u00E0\u0081\"\u00FDJ\u00D5\x17,\u00AF;\u0082?\u00D8\u00DA\u00F8g\u008B>L,\u00FCd\u00B1\u00CB\u0089\x15\u00972\u00F9\u00D3\u00BD\u009B\u00E0\x0B+J\u00A3\u00BA\u00AA5\u00E7\u009C_f\u0098\u0090\u00C7\u00D1\u00DC\u00AE\u00B8\u00E4\u00D5KY\u00BD\u00B6\u00C95\x04\u00FB\u00D2\u00FB'\x14\u0092R\u00E0\x14\u00A1\u0090|?\u00BA\u00FBE\u00B8G\x05\u00B6\u00DD\x1BI\u00A5S\x14\x1A-\u00BB[|z\x19\u00F4\u0080jX\u00D3\u00BBD\u00F6\u0081\u009E\u0085\u00B8\u00E2\x19\x01_,\u00D6n7\n|\u00F8l@\\6\u009F\u0097\x02\x18]pjHe>\u00BD\u00DD?\u008B\u009CF ,wM\u00E3\u00C5\u00A3.\u009Fu \u0084\u00D1X\u009A\u00C5\u0093\u00A2\x07\u00E6\u00F7\u00DD\u00F8\x1DX\u0081\u00E9\u00D6\u009A\u009EB=n}\x7F\u00F1\u00DE40\x1C\u00E2\x0E\u00E9\u00B1\u009AR\u0089\u00CAN\u00BF\u00F6\u00DE\u00F9\u009D\u008D\x0EWr>UZ\x17,gK\u00CC\x1E{\u00F4\u00D7\u00BE\u00EAU\u00FB^ _\u0093\x1C\u00D0\u00D3e\u009Cv\n\x01\x00.\x11\x19\u00FFJ\u00F5\u009F\u00CF\u00AE9\u00B2|\u00EB\u00D1\u008D\x17,\x1C\u009C\u009B\u00F4\u009E+\x13(x\x0B\u008A\u00A8E\u0088\u00859B\u00D0r\u00FF*\u00A0\f=\x18&\x103\u00E0[\u00D4\u0095s\u00C5Lu+\x1C` \u0090@ \x05\u00CEc\u00D5\u0089\u00F5\u00E7D\u009Bx\f\u0088I\x18\x1Dr\x14e\u00D5\u00E8\u00B4fp\u00D0\u00B3wk\u00FB\u00CD%\u00CB\u0088\u0092s\u009DG\u00A6\x1C\u0087\u0091\x16\u00DA\u00CEC\u00F6\x1D\u00A0\u008E5H\u00C6\u00D8\u008APR\u00B4\u0088\x00\u00A2\u009E\u00BFAc\x01Y*h+k\u00EE\u00FE\x7Fs\u0095\x15F)\x1E;\u0082\u0081G\u00EC\u00C6\x18zL\u00ED\u009A\u008E`\u00980*\u00CA3\u00F6\u00FB\x06\u009FM\u00E8\u00E8t\u00C3Kz\x11\u00C0D\u00A0\u00B9\u009Dm\u00A6\u00A9$\u00CB\\!+\u0096\u00FBV\x12\\cM\f\x10\rZ9\u0087\u00D8\u0099\u00B9\u00BB\u00C2\u0093\u00F2n#3\x05\u0080\u00AB86X\u00EB4\u009Dob\u00FE\u0098\u009D_\u00B9\u00E4g\u00F6\u00BD\u00E8tT\x06\u00C0i\u00AA\x10\x00\u00E0\u00C1\"\u00FDj\u00D5\u00EF\u00DA\u00F5\u0085\u00C3G\u00DErd\u00FD%Gd\x0E\x00\u00C1\u00AD\u009FZQ\u00BE\u00C8\u00ACy\x0F\u00A1\fSC\u00F4\x1C9\u00E1\u00A0E ]1\u0084\u00A0\u00A2\b\t\u00D2}t7\x1E\u00C0D\u0090\u00A3n\u0081\u00D7\u00E4\u00E7\u00B1\u00D3\u0088#\u00D3\u00F99S\u0092\u00AB\u0093{r^*\u00BB:\u00D1\u00FD~\u00F9=\u00BB\x15-YX\x13}(\u00AD\u00E0i\u008Cs\u00E5\u00BD\x18*\u00EF\u00E7Z\u00DA\u00BD\u00F7\u00A2\x18\u00E0\x1EB\\\u0087c\x17\u00BC\u0084\u00C8\x0E\u0080:\u00C3\x1A\u00AA\u00F0\u00B6'\u00E9XI\u00AF\u00AB\u00C3\u0094V,\u00D9\u00A3EX\u0091\u00F7\x1Cy\x7F R\u0085\u00A3k\x03k\u00A3.q\x1Ef\x0EB\u00A1\u00F8>ld\u00CA\u00FD\u00ADn\u0081\u00CA\u009F\u0082n7\u00C0\u00BA\x02\u008A\u00B2({*d\u00D1\x14i\u00DCCxY\x1A\u00A1\x0F\u00FB)\u0088\u00DA\u00C9D\u00E9=\u00D9\u009DvU\u00B4\u00D9\x0Ef\u008F\u00DFy\u00F5%\u00BF\u00B4\u00EF{\u00E4!\u00A7W\u0098P\u00C7i\u00AB\x10\x00\u00E0^\"z\u0093\u00EA\u00BF\u0099}a<\u00F8\u00DB\x07\x17\u00FF\u00F1\x16\u0099E\u00E3O\x00\x13W\u00DE\u00F4mZh s\u00EA=P}M\u00ABW'\u00AD\u00BA\x00(\u00AB\x19\x01\u0086\x06\u00D5\u009B\u00E0\x04\u00A5`\u00AE\u00B6U\u00CB\u00F0\u00A5\u00DC\x043\x1B]b\u00D2\u00F3\u00DCU\x19To$Zz\u00D5T\u00A5\x0B\u00F3\x04XuA\u00D9!\u00FB\u00D0\u00D3}v\x1C\u0089u\x10\u009B\u00DF\b\u00C9G\u00A3zO\u0088\u00D5\u00F5\x19\u00E2Z\x10a\x06\u00E3o\u00ED\x02\x11\u008D\u009A\x06>n\"\u00FBl\u00B5\x1E\u0082\u00C1\u00EF\u00B9m}vq\u00DF\u00E6UPY\x11w\u00A0+\u00CFc\u00D9\u00BB%(g\u0099\x10\b\u00A2U\u00BA\u0096sq\u00DB\u00C6k.\u00F3\u0084\u00CF\u0087\u00E7'\u008E\u00A0\u00E5\u00BC\n\x03!\u00C7\u009E\u00A9\u00C4j \u00B8O\u009C\u00CB\u0081\u00CC\x16\u00D7\u009F|\x0B^\u0094\u00ACw\fO<\u00F4\u00A3\x0F\u00FA\u008D\u00F3^!\x17\u009E>\x00\u00E2\u00F1\u00C6i\u00AD\x10\x00\u00E0\u0080\u00CD\u00B8W<\u00EF\u00BA\u009Box\u00DBM\x1B?\u00F7%]o\x14\u00F0\u009CX\u00EAVS\u00FF\u00F5_]\x00\x00\x17\u00F9IDAT\u00F2\u00ED\u00BAPL\u00B6\u00C3\u00CA\u00FF\u00EB$r!\u00AD-\u00D4\u00E8Y(_.\u00B2\u00ECZ'B\u0094\x05F5\u00AC\b\u00F7\u009F\x16\u008F\x13k%\u00F4\u0099\u00AC\x05A\x0B\u00AF\x1A\u0093p\x12\u00C6\x14e@\u0080t\u00A9\u00B6X,\u00AD\u00F9\x1ASe\u00BE\u00AD5\x01\x15\u00B4\u0091\u00F8@GG\x0BO\u00C0\u00D6\u0082t\u008B\u00D7\u00BD\u00A0\u00CC\x19\x7Fl_\u00AE\u00DD\u00B2\t|&+p\bwW0_$\u00F9\u0086\u00CC\u00CA\u00B6D(\x06\x02\u0092\u00CD;\u008C\n\x043\u00B6\u00F9\x12o\r\u008FB\u00F2Q\u00EF\u00B9\b\u00F6D\u00D0d\x1F\x164?[\u00B2#Rs\x14\u00B2\fG$HIl\x04c\u00C0\u00A0\u00C4\x020\u00B6\u00F2R\u0092\u0094jk4R\u0087\u00E9\u00F2\u00B3\f;\u00FB$:\u0089\u00ABg\u00F8G\u00A5\u00D4\x1C\u0097\u0099\u00B0\x1By\u00AC\u00CEtd\u0092\u00A6\u0082<\u00C5s\u00B9\u00F2k\u00FB\u008El\u009D}\u00E9\u0091\x7F\u00FA\u00F07_x\u0087\u00D2\u0091Od\u00DC\u00A9\x14\x02\x00\u00BC\u00FC\u00DACOz\u00F3\r\u00ED\u00B7?\u00B5\u00D88\u00A0*e\u00E9+Mp/\u00C8A\u009A\u009E\u0082\u00BFD\x19i\u00C9\u00B5\u00E0\x05\u008E\x0BHZy\u0089NCi\u00D9\x05fU\u00A8\\\b\x0B\u00A5\u00AB?U\"\u0093~\x02.\u00E8:\u00F2$\u0098(\rZ\u00E1\u00C0;|RO\u00C3\x04E\u00AC\x10\f\u00B7\u00E6\u00B1\u00F8l\u00AE\u00DD\u00B0\u00E1\na\u00D6\u0081\u008D\u00A2\f\u00B8\x04\x1C\\1\u00CC\u0096\u00C5\u00AA2L\u00F0&+V<\u00C5\u00CF\u00F8l\x053\u00B8K,y>*\u0084\x01N\u00A1\u00F6YE\u0081d5#k!\x06\u0099\njU\b\u00F3\u009E\x7F\u00F3\u00F3`'\u0082M]\u00CD\x06\u00AF\u0095\u00DE\x0EA\u009D\u00EE^c\x11J$\u00EF\u008F\u00D4kT\u0085@\u00D4\u00B3\u00F3<\u00A9$\u00EB\u00B2r\u00F0k\u00E5\u00B3\f\x05\u0081\fw\u00E2Z\x05\x18/\x1FT\u00DDKH\u00EBl!G\u009B\u00B4Q\u00A7\x07\u0093L\u00C3\u00A9\u00E0\u00D6\u00B6h\u00ACFl\u00E59\u00B3\u00FE\"i\u00CC\u00A6\x10\"\u00E4\x00\\\x1D kF,\x7F\u0082&K\u00AC=\u00EC\u00C8;\x1E\u00F8\u009D\u00EB\u00CF\u00BE\u00E8\u00DF\u00EE\u00BEC\u00FA\x19\u009C\u00EC\u00B8\u00D3*\x04\x00\u00F8\u00A0\u00EA\u00F0\u0093\u009F\u00D9\u00FA\u00E9\u00B7]/\u00DF{x\u00B1\x06@&\u00D6VV\u0084+R\u0088.\u00D0\u0093\u00BC\u00B1\x0B\u00AA\x05\u00F2\u00E4\x17\x14\u00B0/\x14\nR\x00\u00A9H\nEZ\u0099\u00FB\u00EA\x05\x1FP\u00B2#\u00BDwB\u00D7\u0089\u0092\u00A9\u00FC\u00F9\u00D5\u00AEM\x01,v\x05z\x07\u00D7\u0097Hfa\u00D6\u00E5\u00F3x\u00B3nK\u00BB\u00CD}\u0082ot\n\x0F\u00AD\u00AA\u00F5\x10\x14\x05\u00DAR}\u00CD\x066\u00F5\u0090P\b\u00F5Y\x0EK\u00B3\u00FE\x112\u00C0\u00AB\x14Qp\x04\n\u009C\u00A4`\u00B1z\u00B1\u00A9\u00C6\u00DA\x0E\u00EC\u00930\x1F33\u00C1T\u00E4\u00DC\x15j\u0093\x04\u00FF\u00A2h\u008Ba_Q$3L\u00DDx*\x11\n+\u00F7\u009F\x14\x1F\u00D5\u00FFs\u00BB\u00A2d&\u00E9\u00CC\u00AE\u00A1\x042{P\u00CF\u00E5+J\u00ED\u00DA\u00C6\u00FE\u00AF9\u00FC\u00AA'\u00FE\u00E4y/\u0093\u00C7\u00DF\u00FE\u009D\u008EN\u00D5\u00B8S+\x04\u008E\u0097|\u00F6\u00D0s\u00DE\u00FA\u0085\u00D9/\x7Ff{\u00FD,\u00A2\u00DA\x13\u00E6\x1B\u0095\x000\t\x19\u00A2G>\x15\u0087\x7F\x1Fi\u00B0\u00A8\u00C8h\u00AE73\x0E\u00F3\u009Em\u00C0\x18O\u00CF\u0096\u009Aq\u00F4\u00D2-\u00F1X\x04\u008A<\x04ZL5\u00F7\u0099\u00D8\u00C1\f+\u00DE\x00hm\u00D5+\u00FC\u009C\x0BQ\x05\u00DB\u00EE|B\u0083\u00E6o\n\u00FD\x04\x13@\u00F9\u00BF&\x1F\u00C1\u00C2\x03{\u00DC5\x14 \u00EE\u00C0\u0090\u00AEr\x1F\b$\u009A\"\u00C8\f\u00CB\u00F1\u00D2\u0088@*\u00B2A\x15\u00DA:\u00DA\u00B9\u009B\u0087\u00EF\u00F1\u00A4\u00ED\u00EF~\u00F2\u00FF<\u00EF\u00BF\u009D\u00E4T=\u00ED\u00C6]R!\x00\u00C0/_\u00B7|\u00C0\u00AF\u00FF\u00F5\u00D6\x1B\u00DE}\u00E3\u00DA\x13F\u009D\u0085\u00B55,\u00C1-\u00A9\u00F3\x0F\u0092\u00FC\u00A3\u0089'\u00ACX\u00F8\u008A\x1B\u00D4\u00B4bd\b\u0082;\u0090\u00DB\u008A+\u0092\x001\u0091\u008A\u0089\x1EB\u00ACVCE\u0080\x05\u00D5[R\u0092\u00AE\u0090\u00A1\x03x\u00CD\x00\x1A\u00B6\u00B0\u00EBA\u00B7\u00BC\u00F7\x01\u00DF6<\u00EF\x11?z\u00DEm\u00BA\n\u00F3\x1D5\u00EE\u00B2\n\x01\x00nP\u009D}\u00DF\u00C7\x0F\u00FF\u00C0;\u00AEn\u00FF\u00E1\u00BA\u00CD\u00B59tf2\u00E7\x02\u00CE\u00BC\u00BE\x1CO\u00A0};\u00A0\u0084\t\u009E^\u00A40\x06\u00BF\u00A0\u00B8\u00AC\u00BD\u0097\u00E3\u00AD\n4\u00A6\x1E@\u00BA\u00FAT2=\u00F0\u0087)x\u00A8\x01v\u00C2\u00BD\u008A\x00,\u00A9\f\bL\u00B2\u00D6\u00A3S!e\x0F\u00C59\x14\u00EBKKCJ\u0097X1\u009A\u00B8\u0082t\u00B16jc\n\u00B4:S\u0091\u00D7\u00CD\\\u00BD\u0088uIb\u00CFDZ\u00FF\u009AV\u00AC`\u00E3\u00CC\u00D3\u0096)\\\u00CE\u008B\u0080L\x04\x1E\u00F0%\u00EBz\x11H\u00CD\u0098\x7F\u00E8\u0092<\x06\u00F7\u00A8\"\u00E4P\u00A3`\u00DBwb\u0085P\u00BA\x12\u00A6(\u008F\u00B9\x12&(\x00\u0099z\"\u00D6\u00EE\f\x10\u008C\u0098\u00ED\u00DBY\u00EC\x7F\u00C2\u00D1W>\u00FDG\x0E\u00FC\u00B8\u00CF\u00EE\u00C8$\u00F90\u00D5\x17\u00C2\u00AA\u00A8\u008B\u00AE\u00AC2\x11\u0089\x01\u00D4\u00DC\u00FF\u0094\x15\u00A9\u00A1\x10Hf\u008A,Fa\u00D7\u0099\x05\u00F7\u00CF\u0095\x1C\u00FA\u00E45\u00D0\u00C3\u00A0\u00F5'M\u00B9\u0086\x14\u00E4!\x18\u00960\u00CD@\u00ACfI\u0086n\na\u00DE\u00E9\x19 \u0080\u00B6\x16\u00D4e\t\u00E5\x10k\x1BF\x16B-\u0095)m\u0082\x11Tl\u0080L\u00C4\u00CAQ\u00E0\u00B6\u00C1+\u00A8\u00FB\x00\x13\u00AB\u00CE\u00EF\u00AAg@\x16\"\x15B+\u00E7k\u00FE\x1E\u00B2\u0083sV\x1E\u0092;0\u00A10k\u009EG\u00FC\u00B8\x11>\u0094\u0085g\x07\u00D8\x1F3Yb\u00EF\x03\u00B6>|\u00CF\u00A7.\u009F\u00FF\u00A4\u009F?\u00F7C\u00A7|r\u009Ef\u00E3n\u00A1\x10\x00\u00E0}\u00AA\u00F3\u00D7\u00FE\u00F9\u00C1\u00EF\u00FF\u0093k\u00D7\x7F\u00F0\u00AA\u00A3\u00EB\u00EBY\u009C$S\u008F \\w\x14\u00C1C\u00C4\u00E9\u00AB}\x15\x01W\x14\x10T\u00A6a\x05\"Y\u00E84\u00E14\x14A\u0095n=\x04\u00C2\u00D2\x17\u00A1\u00D61\u00AB\x14\u00B9\u00EC\\\x1E\u0087\u00A9KR\u0098\u00CB=\u00B8\u00D0O\u00C0\u00CF\u00AE\u0098\u008F&\u00E8\u00A46\x1BkQ\u00A39h[z7\u0083n\u00EB@\x06\x0E\u00E2\u00CAf\u00EE\u00AE\u00BF\u00C8T!DCUMjr\u0082\u008A\u0096Q \u00A5\u0098.9=\u0089\u00B9[gvB\u00AA\x1EF\u00C4\u00F5Z\x7F\u00EC\u00E9?p\u00EEO\x0E\x7FO\x16'5\x01\u00EF$\u00E3n\u00A3\x108~\u00ED\u00BA#\x0Fz\u00FD\u00C7\x17\u00BF\u00F0\u00DE\u00EBw]\u00BA=\u00CE0\u00F6\x16a\u00C4\u00B4W\x02\x02\u00B4\u00E3:\u0082(\u0082\x01wc\u00ED\u00CF\u00A9e\x060\u00C9XT\x1E\u00C3jQT4Q\u00ED\u00A4!\u0097\x10\u00C3\u00BD\t\u00BA\u00B9q-%L\u00806\u00AF\u00E7\u00C8\u00FDB\u00D9uW\"]\u0081nB>\u0090{\u00D0\u00D3\n\u00CF:0\u008C\u009EI\u00A0@\u008DV\u00EB\x10)Wz\b\u00A3\x1CCH2k\u00EF\u0099\x05\u00CB\u00DB\u0080]\u0099i\u00A5\u00C5\u00D3\u0088\x03$)\u00CB\u0098\u00A6\u00FA\x02\u00F4\u00C3\u00B1\u00C0b\u00F3d\u00B1-\x02+\u00A1\x1C\u00E8m\u00CDz\x12\u0099\u00C0\u00EBQ@\u00A4\u00B6s/\u00FC\x03\x14O\x01E\u00B9\u00A9B\u00E6Gq\u00EEC\u0097\u00EF\u00BA\u00E4i\u00FD\u00C5\u008F\u00F9\u00F1s\u00AF8\x15\u00F3\u00EE\u00CE2\u00EEv\n\x01\x00\u00BE\u00A8*?\u00F1\u00B1#\u00CF\u00FB\u0083\u00BFn?\u00FD\u00F1\u009B\u00D7.\u00EC:\u0084\u0090O*\x1C\u00DD\n\u009B[_\u00C0>n\u00AB@\x10\u00A1h\u00991\r\x07\"\u009E\u00D7\x12>\u0084\u0087a\u008Af\u00B5\u00A4\u009A\u00CDM'\u00A5\u00B9\u00A0\u00C7\u00D1#$\u0091\u00DE&\u00DEDz\x02\u00C80#>\u0097\b#\b\u00C4\u00CD\u00C7$\u00E3\u00CC\u00D8\x15i\x04\x00\u009D(\x04*\x1Cx\x18\x11\u0085L\u00A8\x1EBw\u00901\u0089C\u0095\u00AF\x00\u00FF\u009Bt\u00E5\u008A\x03$\u00BBP\u00A7t\u00E5n\u00DD\u00A1b\u0089w0\u00F4(\u00ACAw\u00EF\u00E8\u00F5\u00A4\u0090'\u00EE@B\u0091\u00F8\u00B5\x05\u00B7\x01\u00F6\x0E\x1B\x18\u00E6t\u00EC\u00BE\u00F7\u00E6u_\u00F1\u00B5\u00CB\u0097=\u00FD\u00D5\u00E7\u00BCA\u00CE\u00E7Y\u00EF>\u00E3n\u00A9\x108\u00FEd[\u00F7\u00FD\u00E2\x07\x0E\u00FF\u00D0\u00BB>/\u00FF\u00FA\u00BA\u00C3\u00BB\u00E7Q\u00D3O\u00CB\u00CAJ\u00CAb\u00E9\x05\u00C8\u00AC\x00$\x1B\u0088v+t\u008A\u00B4\u00A2\x0Ba\u00E57\u00B0Y)\u00AD\u00ADhK\u00A0\u0090\u00FB\u008C+a\t*\u0086\u00D1\u00CB\u00B1\u00E4\u00B8\u00C0c\u00D0\u00B5\u00EB\u00825\x04\x05\u00A9\u00A4\\A\u0091\u0097\u00C0\u00D4]\u00EB\u00C0\u00B0T\u00A0[\u00FD\u00C5|l\x19~\u00F85\u00B6\u009E\u00A1A-}\x1E\\\x00\t0r\u00C5\u00A6Y\u00B0\n\u00CDk\u0098\u00BB\u00CB\x1Fk5(\u00A6\u0098\u0080\u00D7\u00944X\u009AT\\\u00F1\u00D6\u00E5\u00E4#EI\x0F\x04\u00CC\u009A\u00E8\u00E4\u00FC\u00C2\u00CC\x0E\u008F/\u0080h\x0B\u00CA\u00B1\u00A83%\u00A5cc\u00FF\u00F6\u00E2\x1E\x0F\u00DF~\u00ED\u00D7\u00BFp\u00DF\x0F\u00DF\u00FB\u00B9\u00B3\u0083\u00A7|\u00B2\u00DDI\u00C6\u00DDZ!p\u00BC\u00F6\u00FA\u00EDK~\u00EFC;?\u00F3\u009Ekf\u00CF8\u00B2\u00B3\u00EE\x0B\u0082f\u009DCm'\u00C6N\u00C9\u00C7\u00C4\u00F3>q3\u00AD\u0088\u00E47L\u00C2\x07\u00AE\x07\u00E9\u00DD\u0097+n\u00A1\u00F0\u0096f\u00E9Q\x00\b,\u00C1x\x06\r\u00AC\u00C1\u0098tm\u00A6w\u00C0\u009E\u0092\u00A5\u00ACz\u00EAAx\x1B\u00B1\u00D1\u00AC*\x19\u008B\\\u00E8\u00A5-5\u0084kXz\u00B1\u00D7\u0098@j\u00AC\f%iy#\u00DD\b\u00B7\u00F2\u00C5\u00A5O\x0F\u00C1\u00DA\u00A4\u0093Dd\u00C0\u00A1\x06\u00907\x14\u0085@\u00AB\x1E\u0085N\u00C8\u00F0\u0081J \u0084\\\u00A7\u00DBP\u00B9\u00F9z\u00CF\u00B1\u00DA\u0093(\n\u00A5ZC\u00F1\f\u00BB\x0E\u00E3\u00A2\u0087\u00E2\u00AD_\u00FD\u008C\u00E1\u00A5\u008F}\u00C5YW\u009E\u00D2\u0089u'\x1Cg\x14B\x19?\u00F1\u00C9\u00A3\u00DF\u00F0\u00FBW\u00F4\u009F\u00FA\u00E0\u00D5\u00F3\u00C7m\u00F6\x19b\u00E5\u00A4\x11`S\u0093\x00\u00FD\\\u0080k\u00A7\u00E4\f\x0F\u00B2%x\u0084\x0F\u0091\u0095(\u00E1\x00\u00BB\x13\u0091\u00BE\\\u00B3\x18\u00A1h\u00E0a\x02\u00CF;\u00F5X\u00D8\u00BA\u00D8\u00CE\u00A9%\u009C\u00E01\u00BB\x0B\u00B4/Q\u00C7\u00E6.%Dh=\u00B3\x00\u00ACoh]\u00D1\u0096\x12\u00CA\u008C\u0095\u008F\u008D\n\u00C1\u00C3\x03\"\u00F2\x0348\x04\x04\u00FD,#\u0091\x02[C\u0086Ua\u00AE\u00DF\u00D1k \x1FaU!\u0084W\x01\u00842\u00A1sOO`\u0082K\u00F0oq\u008C\x00\x00f[\u00B8\u00F0\u0081[\u00EF\u00BF\u00FFS\u00F1\u00F2o|\u00D5\u00B9\u00FF\u00EB6\u009ARw\u00BAqF!\u00AC\u008Ck\x16*\u00BF\u00F0\u0097\u009B\u00FF\u00E8\u00ED\u009F\u00DA\u00FE\u00E1\u008F\\\u00BB\u00EB!\u00DB}\u00EE\x02\u00ECe\u00D2\u0085\u00B5\x18\u00AE?\x00\u00AE\t\u00D9\u00BADCNV\u00DB\x05\u0093\x10\u00E9Ap)\u00F6\u009A\x05\u00A8\u00A0\u00A3N\u0094H*\u0099)\u0093q\x1A\x02\u00C0\u00C3\x04\u0092\u0089\u00A8p\u00F2s\x01\nP\u00A8T\b\u009AJ\u0080$&\x19\u0093\u00E5\u0088\x0EH,\u00EBV\u00D2\u0088@\x10\u0091\x06e\u0097$\t\u0081\x1C:\u00A2\u00DF\x01\u00BA\u0085\x10s\u0095\u00E8\u00C6\x1E\x0B\u00BA\x02\u0098\u00ABN\u00AD=Jz\u00B1\u00F3\u00F8\x12a\x14\x0B\u00AB*\u00C7@\u0080Ia\x15y\x10\u00E6U\x18(9\u00C76\x0Ep\u00CB\u00B3\u00DF\u00F3\u00A9\u00F6\x1F>t\u00ED\u00ECA;}\x1D\u00D10\u0095`!\u00A6 \u00A1\u0096\u00DF\u00ABl\u00C6\u00E43\u00ACd$\u00A8\x1C\u008E\u00F1\ntE\u00F10l\u00D1\u00F8;\u00EB+\u00E8\x150\u0084\u00D0\u00C0\x13t\u00B5\u00D4ztO\u00C3\x15\x12\u00AF\u00DFV\u0086\u00F6\u0085Y\u00F9\u00DD\u0098+\x18K\u00C1!fj\u00EC\u00C4\x106a\u0083\x14Zo\u00EF\u009D\x10\x02\u00C9\u00E6\"\u00CE\u0081\u00F0g\u00CC0\x03\u0092\u008D\\(\u00D8\u0095\u00C7P3\x0E\u0099\u0086,m\u00DA\x14\u0096fDvs\u008A\u00F0\u0081\ni\u00D8\u00C4E\u0097l^\u00F1\u0095\u008F\u00D7W~\u00DB\x0F\x1Ex\u0093|\u00D5\u009D\u00B7D\u00F9\u00B6\x1Cg\x14\u00C2\u00DF1nP\x1D~\u00E6\u00CF\x0F}\u00FB\u00FF\u00FE\u0084\u00FE\u00FB\u00BF\u00B8z\u00E3\u0091[\u00E3\x1C\u00D1\u0099\u00B9g#US\x04:\u00C1\x10\b\u0088u-K\u00A6\x05\rZ\x0B~0\r\x13&MO\"\u00A5Y\u00D6J(\u00E7\u00AAaB\x0B\x0ECn\x1B\u00DC\u0088\u00DE}?\u00C9\u00DA\x0E*\u0095\u00D1\u00B6\x1F\u00BA@F5\u00D7\u00DD\u008B\u009B\x06 J\u00A0\u00A1@s%1\u00D7\u00E4#\b\u008C\x16m\u0096=-t\u00F6IP\u00F7\b$\u00B0\u008A\u00E0\x00\u00F8\u00CF\u00BC\n\u00BB \x17\u008E\u0091\u00A2\x10\u0090^\u0085\u00BAWR\u00B9\x0E\x02\t\x16\u00A5\u00A5\x1C;\u00E6\u00F3M\u009C\u00F3\u00A0\u00C5\u0087\u00EF\u00F7\u0084\u009D\u009F\u00F8'?v\u00C1o\u00C9yg\x14\u00C1\u00DF6\u00CE(\u0084/s\u00DC\u00A4*\u00BF\u00F8\u0091[\u00BE\u00E9\u008F>\u008E\u00EF\u00FB\u00F0\u00E7\u00E7\u00DFpp{\u00CD\u00AC\u00EF8K\x10\u00B0\x02\u0089,o\x06\u009CX$\u00D30A1\u00E5\x19\u00D0\u00C3\u0088B\u00A5\u00C2\u0094t\u00A1]]T%HC\x05\x1F\b2\u0093V\u00A6c\u00CF~\x10\u00A3D\u00E5'\u0097\u0088\u00AB\u00EBA\u00A2K\u00B4P\u0093\u00DEm\u00F9s\u00E7h\u0088Z(1\u00C0:1\u0091\u00C8\x13\x1E\u0082\x0B4-4\u0097\u008D\u00E7\u008A\u00CA\u0086\x13h\bpM\x1F2Kaq\u00BEd\u00FA\u0091\u00C7*\n#AE-\u00D8\u0080g\x19\x00\u00B4\x06\u00CCv\x1F\u00C2=/\u00D9\u00FE_\x0F\u00FFz\u00FC\u00E7g\u00BE\u00EC\u0082?\u0090\u008B\u00CE\u0084\x06_\u00CE8\u00A3\x10n\u00C5x\u00DD\u00A7\u00B7\x1Eu\u00F9\u00FB\x0F\u00BF\u00E4\u0093\u00D7\u00AC=\u00FBs7\u00ED\u00DE\x18\u00D1\f\u00D5\x1E%\u0080H\u0096CG\u00DD\u00C3\u0098\x169\u0081\u00C8\u009A\u00A5pE\x10\u00DC\u0085Z\u00E1X>\u00AF\u00A0\u00A2f/\u00C5\x00\x1DGWD\u00DD\u0081E\u00ED\b\u00A6%$\u00AE#\u0088OU\u00C1x3\x16\u00E9ITj\u00DEg1\x14\u00D1h\u0085E\u00F3\x1A\u00A3\u00A3T7\u00BB\u00DF\u00D6\u00F6\x06 \u00CD\u0090} \u00847]t\u00F5\u00EAD\u0084\x070\u00A9U`\x16\u00C1\u00853j&jj\u00D2\u00C1\u00CB\u00BA\u00D2S\u00E0\x02+!\u0087Q\u0097uJ`\u00A2\u0097r\x1C\u0085@\u009C@\u00C7\u00EE]\u0093\u00DA\x04?\x10\x05\u00DA\u00C8\u00B6\u00E7\x12\x1D\u0096\u00A3\x7F\x01d\n\u00E4)\u00D0\u009A\u0096\u00BE\u008A\x12\u00D6~V\u0094\x070\r5\u00C87\b<\x00\u00EC\u00A7\u00E8\u00CA\u00C23\x17\u00B3\x0EH\x1B1\f\x0B\u00DC\u00E3\u0092\u00FE\u00E9\x0B\u00EEw\u00E4u\u00DF\u00FC\u00C2\u00F3\x7F\u00F5\u00C1\u00CFl7\u00DC>3\u00E0\u00AE7\u00CE(\u0084S0nPm\u00BF\u00FA\u00C1\u00AD\u00A7\u00FC\u00D1G7_p\u00E5\u00B5\u00C3\u00B3\u00AE\u00BEq\u00D7F\u00979d\u00EC\u00D0\u009E\u00E5\u00C8\u00E6\x01$m6\x00H\u00EF\u00F8\u00B3\u00DA\u0082\u00AD\x15\u00C1\r\u008F\u00A2\u0084\t\x13\u009EAaE\u00B2{R\x1B\u00C5\u00D6.\u00EC\x19&P\u00C0'@\u00A8\u00EF\u009B\n\u00C1\x0B\u009DF\u00C9\u00BF\u00BB@tD\x1B\u00CD\u00E1\u00B7\u00B4\u00A2U;\x1A\x01)\x05\u00BAIV5\x0E\u00A2\u0091%\u00A8\u00B5\fMR\u00A1\x10,\u0094\u00A6%4(U\u008D\x00\x04=k%\u009Ab\u00AE#\u00F6\u00DEck\u00EB\u00C2\u008B\u00FB[\x1E\u00F1u\u00F2+\u0097}\u00EF\u00BE?\u0096{\u00B0\u00A6\u00F4\u00CC\u00B8\u00B5\u00E3\u008CB8\u00C5\u00E3\u00A3\u00DB\u00BA\u00FFu\u00EF8\u00F4\u008F?x\u00D5\u00F8\x1D\u009F\u00B9v\u00F6u_\u00B8e]0\x0E%\u00BB\u00E0\u008F\u00FC\x18\x001]y\u00F5X=\x0B\u00A4\u00DC\u009B\x00\u0080\u00B1\u00B4U\u00EB2\u00B5\u00F8\u009E\u0081`wf\u00E9\r\u00DD\u00B9\x13Qe\u00E9\x05KUy\u00C4Z\x15\u00A3\u00A5!\u0089u\u0084\u0097\u00C2f)\u00DD\u00BEg\u00E5!\x15B\u0083Z\u00B3S\u0086\x02\u0092\u00C2L\u009As\u00E5\x05\x10+`\u00B6\x02\u00D2]\t\u00B4l\u00AC\u008A\u00C4 \u00C4=\u0084&\u0082=\u00FB\u008E\u00E8=\u00BEj\u00FC?\u00F7{X{\u00E37}\u00E7\u00DE\u00FF\u00FE\u00C0K\u00E5N\u00D9\u00DD\u00F8t\x1Dg\x14\u00C2m8\u00DEv\u0093^|\u00F9;o\u00BC\u00EC\x13\u009F\u00DB}\u00D9g\u00AE\u00E9\u008F\u00BF\u00E1K\x1B\u00B2h\u0080\u00F6Y\u00A4\x13\u00938d\x19\x00x#\u0092\x1A&\u00E4\u0092\u00F4Z\u00D2\u0089\u0098x\x05LSF\x1B\u00F9\u00B1\u00B4V+\x00c\u00F5\x0Ejed\u00FDa\u00F6\u00A3\u0091\u00E30j\\#y\x0B@\x12\u0092\x06\u00F1\u00DF\x10\u00D4\u00F6\u00EB\u0081/\x1400\u00BD\b\x0F%JS\x12\x02\u008F\u00CC.4\x05\u00B4m\u00E3\u009C\u00FDK\u00BD\u00E7}v\u00DEw\u00AF\u008B\u00FB\u00E5O\u00BB\u00EC\u00C0\u00E5\u008F~\u008E\\u\u00DB\u00BF\u00BD\u00BB\u00E78\u00A3\x10n\u00A7\u00F1\u00A7\u00D7\u00EAW\u00BC\u00FEO\u00BF\u00F8\u00AC+>7|\u00CBu7\u00CC\u009E\u00FC\u00E9\u00EB\u00DB\u00BA\u00F6\r\u00F4>B\u00FAP\\\u00FF$\x16\u00B1\u00D1\u00CA$\u00ADY]\u00FF\x122\u00B0\u0085Z\x1Bk\u00AAq\u00CAy\u0098\u0084!\x05C\u00A0\x17\u0090\u00C5U\u00E4!\u00A4\x12!\u0086 E!4'\x18\u00AD\u00B9R\b\u008C@\x10\x1D\u008BY\u00B7\x10\u009C\x02$.@\u00C6c\u0093\x1E\x15\u0088\u0096\u00A5\u00D8\u00C2E_\u00B1\u00D8>\u00FF\u00C2\u00FE'\x17\u00DF\u00B7\u00FF\u00CE3\u009F\u00B7\u00E7-\u008Fx\u00FA\u00DA\u00E7o\u00CF\u00F7uw\x1Dg\x14\u00C2\x1D0>\u00BE\u00D0\u00B3\x7F\u00F3O7\u009F\u00F2\u00BE\x0Fo~\u00E3\u00F57\u00F7\u00A7^u\u00ED\u00EE\x07\u00DC|x\u008E\u00DEg\u00C1\u0084\u00AC\u009C\u0083\u00EA\x1D`d\x1A\u00D3>\u00EF$*\u00D5\x02&\x0F\x13j\x0B\u00B7\u00C8\x12\x14\u00E5\x10\u00D8\u00C3q?K\u00E5\x12e\u00D1\x1E\u00CAp\u00DA\x18\u00E3P\u00B1\x06\u00F1\u00DA\u0086\x04\n[\u00CFjH\u0092\u0093\u00A2\u00AB\u0092\u00A470\x03 \u00B2\u0085\u00B3\u00F6\u00EE\u00E0\u009E\u00F7\\~\u00F2\u00FC\u00F3\u00C7?|\u00F0c\u00E7\u00EFx\u00CE\u00F3\u00CF\u00F9\u00E3\x03\x0F\u00B9\u00EB4/\u00BD\u00B3\u008C3\n\u00E14\x18\x1F\u00B8Q/~\u00FD\x1F|\u00F1\u00D2+\u00AF\u009A?\u00F9\u00FA\u0083\u00FDI_\u00B8\x01\x0F\u00B8\u00F1Kk\u0082\u00E5\x06\u00FA\u00D8\x01VE\u00BA\u0092hZ\u00D8\u0087U\u00E0'!@\u0082\u008E\u00D19\tn\u00FD\u00C9+\b\u00D0R\u00DD\x13\u00D1LK\u008E\u0088B\u00AB\u00C8Bxf@\u00FD\x070\u00D7\x7F\x069\u0086\x1D\u00C8\u008E\u00CC\x19\x06X\u008ApP\u00C5 K\u009Cs\u00EE\u00B6^x\u00E1\u00E2\u0093\u00FB\x0F,\u00DF}\u00DF\u00FB\x0F\x7F\u00F2-\u00CF=\u00FF]\u008Fy\u00CA\u0099P\u00E0\u008E\x1Eg\x14\u00C2i8>pT\u00CF{\u00F3\u00DB\u008F|\u00CDG>q\u00E4q7\u00DC8\x7F\u00EC\u00E6Qy\u00F4\u00E7\u00AF_\u00BB\u00E8\u00E6\u0083\u0082\u00D6\u00D7c\t\u00B7\u00DE-o?\u00EAh\u00DE\u00C08K*uu\u00F9)\u00C4\u00A55[\u00A65\u00E1\u0095\u0094\x1E^,\u00CB\u00BET$c\u00F6\x16`\u00898\u00E0J\x02\u008A\u00D6\x14M\u009B\t|o\u0096Y\x000H\u00C7\\\x17\u00D8\u00BBg\u00C4\x05\x17m_{\u00F6Y\u00F3\x0F\x1E\u00B8\u00E0\u00E0\x07\x1E\u00F2\u0088s\u00DE\u00FF\u00DC\x7Fz\u00F6\u009F]\u00FCP\u00B9\u00F1\u00F6\x7F\u00BAg\u00C6\u00DF6\u00CE(\u0084;\u00C9\u00F8\u00C4!\u00BD\u00F0w\u00FE\u00E8\u00E6\u0087\u00BF\u00E7\u00A3\u00FA\u00B0\u009B\u00BE\u00D8\x1E|\u00F0\u00E8\u00F8\u00A0qs\u00FD\x01_:\u0084\u008B\u00AE\u00F9\u00E2R\u0096\u00DB\u00EB\u00C0\u00B8\x11K\u00C8G\u00C6\u0080)\u00BD\x0Et_\x1C\u00D6\u00BAC\x19zo\x1C\x05\u008D\x05`\u00C4S\u00A3p\u00CFA<,\x19\u00E0\u00D4kXH\u00A2\u009EZ\x1C\u00A0\x18t\u0089\u00F9p\x14\u00E7\u009E\u00DFt\u00FF\u00DE\u00E1\u00DA=\u00B3\u00ADO\u009E\u00BDG\u00AF\u00D8\x7F`\u00FC\u00ABG>\u00BA\u00FF\u00E5\u00B7?\u00E7\u00A2\u008F\u00DE\u00EF\u00C1r\u00DD\x1D\u00F8\u00F8\u00CE\u008C/s\u009CQ\bw\u00F2q\u00D5\u00A8g\u00BD\u00FFS\u00F8\u00CA\u00F7\u00BD\u00EB\u00E6\u00FB\\\u00FD\u00B9\u00E5\u00C5\u009F\u00BFe\u00F3^\u0087\x0F\u00EE\u00B9\u00C7\u00F6\u0091\u00D9E}G\u00CE_.\x16\x07\x16\u0090s\u0097\u00DB\u00B3\u00BD[Gt\u00D8\u00DC\u009Ec\u00B15\u00C3r{\u0080.\x15:6\u00E8\u00C2\u00B3\x1A\u00EA\x1D\u008A\u00A0\u0098\r#\u00D6\u00D0\u00B1\u00BE\u00B6\u00C4\u00AE\u008D>\u00CEf\u008B[f\u00D0/\x0Em\u00FD\u00A6a\u00BE\u00BCa>\u00C7\u00B5{\u00F6}\u00F1\u009A\u008B\u00F6\u00AE_}\u00EF\u008B\u00CF\u00BA\u00EA\u00D2'\u009F\u00F3\u00D9\u00C7=\x11\u009F\u00B9\u00F0^r\u00E4\u008E~&g\u00C6\u00AD\x1F\u00FF\x1F\x00\u00F3\u00AA\r=e\u0082\u0081\x00\x00\x00\x00IEND\u00AEB`\u0082" ; + this.slash = "/" + var targetFolder = new Folder(Folder.userData.fullName +this.slash+ "Aescripts"+this.slash+"colorPicker"); + !targetFolder.exists && targetFolder.create(); + + this.settingFile = new File(targetFolder.fullName + this.slash + "colorPicker.xml"); + if(!this.settingFile.exists){ + this.settingFile.open("w"); + this.settingFile.write(""); + this.settingFile.close(); + } + + this.haveSetting = function(name){ + this.settingFile.open("r"); + var content = this.settingFile.read(); + this.settingFile.close(); + return content.toString().indexOf("<"+name+">") !=-1; + } + + this.getSetting = function(name){ + this.settingFile.open("r"); + var xml= new XML( this.settingFile.read() ); + this.settingFile.close(); + return xml[name].toString(); + } + + this.getSettingAsBool = function(name){ + var result = this.getSetting(name); + return result == "true" ? true:false; + } + + this.saveSetting = function(name,value){ + this.settingFile.open("r"); + var xml= new XML( this.settingFile.read() ); + this.settingFile.close(); + var isOk = true; + try{ + xml[name] = value.toString(); + }catch(err){ + isOk = false; + } + this.settingFile.open("w"); + this.settingFile.write(xml); + this.settingFile.close(); + return isOk; + } + +} + $.global.colorPicker = colorPicker; + return colorPicker; diff --git a/src/library/filePath.jsx b/src/library/filePath.jsx new file mode 100644 index 0000000..afc1083 --- /dev/null +++ b/src/library/filePath.jsx @@ -0,0 +1,14 @@ +//@include "OS.jsx" + +function joinPath(components){ + var pathSeparator = getPathSeparatorSymbol(); + return components.join(pathSeparator); +}; + +function getPathSeparatorSymbol(){ + return (OS.isWindows() ? "\\":"/"); +}; + +function getUserDataFolderPath(){ + return Folder.userData.fsName; +}; diff --git a/src/library/km_helperFunctions.jsx b/src/library/km_helperFunctions.jsx new file mode 100644 index 0000000..91c1b76 --- /dev/null +++ b/src/library/km_helperFunctions.jsx @@ -0,0 +1,383 @@ +/** + * Kyle Harter function library + * @module km-helper-functions + * @author kylenmotion@gmail.com + * @returns {object} returns exported modules to be used in other jsx files + */ + +var kmFunction = (function () { + /** + * gets current project + * @function getProj + * @returns {object} current project + */ + function getProj() { + var proj = app.project; + if (!proj) { + alert( + "Whoops!\rYou don't have any projects open. Open a current project or create a new project and try again.", + ); + return; + } + + return proj; + } + + /** + * gets the active comp + * @function getActiveComp + * @param {Project} proj - the current AE project + * @returns {CompItem} active composition object in ae project + */ + + function getActiveComp(proj) { + var activeComp = proj.activeItem; + + if (!(activeComp && activeComp instanceof CompItem)) { + alert( + "Whoops!\rYou don't have an comp item active. Open a comp item or select a comp item from the project panel and try again.", + ); + return; + } + + return activeComp; + } + + /** gets selected comps as well as their names and unique ids in the project panel + * @function getSelectedComps + * @param {Project} proj - the current AE project + * @returns {object} an object that stores arrays of selected comp objects, names, and ids + */ + + function getSelectedComps(proj) { + var comps = []; + var compNames = []; + var compIds = []; + + var selectedItems = proj.selection; + + if (selectedItems.length < 1) { + alert( + "Whoops!\rYou don't have any project items selected. Select at least 1 project item and try again.", + ); + return; + } + + var found = false; + + for (var i = 0; i < selectedItems.length; i++) { + var item = selectedItems[i]; + if (item instanceof CompItem) { + found = true; + comps.push(item); + compNames.push(item.name); + compIds.push(item.id); + } + } + + if (!found) { + alert( + "Whoops!\rYou don't have any comp items selected. Select atleast 1 comp item and try again.", + ); + return; + } + + return { + comps: comps, + compNames: compNames, + compIds: compIds, + }; + } + + /** + * converts a hex code into a usable RGB array + * @function hexToRGB + * @param {string} hexValue - a 6-character string that makes up a hex code. Can be used with or without a '#'. + * @returns {Array} a 3 element array that makes up a full RGB value + */ + function hexToRGB(hexValue) { + var hexTrim = hexValue.trim(); + var hexString = hexTrim; + var finalHex = hexString.replace(/[#]/g, ""); + var hexColor = "0x" + finalHex; + var r = hexColor >> 16; + var g = (hexColor & 0x00ff00) >> 8; + var b = hexColor & 0xff; + + return [r / 255, g / 255, b / 255]; + } + + /** + * gets selected layers in comp + * @function getSelectedLayers + * @param {CompItem} comp - current active or selected comp + * @return {Array} returns an array of selected layers in comp + */ + function getSelectedLayers(comp) { + if (!comp) return; + var selLayers = comp.selectedLayers; + if (selLayers.length < 1) { + alert( + "Whoops!\rYou don't have any layers selected in your comp. Select atleast 1 layer and try again.", + ); + return; + } + + return selLayers; + } + + /** + * gets selected properties on a layer + * @function getSelectedProperties + * @param {LayerCollection} layers - current selected layers in active comp + * @return {array} selected keyframeable properties on a layer + */ + + function getSelectedProperties(layers) { + if (!layers) return; + + var selLayerProps = []; + var found = false; + for (var b = 0; b < layers.length; b++) { + var layer = layers[b]; + var selProps = layer.selectedProperties; + for (var i = 0; i < selProps.length; i++) { + var prop = selProps[i]; + if (prop.propertyType === PropertyType.PROPERTY && prop.canVaryOverTime) { + found = true; + selLayerProps.push(prop); + } + } + } + + if (!found) { + alert( + "Whoops!\rYou don't have any keyframeable layer properties selected. Select atleast 1 keyframeable layer property and try again", + ); + return; + } + + return selLayerProps; + } + + /** + * gets selected keyframes on layers in the comp + * + * @param {Object} props - selected properties on selected layers + * @return {Object} an object that stores arrays of selected keyframe objects, times, and values + */ + function getSelectedKeyframes(props) { + if (!props) return; + var selKeys = []; + var keyInSpatialTan = []; + var keyInTemporalEase = []; + var keyOutSpatialTan = []; + var keyOutTemporalEase = []; + var keyLabel = []; + var selKeyVal = []; + var found = false; + for (var i = 0; i < props.length; i++) { + var prop = props[i]; + if (prop.selectedKeys.length > 0) { + found = true; + for (var k = 0; k < prop.selectedKeys.length; k++) { + var keyIndex = prop.selectedKeys[k]; + selKeys.push(keyIndex); + selKeyVal.push(prop.keyValue(keyIndex)); + keyInSpatialTan.push(prop.keyInSpatialTangent(keyIndex)); + keyInTemporalEase.push(prop.keyInTemporalEase(keyIndex)); + keyOutSpatialTan.push(prop.keyOutSpatialTangent(keyIndex)); + keyOutTemporalEase.push(prop.keyOutTemporalEase(keyIndex)); + keyLabel.push(prop.keyLabel(keyIndex)); + } + } + } + + if (!found) { + alert( + "Whoops!\rYou don't have any keyframes selected. Select atleast 1 keyframe and try again.", + ); + return; + } + + return { + selKeys: selKeys, + selKeyVal: selKeyVal, + keyInSpatialTan: keyInSpatialTan, + keyInTemporalEase: keyInTemporalEase, + keyOutSpatialTan: keyOutSpatialTan, + keyOutTemporalEase: keyOutTemporalEase, + keyLabel: keyLabel, + }; + } + + /** + * gets or creates a folder object based on the search term of the match string paramater + * @function getOrCreateFolder + * @param {object} proj - current AE project object + * @param {string} folderName - a valid string used to search for a folder name + * @return {object} - the folder object that was either created or found using the search parameter + */ + + function getOrCreateFolder(proj, folderName) { + if (!proj) return; + if (typeof folderName !== "string") { + folderName = folderName.toString(); + } + + var folder = null; + for (var i = 1; i <= proj.numItems; i++) { + var item = proj.item(i); + if (item instanceof FolderItem && item.name === folderName) { + folder = item; + return folder; + } + } + + if (folder === null) { + folder = proj.items.addFolder(folderName); + } + return folder; + } + + /** + * + * @function traverseFolder + * @param {object} container - object with a number of items greater than 0 + * @param {Function} callback + * @return {null} + */ + function traverseFolder(container, callback) { + for (var i = 1; i <= container.numItems; i++) { + var item = container.item(i); + + var result = callback(item); + if (result) return result; + + if (item instanceof FolderItem) { + var nested = traverseFolder(item, callback); + if (nested) return nested; + } + } + return null; + } + + /** + * + * @function traverseProperties + * @param {CompItem} comp - object with a number of items greater than 0 + * @param {Function} callback - + * @return {null} + */ + function traverseProperties(layer, callback) { + for (var b = 1; b <= layer.numProperties; b++) { + var prop = layer.property(b); + callback(prop); + if (prop.numProperties > 0) { + traverseProperties(prop, callback); + } + } + return null; + } + + /** + * + * @function traverseComps + * @param {CompItem} comp - object with a number of items greater than 0 + * @param {Function} callback + * @return {null} + */ + function traverseComps(comp, callback, visited) { + if (!visited) visited = {}; + + if (visited[comp.id]) return; + + visited[comp.id] = true; + + for (var i = 1; i <= comp.numLayers; i++) { + var layer = comp.layer(i); + callback(layer); + if (layer.source instanceof CompItem) { + traverseComps(layer.source, callback, visited); + } + } + return null; + } + + /** + * finds comp by name via recursion + * @function findCompByName + * @param {string} name - a valid string used to search for a comp name + * @return {CompItem} + */ + + function findCompByName(name) { + return traverseFolder(app.project, function (item) { + if (item instanceof CompItem && item.name === name) { + return item; + } + }); + } + + /** + * adds selected comps to the render queue and applies output module and token templates + * @function addCompsToRQ + * @param {CompItem} comps - an array of selected compositions in the project panel or the current active comp + * @param {String} module - a string representing the Output Module Template + * @param {String} tokenPath - a string representing the Output Destination Render Token + * @param {Boolean} imageFlag - a boolean that determines if the output is a still frame output or full sequence + * @returns nothing + * + */ + function addCompsToRQ(comps, module, tokenPath, imageFlag) { + var proj = app.project; + var renderQueue = proj.renderQueue; + + while (renderQueue.numItems > 0) { + renderQueue.item(1).remove(); + } + + for (var i = 0; i < comps.length; i++) { + var comp = comps[i]; + if (imageFlag) { + comp.workAreaStart = 0; + comp.workAreaDuration = comp.frameDuration * 1; + } else { + comp.workAreaStart = 0; + comp.workAreaDuration = comp.duration; + } + for (var b = 1; b <= proj.numItems; b++) { + var item = proj.item(b); + if (item.id === comp.id) { + var rqItem = renderQueue.items.add(comp); + var rqOM = rqItem.outputModule(1); + rqOM.applyTemplate(module); + var fileInfo = { + "Output File Info": { + "Full Flat Path": tokenPath, + }, + }; + rqOM.setSettings(fileInfo); + // rqOM.file = new File(tokenPath); + } + } + } + return; + } + + return { + getProj: getProj, + getActiveComp: getActiveComp, + getSelectedComps: getSelectedComps, + hexToRGB: hexToRGB, + getSelectedLayers: getSelectedLayers, + getSelectedProperties: getSelectedProperties, + getOrCreateFolder: getOrCreateFolder, + addCompsToRQ: addCompsToRQ, + getSelectedKeyframes: getSelectedKeyframes, + traverseFolder: traverseFolder, + traverseProperties: traverseProperties, + traverseComps: traverseComps, + findCompByName: findCompByName, + }; +})(); diff --git a/src/library/km_scriptUI_functions.jsx b/src/library/km_scriptUI_functions.jsx new file mode 100644 index 0000000..11fc934 --- /dev/null +++ b/src/library/km_scriptUI_functions.jsx @@ -0,0 +1,75 @@ +/** + * Kyle Harter's Script UI library + * @module km-scriptUI-functions + * @author Kyle Harter + * @returns {object} returns exported modules to be used in other jsx files + */ + +var kmScriptUI = (function(){ + + var scriptName = "insert-script name"; + + /** + * shows help window for script + * @function showHelp + * @return {Object} a script UI window + */ + + function showHelp(){ + + var settingsWindow = new Window("palette", "About " + scriptName, undefined, {closeButton: true, resizeable: true}); + settingsWindow.orientation = 'column'; + settingsWindow.alignChildren = ["fill", "fill"]; + + var editTextGroup = settingsWindow.add("group", undefined, "Middle Info Group"); + editTextGroup.orientation = 'column'; + editTextGroup.alignChildren = ["left", "top"]; + var helpMessage = +'ABOUT '+scriptName.toUpperCase()+'\r\r\ +INSERT INFO ABOUT SCRIPT HERE\r\r\ +------------------------\ +HOW TO USE '+scriptName.toUpperCase()+':\r\r\ +STEP ##: STEP DETAIL\r\ +INSERT STEP DETAIL HERE\r\r\ +-----------\r\ +' +var textBox = editTextGroup.add("edittext", undefined, helpMessage, {multiline: true, readonly: true ,scrollable: true}); +textBox.justify = "left"; +textBox.alignment = ["fill","fill"]; +textBox.preferredSize = [600,200]; + +var creatorInfo = +''+scriptName+' v1.0\r\ +Script created by Kyle Harter\r\ +www.kylemotion.com' + + + var bottomGroup = settingsWindow.add("group", undefined, "bottomGroup"); + bottomGroup.orientation = "row"; + bottomGroup.alignChildren = ["fill", "center"]; + var creatorGroup = bottomGroup.add("group", undefined, "Creator Info Group") + var creatorStatic = creatorGroup.add("statictext", undefined, creatorInfo, {multiline: true}); + var closeGroup = bottomGroup.add("group", undefined, "Close Group"); + closeGroup.alignChildren = ["right", "center"]; + var closeButton = closeGroup.add("button", undefined, "Close"); + closeButton.preferredSize = [-1, 30]; + + + creatorStatic.addEventListener("mousedown", function () { + var userOS = OS + var launchCode = userOS.openUrl("https://www.kylemotion.com/") + }); + + closeButton.addEventListener("mousedown", function(){settingsWindow.close()}) + + + settingsWindow.hide(); + settingsWindow.show(); + + + } + + return { + showHelp: showHelp + } +})() \ No newline at end of file diff --git a/src/library/km_systemFunctions.jsx b/src/library/km_systemFunctions.jsx new file mode 100644 index 0000000..92b603b --- /dev/null +++ b/src/library/km_systemFunctions.jsx @@ -0,0 +1,70 @@ +/** + * Kyle Harter systems function library + * @module km-system-functions + * @author kylenmotion@gmail.com + * @returns {object} returns exported modules to be used in other jsx files + */ + +var kmSystemsLib = (function () { + /** + * + * + * @param {String} folderPath - valid file system string + * @return {Folder} returns folder object + */ + function getSystemFolder(folderPath) { + if (!folderPath) { + alert( + "Whoops!\rYou didn't enter a valid folder path string. Enter a valid folder path string and try again.", + ); + return; + } + + var folder = new Folder(folderPath); + + if (!folder.exists) { + folder.create(); + } + + return folder; + } + + /** + * + * + * @param {File} file - file system object + * @param {Array} contents - an array that holds an object of data to be logged + * @param {String} logTitle - valid string to be placed in the title of the log file + * @return {String} Contents of the log file + */ + function writeLogFile(file, contents, logTitle) { + var logTitle = "<----- " + logTitle + "----->"; + var newDate = new Date(); + var systemLogTime = newDate.toString(); + var logFile = logTitle + "\r" + "Logged At: " + systemLogTime + "\r\r"; + + for (var i = 0; i < contents.length; i++) { + var currentObj = contents[i]; + for (var key in currentObj) { + if (currentObj.hasOwnProperty(key)) { + logFile += key + ": " + currentObj[key] + "\r"; + } + } + } + + if (!file) { + file.open("w"); + } else { + file.open("a"); + } + file.write(logFile); + file.close(); + + return logFile; + } + + return { + getSystemFolder: getSystemFolder, + writeLogFile: writeLogFile, + }; +})(); diff --git a/src/library/km_textAnimators.jsx b/src/library/km_textAnimators.jsx new file mode 100644 index 0000000..8336afc --- /dev/null +++ b/src/library/km_textAnimators.jsx @@ -0,0 +1,73 @@ + + + +/** + * A function library for adding text animators on top of text layers + * + * @author Kyle Harter + * +*/ + + +var KMTextAnimatorsLib = (function(){ + + var matchNames = { + animator: "ADBE Text Animator", + + props: { + anchorPoint: "ADBE Text Anchor Point 3D" , + position: "ADBE Text Position 3D" , + scale: "ADBE Text Scale 3D" , + skew: "ADBE Text Skew" , + skewAxis: "ADBE Text Skew Axis" , + rotation: "ADBE Text Rotation", + opacity: "ADBE Text Opacity" + }, + + }; + + + + /** + * adds a text animator group to a text layer along with a range selector + * + * @param {TextLayer} textLayer + * @param {string} animator - matchNames.animatorName + * @return {Property} the added text animation property + */ + function addBasicAnimator(textLayer, animator){ + var anim = textLayer.property("ADBE Text Properties") + .property("ADBE Text Animators") + .addProperty(animator); + + + var selector = anim.property("ADBE Text Selectors").addProperty("ADBE Text Selector"); + + return anim + + } + + + + /** + * adds a text animator property to a text animator group + * + * @param {object} anim - the text animator group established in "addBasicAnimator(textLayer,animator)" + * @param {string} prop - matchNames.propName + * @return {Property} added text animator property + */ + function addAnimProp(anim,prop){ + var animPosGroup = anim.property("ADBE Text Animator Properties"); + var textAnimProp = animPosGroup.addProperty(prop); + return textAnimProp + } + + + + return { + matchNames: matchNames, + addBasicAnimator: addBasicAnimator, + addAnimProp: addAnimProp + }; +}()); + diff --git a/src/library/km_utilityFunctions.jsx b/src/library/km_utilityFunctions.jsx new file mode 100644 index 0000000..bb0057d --- /dev/null +++ b/src/library/km_utilityFunctions.jsx @@ -0,0 +1,316 @@ +//@include "./OS.jsx" + +var kmUtilityFunctions = (function (){ + + /** + * A function that will convert a file into a binary string. Useful fo displaying images in script UI + * @function getBinaryFile + * @return {File} + */ + function fileToBinaryString() { + + var input = File.openDialog("choose a file to convert to source code");//new File("path/to/my/file") + if (input === null) return; + + var rawData = readBinaryFile(input); + var variableName = stringToValidVariableName(input.name); + var sourceCode = convertRawDataToSourceCode(rawData, variableName); + writeTextFile(input.fsName + ".jsx", sourceCode); + + + function convertRawDataToSourceCode(rawData, variableName) { + var contentAsString = rawData.toSource(); + var sourceCode = "var " + variableName + " = " + contentAsString + ";\n"; + return sourceCode; + }; + + function readBinaryFile(file) { + file.encoding = "BINARY"; + file.open("r"); + var content = file.read(); + file.close(); + return content; + }; + + function writeTextFile(filePath, content) { + var output = new File(filePath); + output.open("w"); + output.encoding = "UTF-8"; + output.write(sourceCode); + output.close(); + alert("Success!\rYou're jsx file is located here:\r\r" + output.fsName); + var binaryLocation = output.parent; + binaryLocation.execute(); + }; + + function stringToValidVariableName(string) { + return string.replace(/\W/g, "") // remove anything that is not letter, digit or _ + .replace(/^\d+/, ""); // remove any digits at the beginning + }; +} + + + /** + * A function to load CSV data and bring in data from an array + * + * @param {object} options - Encoding object to determing encoding type. Acceptable keys are 'encoding' or 'separatorSymbol'. Ex:{encoding: "ascii", separatorSymbol: ;}; + * @return {Array} - CSV Data from a chosen CSV file + */ + function loadCSVFromFile(options){ + var file = File.openDialog("Select a .CSV file to parse data from") + function parseCSVString(csvString, options){ + options = options || {}; + var separatorSymbol = options.separatorSymbol || ","; + + var currentRow = 0; + var currentColumn = -1; // will be increased to 0 during first loop iteration + var thisCell = ""; + var i; + var token; + var cellStart = true; + var insideQuote; + + function nextTokenLookAhead(){ + var nextTokenId = i + 1; + return (nextTokenId + * @version 1.0.0 + * + * @license This script is provided "as is," without warranty of any kind, expressed or implied. In + * no event shall the author be held liable for any damages arising in any way from the use of this + * script. + * + * + * + * + */ + +(function () { + //@include "../library/km_helperFunctions.jsx"; + //@include "../library/km_scriptUI_functions.jsx"; + //@include "../library/km_utilityFunctions.jsx"; + //@include "../library/km_textAnimators.jsx"; + //@include "../library/km_systemFunctions.jsx"; + try { + app.beginUndoGroup("Layer to comp dur"); + var km = kmFunction; + var kmScript = kmScriptUI; + var kmUtils = kmUtilityFunctions; + var kmTextAnims = KMTextAnimatorsLib; + var kmSystems = kmSystemsLib; + + var activeComp = km.getActiveComp(app.project); + if(!activeComp) return; + var selLayers = km.getSelectedLayers(activeComp); + if(!selLayers) return; + + + setCompDurationFromLayer(activeComp,selLayers[0]) + + } catch (error) { + alert( + "An error occured on line: " + + error.line + + "\nError message: " + + error.message, + ); + } finally { + // this always runs no matter what + app.endUndoGroup(); + } + + function setCompDurationFromLayer(comp,layer){ + var layerStart = layer.startTime; + var layerIn = layer.inPoint; + var layerOut = layer.outPoint; + var layerShiftTime; + comp.duration = layerOut-layerIn; + for(var i = 1; i<=comp.numLayers; i++){ + var compLayer = comp.layer(i); + $.writeln("Layer Start Time: " + layerIn) + if(layerIn > 0){ + layerShiftTime = -layerIn; + $.writeln("Layer Shift Time: " + layerShiftTime) + } else { + layerShiftTime = layerIn; + } + compLayer.startTime += layerShiftTime + } + + + return comp + } +})(); diff --git a/src/scripts/km-layer-labeler.jsx b/src/scripts/km-layer-labeler.jsx new file mode 100644 index 0000000..82d2766 --- /dev/null +++ b/src/scripts/km-layer-labeler.jsx @@ -0,0 +1,134 @@ +/** + * @description a script wiyh a UI that will do something really cool in AE + * @name km-layer-labeler + * @author Kyle Harter + * @version 1.0.0 + * + * @license This script is provided "as is," without warranty of any kind, expressed or implied. In + * no event shall the author be held liable for any damages arising in any way from the use of this + * script. + * + * + * + * +*/ + + +(function(thisObj){ + + //@include "../library/km_helperFunctions.jsx"; + //@include "../library/km_scriptUI_functions.jsx"; + //@include "../library/km_utilityFunctions.jsx"; + + var scriptName = "km-layer-labeler"; + + createUI(thisObj) + + function createUI(thisObj){ + var kmUtils = kmUtilityFunctions; + var file = new File('/Users/Shared/km/km-layer-labels.json'); + var config = kmUtils.readJSONFile(file); + var btnSize = [100,25] + + var win = thisObj instanceof Panel + ? thisObj + : new Window("window", scriptName, undefined, { + resizeable: true + }); + + win.orientation = 'column'; + win.alignChildren = ["left", "top"]; + + var mainGroup = win.add("group", undefined, "Main Group"); + mainGroup.orientation = 'column'; + + if(config && config.labels && config.labels.length > 0){ + var buttonsPerRow = 4; + var labelGroup = mainGroup.add("group", undefined, "Labels Group"); + labelGroup.orientation = "column"; + labelGroup.alignChildren = ["left", "top"]; + + for(var i = 0; i + * @version 1.0.0 + * + * @license This script is provided "as is," without warranty of any kind, expressed or implied. In + * no event shall the author be held liable for any damages arising in any way from the use of this + * script. + * + * + * + * + */ + +(function () { + //@include "../library/km_helperFunctions.jsx"; + //@include "../library/km_scriptUI_functions.jsx"; + //@include "../library/km_utilityFunctions.jsx"; + //@include "../library/km_textAnimators.jsx"; + //@include "../library/km_systemFunctions.jsx"; + try { + app.beginUndoGroup("what does this script do?"); + var km = kmFunction; + var kmScript = kmScriptUI; + var kmUtils = kmUtilityFunctions; + var kmTextAnims = KMTextAnimatorsLib; + var kmSystems = kmSystemsLib; + + var activeComp = km.getActiveComp(km.getProj()); + + var selLayers = km.getSelectedLayers(activeComp); + nullNamefromFirstChild(selLayers) + + } catch (error) { + alert( + "An error occured on line: " + + error.line + + "\nError message: " + + error.message, + ); + } finally { + // this always runs no matter what + app.endUndoGroup(); + } + + function nullNamefromFirstChild(layers) { + var found = false + for(var i = 0; i + * @version 1.0.0 + * + * @license This script is provided "as is," without warranty of any kind, expressed or implied. In + * no event shall the author be held liable for any damages arising in any way from the use of this + * script. + * + * + * + * +*/ + + +(function(thisObj){ + + //@include "../library/km_helperFunctions.jsx"; + //@include "../library/km_scriptUI_functions.jsx"; + //@include "../library/km_utilityFunctions.jsx"; + //@include "../library/km_textAnimators.jsx"; + //@include "../library/km_systemFunctions.jsx"; + + var scriptName = "km-layer-props-copy-paste"; + + createUI(thisObj) + + function createUI(thisObj){ + var win = thisObj instanceof Panel + ? thisObj + : new Window("window", scriptName, undefined, { + resizeable: true + }) + + win.orientation = 'column'; + win.alignChildren = ["left", "top"]; + + var mainGroup = win.add("group", undefined, "Main Group"); + mainGroup.orientation = 'column'; + + + var copyPasteGroup = mainGroup.add("group", undefined, "Copy Paste Group"); + copyPasteGroup.orientation = 'row'; + var copyButton = copyPasteGroup.add("button", undefined, "Copy"); + copyButton.preferredSize = [-1,30]; + var pasteButton = copyPasteGroup.add("button", undefined, "Paste"); + pasteButton.preferredSize = [-1,30]; + + var layerInfoGroup = mainGroup.add('group', undefined, 'Copy Info'); + layerInfoGroup.alignChildren = ['left','top']; + var layerInfoText = layerInfoGroup.add('staticText', undefined, 'text'); + layerInfoText.characters = 50; + + + var layerPropData = [{ + label: null, + name: '', + comment: '' + }]; + + + copyButton.onClick = function(){ + try { + app.beginUndoGroup("What script does"); + + var km = kmFunction; + var kmScript = kmScriptUI; + var kmUtils = kmUtilityFunctions; + var kmTextAnims = KMTextAnimatorsLib; + + var activeComp = km.getActiveComp(km.getProj()); + var selLayers = km.getSelectedLayers(activeComp); + + + copyProps(selLayers) + + layerInfoText.text = layerPropData.length + ' layers copied from ' + activeComp.name; + + } catch(error) { + alert("An error occured on line: " + error.line + "\nError message: " + error.message); + } finally { + // this always runs no matter what + app.endUndoGroup() + } + + } + + pasteButton.onClick = function(){ + try { + app.beginUndoGroup("What script does"); + + var km = kmFunction; + var kmScript = kmScriptUI; + var kmUtils = kmUtilityFunctions; + var kmTextAnims = KMTextAnimatorsLib; + + var activeComp = km.getActiveComp(km.getProj()); + var selLayers = km.getSelectedLayers(activeComp); + + pasteProps(selLayers) + + layerInfoText.text = layerPropData.length + ' layers pasted to ' + activeComp.name; + + } catch(error) { + alert("An error occured on line: " + error.line + "\nError message: " + error.message); + } finally { + // this always runs no matter what + app.endUndoGroup() + } + + } + + + function copyProps(selLayers){ + layerPropData = []; + + for(var i = 0; i + * @version 1.0.0 + * + * @license This script is provided "as is," without warranty of any kind, expressed or implied. In + * no event shall the author be held liable for any damages arising in any way from the use of this + * script. + * + * + * + * + */ + +(function () { + //@include "../library/km_helperFunctions.jsx"; + //@include "../library/km_scriptUI_functions.jsx"; + //@include "../library/km_utilityFunctions.jsx"; + //@include "../library/km_textAnimators.jsx"; + //@include "../library/km_systemFunctions.jsx"; + try { + app.beginUndoGroup("Moves each comp CTI to middle of comp timeline for easy viewing when viewing comp"); + var km = kmFunction; + var kmScript = kmScriptUI; + var kmUtils = kmUtilityFunctions; + var kmTextAnims = KMTextAnimatorsLib; + var kmSystems = kmSystemsLib; + + var proj = km.getProj(); + + + + batchCTICompCenter(proj) + + } catch (error) { + alert( + "An error occured on line: " + + error.line + + "\nError message: " + + error.message, + ); + } finally { + // this always runs no matter what + app.endUndoGroup(); + } + + function batchCTICompCenter(proj) { + var compsArray = [] + km.traverseFolder(proj, function (item){ + if(item instanceof CompItem){ + item.time = item.duration/2; + compsArray.push({ + compItem: item, + compName: item.name + }) + } + }) + + var msg = 'Analysis is complete!\r\r' + compsArray.length + ' comps\' CTIs were placed in the middle of their timelines.'; + + alert(msg) + + return; + } +})(); diff --git a/src/scripts/km-trim-selected-comps-work_area.jsx b/src/scripts/km-trim-selected-comps-work_area.jsx new file mode 100644 index 0000000..39765e8 --- /dev/null +++ b/src/scripts/km-trim-selected-comps-work_area.jsx @@ -0,0 +1,60 @@ +/** + * @description a headless script to do something cool in AE + * @name km-trim-selected-comps-work_area + * @author Kyle Harter + * @version 1.0.0 + * + * @license This script is provided "as is," without warranty of any kind, expressed or implied. In + * no event shall the author be held liable for any damages arising in any way from the use of this + * script. + * + * + * + * + */ + +(function () { + //@include "../library/km_helperFunctions.jsx"; + //@include "../library/km_scriptUI_functions.jsx"; + //@include "../library/km_utilityFunctions.jsx"; + //@include "../library/km_textAnimators.jsx"; + //@include "../library/km_systemFunctions.jsx"; + try { + app.beginUndoGroup("what does this script do?"); + var km = kmFunction; + var kmScript = kmScriptUI; + var kmUtils = kmUtilityFunctions; + var kmTextAnims = KMTextAnimatorsLib; + var kmSystems = kmSystemsLib; + + var comps = km.getSelectedComps(km.getProj()).comps; + + var trimmedComps = trimCompsWorkArea(comps); + + alert('Comps Trimmed: ' + trimmedComps) + + } catch (error) { + alert( + "An error occured on line: " + + error.line + + "\nError message: " + + error.message, + ); + } finally { + // this always runs no matter what + app.endUndoGroup(); + } + + function trimCompsWorkArea(comps) { + var compsTrimmed = 0 + for(var i = 0; i < comps.length; i++){ + var comp = comps[i]; + comp.openInViewer(); + app.executeCommand(2360); + comp.time = comp.duration/2; + compsTrimmed++ + } + + return compsTrimmed + } +})(); diff --git a/src/templates/_km-template-headless.jsx b/src/templates/_km-template-headless.jsx new file mode 100644 index 0000000..ada4afe --- /dev/null +++ b/src/templates/_km-template-headless.jsx @@ -0,0 +1,45 @@ +/** + * @description a headless script to do something cool in AE + * @name km-scriptname + * @author Kyle Harter + * @version 1.0.0 + * + * @license This script is provided "as is," without warranty of any kind, expressed or implied. In + * no event shall the author be held liable for any damages arising in any way from the use of this + * script. + * + * + * + * + */ + +(function () { + //@include "./library/km_helperFunctions.jsx"; + //@include "./library/km_scriptUI_functions.jsx"; + //@include "./library/km_utilityFunctions.jsx"; + //@include "./library/km_textAnimators.jsx"; + //@include "./library/km_systemFunctions.jsx"; + try { + app.beginUndoGroup("what does this script do?"); + var km = kmFunction; + var kmScript = kmScriptUI; + var kmUtils = kmUtilityFunctions; + var kmTextAnims = KMTextAnimatorsLib; + var kmSystems = kmSystemsLib; + } catch (error) { + alert( + "An error occured on line: " + + error.line + + "\nError message: " + + error.message, + ); + } finally { + // this always runs no matter what + app.endUndoGroup(); + } + + function runScript() { + alert("Script is run"); + return; + } +})(); diff --git a/src/templates/_km-templatename-scriptUI.jsx b/src/templates/_km-templatename-scriptUI.jsx new file mode 100644 index 0000000..a5797ad --- /dev/null +++ b/src/templates/_km-templatename-scriptUI.jsx @@ -0,0 +1,94 @@ +/** + * @description a script wiyh a UI that will do something really cool in AE + * @name km-scriptname + * @author Kyle Harter + * @version 1.0.0 + * + * @license This script is provided "as is," without warranty of any kind, expressed or implied. In + * no event shall the author be held liable for any damages arising in any way from the use of this + * script. + * + * + * + * +*/ + + +(function(thisObj){ + + //@include ".../library/km_helperFunctions.jsx; + //@include ".../library/km_scriptUI_functions.jsx"; + //@include ".../library/km_utilityFunctions.jsx"; + //@include ".../library/km_textAnimators.jsx"; + //@include ".../library/km_systemFunctions.jsx"; + + var scriptName = "Script Name"; + + createUI(thisObj) + + function createUI(thisObj){ + var win = thisObj instanceof Panel + ? thisObj + : new Window("window", scriptName, undefined, { + resizeable: true + }) + + win.orientation = 'column'; + win.alignChildren = ["left", "top"]; + + var mainGroup = win.add("group", undefined, "Main Group"); + mainGroup.orientation = 'column'; + + + var applyGroup = mainGroup.add("group", undefined, "Apply Group"); + applyGroup.orientation = 'row'; + var applyButton = applyGroup.add("button", undefined, "Apply"); + applyButton.preferredSize = [-1,30]; + applyButton.helpTip = "Click: Apply markers to selected layers.\rShift+Click: Apply markers to beginning of a comp." + + + applyButton.onClick = function(){ + try { + app.beginUndoGroup("What script does"); + + var km = kmFunction; + var kmScript = kmScriptUI; + var kmUtils = kmUtilityFunctions; + var kmTextAnims = KMTextAnimatorsLib; + + runScript() + + } catch(error) { + alert("An error occured on line: " + error.line + "\nError message: " + error.message); + } finally { + // this always runs no matter what + app.endUndoGroup() + } + + } + + + function runScript(){ + alert("Script is run") + return + } + + + + + win.onResizing = win.onResize = function (){ + this.layout.resize(); + }; + + if(win instanceof Window){ + win.center(); + win.show(); + } else { + win.layout.layout(true); + win.layout.resize(); + } + + + } + +}(this)) diff --git a/src/types/JavaScript.d.ts b/src/types/JavaScript.d.ts new file mode 100644 index 0000000..ab4dd31 --- /dev/null +++ b/src/types/JavaScript.d.ts @@ -0,0 +1,2731 @@ +/** + * The $ object provides a number of debugging facilities and informational methods. + */ +interface $ { + /** + * The ExtendScript build information. + */ + readonly build: string + + /** + * The ExtendScript build date. + */ + readonly buildDate: Date + + /** + * The character used as the decimal point character in formatted numeric output. + */ + decimalPoint: string + + /** + * The name of the current ExtendScript engine, if set. + */ + readonly engineName: string + + /** + * The most recent run-time error information. + * Assigning error text to this property generates a run-time error; however, the preferred way to generate a run-time error is to throw an Error object. + */ + error: Error + + /** + * The file name of the current script. + */ + readonly fileName: string + + /** + * Gets or sets low-level debug output flags. + * A logical AND of bit flag values: + * 0x0002 (2): Displays each line with its line number as it is executed. + * 0x0040 (64): Enables excessive garbage collection. Usually, garbage collection starts when the number of objects has increased by a certain amount since the last garbage collection. This flag causes ExtendScript to garbage collect after almost every statement. This impairs performance severely, but is useful when you suspect that an object gets released too soon. + * 0x0080 (128): Displays all calls with their arguments and the return value. + * 0x0100 (256): Enables extended error handling (see strict). + * 0x0200 (512): Enables the localization feature of the toString method. Equivalent to the localize property. + */ + flags: number + + /** + * A reference to the global object, which contains the JavaScript global namespace. + */ + readonly global: any + + /** + * A high-resolution timer, measuring the time in microseconds. The timer starts when ExtendScript is + * initialized during the application startup sequence. Every read access resets the timer to Zero. + */ + readonly hiresTimer: number + + /** + * The path for include files for the current script. + */ + readonly includePath: string + + /** + * The current debugging level, which enables or disables the JavaScript debugger. + * One of 0 (no debugging), 1 (break on runtime errors), or 2 (full debug mode). + */ + level: number + + /** + * The current line number of the currently executing script. + */ + readonly line: number + + /** + * Gets or sets the current locale. + * The string contains five characters in the form LL_RR, where LL is an ISO 639 language specifier, and RR is an ISO 3166 region specifier.Initially, this is the value that the application or the platform returns for the current user. You can set it to temporarily change the locale for testing. To return to the application or platform setting, set to undefined, null, or the empty string. + */ + locale: string + + /** + * Set to true to enable the extended localization features of the built-in toString() method. + */ + localize: boolean + + /** + * The ExtendScript memory cache size, in bytes. + */ + memCache: number + + /** + * The current operating system version information. + */ + readonly os: string + + /** + * An array of objects containing information about the display screens attached to your computer. + * Each object has the properties left, top, right, bottom, which contain the four corners of each screen in global coordinates.A property primary is true if that object describes the primary display. + */ + readonly screens: object[] + + /** + * The current stack trace. + */ + readonly stack: string + + /** + * Sets or clears strict mode for object modification. + * When true, any attempt to write to a read-only property causes a runtime error. Some objects do not permit the creation of new properties when true. + */ + strict: any + + /** + * The version number of the ExtendScript engine. + * Formatted as a three-part number and description; for example: "3.92.95 (debug)". + */ + readonly version: string + + /** + * Shows an About box for the ExtendScript component, and returns the text for the box. + */ + about(): string + + /** + * Breaks execution at the current position. + * @param condition A string containing a JavaScript statement to be used as a condition. If the statement evaluates to true or nonzero when this point is reached, execution stops. + */ + bp(condition?: any): void + + /** + * Invokes the platform-specific color selection dialog, and returns the selected color. + * @param color The color to be preselected in the dialog, as 0xRRGGBB, or -1 for the platform default. + */ + colorPicker(color: number): number + + /** + * Loads and evaluates a file. + * @param file The file to load. + * @param timeout An optional timeout in milliseconds. + */ + evalFile(file: File, timeout?: number): any + + /** + * Initiates garbage collection in the ExtendScript engine. + */ + gc(): void + + /** + * Retrieves the value of an environment variable. + * @param name The name of the variable. + */ + getenv(name: string): string + + /** + * Sets the value of an environment variable. + * @param name The name of the variable. + * @param value The value of the variable. + */ + setenv(name: string, value: string): void + + /** + * Suspends the calling thread for a number of milliseconds. + * During a sleep period, checks at 100 millisecond intervals to see whether the sleep should be terminated. This can happen if there is a break request, or if the script timeout has expired. + * @param msecs Number of milliseconds to sleep. + */ + sleep(msecs: number): void + + /** + * Converts this object to a string. + */ + toString(): string + + /** + * Prints text to the Console. + * @param text The text to print. All arguments are concatenated. + */ + write(text: any): void + + /** + * Prints text to the Console, and adds a newline character. + * @param text The text to print. All arguments are concatenated. + */ + writeln(text: any): void +} +declare const $: $ + +interface ObjectConstructor { + readonly prototype: Object + + /** + * Creates and returns a new object of a given type. + * @param what The object type. + */ + new (what: any): Object + (): any + (what: any): any + + /** + * Reports whether an object is still valid. + * @param what The object to check. + */ + isValid(what: Object): boolean +} +declare const Object: ObjectConstructor + +/** + * The base class of all JavaScript objects. + */ +interface Object { + /** + * Points to the constructor function that created this object. + * Note that this property is treated as an XML element in the XML class. + */ + readonly constructor: Function + + /** + * Points to the prototype object for this object. + * Note that this property is treated as an XML element in the XML class. + */ + readonly prototype: Object + + /** + * Retrieves and returns the Reflection object associated with this method or a property. + * Note that this property is treated as an XML element in the XML class. + */ + readonly reflect: Reflection + + /** + * Reports whether a given property is defined with an instance or within the prototype chain. + * @param name The name of the property to check. + */ + hasOwnProperty(name: string): boolean + + /** + * Checks whether the given object is a prototype of this object. + * @param what The object to check. + */ + isPrototypeOf(what: Object): boolean + + /** + * Reports whether a given property is enumerable. + * @param name The name of the property to check. + */ + propertyIsEnumerable(name: string): boolean + + /** + * Creates and returns a string representing this object, localized for the current locale. See toString(). + */ + toLocaleString(): string + + /** + * Creates and returns a string representation of this object. + * This function serializes the object, so that it can, for example, be passed between engines. Pass the returned string back to eval() to recreate the object. Works only with built-in classes. + */ + toSource(): string + + /** + * Creates and returns a string representing this object. + * Many objects (such as Date) override this method in favor of their own implementation. If an object has no string value and no user-defined toString() method, the default method returns [object type], where type is the object type or the name of the constructor function that created the object. + */ + toString(): string + + /** + * Removes the watch function of a property. + * @param name The name of the property to unwatch. + */ + unwatch(name: string): void + + /** + * Retrieves and returns the primitive value of this object. + * If the object has no primitive value, returns the object itself.Note that you rarely need to call this method yourself.The JavaScript interpreter automatically invokes it when encountering an object where a primitive value is expected. + */ + valueOf(): Object + + /** + * Adds a watch function to a property, which is called when the value changes. + * This function can accept, modify, or reject a new value that the user, application, or a script has attempted to place in a property. + * @param name The name of the property to watch. + * @param func The function to be called when the value of this property changes. This function must three arguments, and return as its result the value to be stored in the property. The arguments are: name: the name of the property that changes. oldValue: The old property value. newValue: The new property value that was specified. + */ + watch(name: string, func: Function): void +} + +interface ArrayConstructor { + readonly prototype: Array + + /** + * Creates and returns a new array. + * Takes any number of parameters, which become the elements of the array, or a single value which becomes the length of an empty array. Note that you cannot create a one-element array, as the single parameter value is interpreted as the length. Returns the new array. + * @param arrayLength If no other parameters are passed, the initial length of the empty array. Otherwise, the first element. + * @param values If there is more than one parameter, the array is initialized with the given parameters. + */ + new (arrayLength?: number): any[] + new (arrayLength: number): T[] + new (...values: T[]): T[] + (arrayLength?: number): any[] + (arrayLength: number): T[] + (...values: T[]): T[] +} +declare const Array: ArrayConstructor + +/** + * An array with integer indexing and a length property. + */ +interface Array { + [n: number]: T + + /** + * The length of the array + */ + length: number + + /** + * Returns a new array created by concatenating the given values to the end of the original array. + * The original array is unchanged.If an array is provided as a parameter to concat(), each of its elements are appended as separate array elements at the end of the new array.Returns a new array, the result of concatenation the given values to the end of the original array. + * @param values Any number of values to be added to the end of the array. Can also be arrays. + */ + concat(...values: T[][]): T[] + + /** + * Joins all elements of the array into a string; optionally, each element is separated by delimiter. + * Returns the string containing the joined elements and delimiters. + * @param delimiter A string used to separate each element of the array. If omitted, the array elements are separated with a comma. + */ + join(delimiter?: string): string + + /** + * Removes the last element from the array, decreases the length by 1, and returns the value of the element. + * Returns the value of the deleted array element. + */ + pop(): T | undefined + + /** + * Places one or more values onto the end of the array and increases length by n. + * Returns the new length of the array. + * @param values Any number of values to be pushed onto the end of the array. + */ + push(...values: T[]): number + + /** + * Reverses the order of the elements in the array. + * Returns the reversed array. + */ + reverse(): T[] + + /** + * Removes the first element from the array, decreases the length by 1, and returns the value of the element. + * Returns the value of the deleted array element. + */ + shift(): T | undefined + + /** + * Creates a new array, which contains a subset of the original array's elements. + * The slice begins with the index start, and continues up to, but not including the index, end.If start or end is a negative number, the indexed is resolved counting backwards from the end of the array resulting in the element array[array. length + negativeIndex]. Returns a new array containing elements array[start] through array[end-1]. + */ + slice(start?: number, end?: number): T[] + + /** + * Sorts the elements of the array in place, using the given function to compare to elements. + * If no function is provided, the elements are sorted alphabetically.Returns no return value. + * @param userFunction A user-supplied function of the form userFunction(a, b) which returns less than 0 if a is greater than b, 0 if a and b are equal, and greater than 0 if b is greater than a. + */ + sort(userFunction?: (a: T, b: T) => number): this + + /** + * Removes num elements from the array beginning with index, start. + * Optionally insert new elements beginning at index start.To ensure contiguity, elements are moved up to fill in any gaps.Returns a new array containing any elements deleted from the original array. + * @param start The index of the first element to remove. Negative values are relative to the end of the array. + * @param deleteCount The number of array elements to remove, including start. If omitted, all elements from array index start to the end of the array are removed. + * @param values A list of one or more values to be added to the array starting at index start. Must specify a value for num, to use this argument. + */ + splice(start: number, deleteCount?: number, ...values: T[]): T[] + + /** + * Converts an array to a string and returns the string (localized). + */ + toLocaleString(): string + + /** + * Creates a string representation of this object that can be fed back to eval() to re-create an object. Works only with built-in classes. + */ + toSource(): string + + /** + * Converts an array to a string and returns the string. + * Yields the same result as array. join() when called without a parameter.Returns a comma-separated list of all the elements of the array. + */ + toString(): string + + /** + * Adds one or more elements to the beginning of the array. + * Returns the new array length. + * @param values The values of one or more elements to be added to the beginning of the array. + */ + unshift(...values: T[]): number +} + +/** + * A global object containing a set of math functions and constants. + */ +interface Math { + /** + * Euler's constant and the base of natural logarithms. + */ + readonly E: number + + /** + * The natural logarithm of 10. + */ + readonly LN10: number + + /** + * The natural logarithm of 2. + */ + readonly LN2: number + + /** + * The base 10 logarithm of e. + */ + readonly LOG10E: number + + /** + * The base 2 logarithm of e. + */ + readonly LOG2E: number + + /** + * The ratio of the circumference of a circle to its diameter. + */ + readonly PI: number + + /** + * The reciprocal of the square root of 1/2. + */ + readonly SQRT1_2: number + + /** + * The square root of 2. + */ + readonly SQRT2: number + + /** + * Returns the absolute value of a number. + * @param x A number. + */ + abs(x: number): number + + /** + * Returns the arc cosine(in radians) of a number. + * @param x A number. + */ + acos(x: number): number + + /** + * Returns the arc sin(in radians) of a number. + * @param x A number. + */ + asin(x: number): number + + /** + * Returns the arc tangent(in radians) of a number. + * @param x A number. + */ + atan(x: number): number + + /** + * Returns the arc tangent of the quotient of its arguments (y/x). + * @param y A number. + * @param x A number. + */ + atan2(y: number, x: number): number + + /** + * Rounds the number up to the nearest integer. + * @param x A number. + */ + ceil(x: number): number + + /** + * Returns the cosine of an angle provided in radians. + * @param x An angle, in radians. + */ + cos(x: number): number + + /** + * Returns Math.E raised to the power of a number. + * @param x A number. + */ + exp(x: number): number + + /** + * Rounds a number down to the nearest integer. + * @param x A number. + */ + floor(x: number): number + + /** + * Returns the natural logarithm of a number. + * @param x A number. + */ + log(x: number): number + + /** + * Returns the largest of zero or more numbers. + * @param rest Numbers. + */ + max(...rest: number[]): number + + /** + * Returns the smallest of zero or more numbers. + * @param rest Numbers. + */ + min(...rest: number[]): number + + /** + * Returns x raised to the power of y. + * @param x Numbers. + * @param y + */ + pow(x: number, y: number): number + + /** + * Returns a pseudo-random number from 0.0 up to but not including 1.0. + */ + random(): number + + /** + * Rounds a number to the nearest integer. + * @param x A number. + */ + round(x: number): number + + /** + * Returns the sine of an angle provided in radians. + * @param x An angle, in radians. + */ + sin(x: number): number + + /** + * Returns the square root of a number. + * @param x A number. + */ + sqrt(x: number): number + + /** + * Returns the tangent of an angle provided in radians. + * @param x An angle, in radians. + */ + tan(x: number): number +} +declare const Math: Math + +interface DateConstructor { + readonly prototype: Date + + /** + * Returns a new Date object holding the current date and time. + * If parameters are supplied, returns a new Date object holding the supplied date and time. + * @param year The year expressed in four digits. + * @param month An integer value from 0 (Jan) to 11 (Dec). + * @param day An integer value from 1 to 31, If this argument is not supplied, its value is set to 0. + * @param hours An integer value from 0 (midnight) to 23 (11 PM). If this argument is not supplied, its value is set to 0. + * @param min An integer value from 0 to 59. If this argument is not supplied, its value is set to 0. + * @param sec An Integer value from 0 to 59. If this argument is not supplied, its value is set to 0. + * @param ms An integer value from 0 to 999. If this argument is not supplied, its value is set to 0. + */ + new (): Date + new (value: number): Date + new (value: string): Date + new ( + year: number, + month: number, + day?: number, + hours?: number, + min?: number, + sec?: number, + ms?: number, + ): Date + + /** + * Parses a string, returning a new Date object. The string should be similar to the string returned bt toString(). + * @param text The string to parse. + */ + parse(text: string): Date + + /** + * Returns the number of milliseconds between midnight January 1, 1970, UTC, and the specified time. + * @param year The year expressed in four digits, for example, 2001. To indicate for a year from 1900 to 1999, you can specify a value from 0 to 99. + * @param month An integer value from 0 (Jan) to 11 (Dec). + * @param day An integer value from 1 to 31, If this argument is not supplied, its value is set to 0. + * @param hours An integer value from 0 (midnight) to 23 (11 PM). If this argument is not supplied, its value is set to 0. + * @param min An integer value from 0 to 59. If this argument is not supplied, its value is set to 0. + * @param sec An Integer value from 0 to 59. If this argument is not supplied, its value is set to 0. + * @param ms An integer value from 0 to 999. If this argument is not supplied, its value is set to 0. + */ + UTC( + year: number, + month?: number, + day?: number, + hours?: number, + min?: number, + sec?: number, + ms?: number, + ): Date +} +declare const Date: DateConstructor + +/** + * A date/time object. + */ +interface Date { + /** + * Returns the day of the month of the specified Date object in local time. + */ + getDate(): number + + /** + * Returns the day of the week for the specified Date object in local time. + * This is an integer from 0 (Sunday) to 6 (Saturday).Returns the day of the week for date. + */ + getDay(): number + + /** + * Returns the four digit year of the specified Date object in local time. + */ + getFullYear(): number + + /** + * Returns the hour of the specified Date object in local time. + */ + getHours(): number + + /** + * Returns the milliseconds of the specified Date object in local time. + */ + getMilliseconds(): number + + /** + * Returns the minutes of the specified Date object in local time. + */ + getMinutes(): number + + /** + * Returns the month of the specified Date object in local time. + */ + getMonth(): number + + /** + * Returns the seconds of the specified Date object in local time. + */ + getSeconds(): number + + /** + * Returns the number of milliseconds since midnight January 1,1970 UTC for the specified Date object. + */ + getTime(): number + + /** + * Returns the difference in minutes between the computer's local time and UTC. + */ + getTimezoneOffset(): number + + /** + * Returns the day of the month of the specified Date object according to UTC. + */ + getUTCDate(): number + + /** + * Returns the day of the week for the specified Date object according to UTC. + */ + getUTCDay(): number + + /** + * Returns the four digit year of the specified Date object according to UTC. + */ + getUTCFullYear(): number + + /** + * Returns the hour of the specified Date object according to UTC. + */ + getUTCHours(): number + + /** + * Returns the milliseconds of the specified Date object according to UTC. + */ + getUTCMilliseconds(): number + + /** + * Returns the minutes of the specified Date object according to UTC. + */ + getUTCMinutes(): number + + /** + * Returns the month of the specified Date object according to UTC. + */ + getUTCMonth(): number + + /** + * Returns the seconds of the specified Date object according to UTC. + */ + getUTCSeconds(): number + + /** + * Returns the year of the specified Date object, as a difference from 1900, in local time. + */ + getYear(): number + + /** + * Sets the day of the month of a specified Date object according to local time. + * Returns the number of milliseconds between the new date and midnight, January 1, 1970. + * @param date An integer from 1 to 31 indicating the day of the month. + */ + setDate(date: number): number + + /** + * Sets the year of a specified Date object according to local time. + * This method can also set month and date if those arguments are specified. Returns the number of milliseconds between the new date and midnight, January 1, 1970. + * @param year A four-digit integer value indicating the year to set. + */ + setFullYear(year: number): number + + /** + * Sets the hours of a specified Date object according to local time. + * Returns the number of milliseconds between the new date and midnight, January 1, 1970. + * @param hour An integer value from 0 (midnight) to 23 (11 PM). + */ + setHours(hour: number): number + + /** + * Sets the milliseconds of a specified Date object according to local time. + * Returns the number of milliseconds between the new date and midnight, January 1, 1970. + * @param ms An integer value from 0 to 999. + */ + setMilliseconds(ms: number): number + + /** + * Sets the minutes of a specified Date object according to local time. + * Returns the number of milliseconds between the new date and midnight, January 1, 1970. + * @param minutes An integer value from 0 to 59. + */ + setMinutes(minutes: number): number + + /** + * Sets the month of a specified Date object according to local time. + * Returns the number of milliseconds between the new date and midnight, January 1, 1970. + * @param month An integer value from 0 (Jan) to 11 (Dec). + */ + setMonth(month: number): number + + /** + * Sets the seconds of a specified Date object according to local time. + * Returns the number of milliseconds between the new date and midnight, January 1, 1970. + * @param seconds An integer value from 0 to 59. + */ + setSeconds(seconds: number): number + + /** + * Sets the date of a specified Date object in milliseconds since midnight, January 1, 1970. + * Returns the value of ms. + * @param ms An integer indicating the number of milliseconds between the date set and midnight, January 1, 1970. + */ + setTime(ms: number): number + + /** + * Sets the date of a specified Date object according to universal time. + * Returns the number of milliseconds between the new date and midnight, January 1, 1970 in UTC time. + * @param date An integer from 1 to 31 indicating the day of the month. + */ + setUTCDate(date: number): number + + /** + * Sets the year of a specified Date object according to UTC, can also set the month and date. + * Returns the number of milliseconds between the date set and midnight, January 1, 1970, in UTC. + * @param year The year expressed in four digits. + */ + setUTCFullYear(year: number): number + + /** + * Sets the hours of a specified Date object according to UTC. + * Returns the number of milliseconds between the date set and midnight, January 1, 1970, in UTC. + * @param hours An integer value from 0 (midnight) to 23 (11 PM) indicating the hour to be set. + */ + setUTCHours(hours: number): number + + /** + * Sets the milliseconds of a specified Date object according to UTC. + * Returns the number of milliseconds between the date set and midnight, January 1, 1970, in UTC. + * @param ms An integer value in the range of 0 to 999 indicating the number of milliseconds to set. + */ + setUTCMilliseconds(ms: number): number + + /** + * Sets the minutes of a specified Date object according to UTC. + * Returns the number of milliseconds between the date set and midnight, January 1, 1970, in UTC. + * @param min An integer value in the range 0 to 59 indicating the number of minutes to be set. + */ + setUTCMinutes(min: number): number + + /** + * Sets the month of a specified Date object according to UTC. + * Returns the number of milliseconds between the date set and midnight, January 1, 1970, in UTC. + * @param month An integer value in the range 0 (Jan.) to 11 (Dec.) indicating the month to set. + */ + setUTCMonth(month: number): number + + /** + * Sets the seconds of a specified Date object according to UTC. + * Returns the number of milliseconds between the date set and midnight, January 1, 1970, in UTC. + * @param sec An integer value in the range 0 to 59 indicating the number of seconds to set. + */ + setUTCSeconds(sec: number): number + + /** + * Sets the year of a specified Date object according to local time, as a difference between the current year and 1900. + * Returns the number of milliseconds between the date set and midnight, January 1, 1970. + * @param year An integer value indicating the year to set. The method interprets a 1- or 2- digit value to mean the 1900s; for example, 13 is interpreted to mean 1913. + */ + setYear(year: number): number + + /** + * Returns the date as a string. + */ + toDateString(): string + + /** + * Returns the date and time adjusted to GMT (UTC) as a string. + */ + toGMTString(): string + + /** + * Returns the date as a localized string. + */ + toLocaleDateString(): string + + /** + * Returns a string value representing the date and time stored in the Date object in human readable format (localized). + */ + toLocaleString(): string + + /** + * Returns the time as a localized string. + */ + toLocaleTimeString(): string + + /** + * Creates a string representation of this object that can be fed back to eval() to re-create an object. Works only with built-in classes. + */ + toSource(): string + + /** + * Returns a string value representing the date and time stored in the Date object in human readable format. + * Returns the following string is an example of the format returned by this method: Mon Aug 13, 10:54:21 GMT-0700 2001. + */ + toString(): string + + /** + * Returns the time as a string. + */ + toTimeString(): string + + /** + * Returns the date and time adjusted to UTC as a string. + */ + toUTCString(): string + + /** + * The valueOf() method returns the number of milliseconds that have passed since midnight, Returns an integer. + */ + valueOf(): number +} + +interface FunctionConstructor { + readonly prototype: Function + + /** + * The Function constructor parses the argument list and creates a Function object. + * @param arguments The list of formal arguments, separated by commas. The formal arguments can also be supplied one by one; in this case, the last argument to the Function constructor is considered to be the function body. + * @param body The body of the function to create. + */ + new (arguments: string, body: string): Function + (arguments: string, body: string): Function +} +declare const Function: FunctionConstructor + +/** + * Wraps a built-in or JavaScript function. + */ +interface Function { + /** + * The function arguments, packed into an array. + * This property is deprecated; use the arguments property within the function body. + */ + arguments: object + + /** + * The number of formal arguments. + * This property is deprecated; use the length property instead. + */ + readonly arity: number + + /** + * The number of formal arguments. + */ + readonly length: number + + /** + * The function name. + */ + readonly name: string + + /** + * Apply a this object and an argument list to a function. + * This function is different from call(); here, the arguments are suppliedas an Array object. + * @param thisObj The object to be used as this. + * @param args An array of arguments. + */ + apply(thisObj: object, args: any): any + + /** + * Apply a this object and arguments to a function. + * This function is different from apply(); here, the arguments are supplied one by one. + * @param thisObj The object to be used as this. + * @param arguments The first agument to the function. Add as many as needed. + */ + call(thisObj: object, ...arguments: any[]): any + + /** + * Creates a string representation of this object that can be fed back to eval() to re-create an object. Works only with JavaScript functions. + */ + toSource(): string + + /** + * Returns the function definition as a string. + */ + toString(): string +} + +interface StringConstructor { + readonly prototype: String + + /** + * Returns a string representation of the value given as an argument. + * @param value A number, variable, or object to convert to a string. + */ + new (value?: any): String + (value: any): string + + /** + * Returns a string created by concatenation one or more characters specified as ASCII values. + * @param value1 One or more ASCII values. + */ + fromCharCode(value1: number): string +} +declare const String: StringConstructor + +/** + * A character string. Each character is adressable by index. + */ +interface String { + /** + * The length of the string. + */ + readonly length: number + + /** + * Get character at index. + */ + readonly [index: number]: string + + /** + * Returns a string consisting of this string enclosed in a tag. + * @param name The text to be stored in the anchors' name attribute. + */ + anchor(name: string): string + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + big(): string + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + blink(): string + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + bold(): string + + /** + * Returns the character at the specified index. + * @param index An integer between 0 and string.length -1, specifying the character to return. + */ + charAt(index: number): string + + /** + * Returns the Unicode value of the character at the given index. + * @param index An integer between 0 and string.length -1, specifying the character. + */ + charCodeAt(index: number): number + + /** + * If necessary, converts the one or more given values to strings. + * Those values are concatenated with the original string, the result is returned. The original string is not effected.Returns the concatenated string. + * @param value The values to be concatenated with the given string. + */ + concat(value: string): string + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + fixed(): string + + /** + * Returns a string consisting of this string enclosed in a tag. + * @param color The value to be stored in the tag's color attribute. + */ + fontcolor(color: string): string + + /** + * Returns a string consisting of this string enclosed in a tag. + * @param size The value to be stored in the tag's size attribute. + */ + fontsize(size: number): string + + /** + * Returns the index within the string of the first occurrence of the specified string, starting the search at fromIndex if provided. + * @param searchValue The string for which to search. + * @param offset The starting offset of the search. + */ + indexOf(searchValue: string, offset?: number): number + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + italics(): string + + /** + * Returns the index within the string of the last occurrence of the specified value. + * The string is searched backward, starting at fromIndex.Returns the index within the string where the last occurrence of searchValue was found, or -1 if it was not found. + * @param searchValue The string for which to search. + * @param offset The starting offset of the search. + */ + lastIndexOf(searchValue: string, offset?: number): number + + /** + * Returns a string consisting of this string enclosed in a tag. + * @param href The value to be stored in the tag's href attribute. + */ + link(href: string): string + + /** + * Performs a localized comparison of two strings. + * @param what The string to compare with. + */ + localeCompare(what: string): number + + /** + * Matches a string against a regular expression. + * @param regexp The regular expression to use. + */ + match(regexp: RegExp | string): RegExpMatchArray | null + + /** + * + * @param what + * @param with_ + */ + replace(what: any, with_: string): string + + /** + * + * @param search + */ + search(search: RegExp): number + + /** + * Extracts a substring of the given string and returns it as a new string. + * The substring begins at startSlice, and includes all characters up to, but not including the character at the index endSlice. A negative value indexes from the end of the string.For example, a negative value for startSlice is resolved as: string. length + startSlice.The original string is unchanged.Returns a substring of characters from the given string, starting at startSlice and ending with endSlice-1. + * @param startSlice The index at which to begin extraction. + * @param endSlice The index at which to end extraction. If omitted, slice extracts to the end of the string. + */ + slice(startSlice: number, endSlice?: number): string + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + small(): string + + /** + * Splits a string into a group of substrings, places those strings in an array, and returns the array. + * The substrings are created by breaking the original string at places that match delimiter, the delimiter characters are removed.Returns an array whose elements are the substrings. + * @param delimiter Specifies the string to use for delimiting. If delimiter is omitted, the array returned contains one element, consisting of the entire string. + * @param limit + */ + split(delimiter: string, limit?: number): string[] + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + strike(): string + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + sub(): string + + /** + * Returns a string containing the characters beginning at the specified index, start, through the specified number of characters. + * The original string is unchanged.Returns a string containing the extracted characters. + * @param start Location at which to begin extracting characters. + * @param length The number of characters to extract. + */ + substr(start: number, length?: number): string + + /** + * Returns a substring of the given string by extracting characters from indexA up to but not including indexB. + * The original string is unchanged.Returns a substring of characters from the given string, starting at indexA and ending with indexB-1. + * @param indexA The index to begin extracting. + * @param indexB The index at which to end extraction. If omitted, slice extracts to the end of the string. + */ + substring(indexA: number, indexB?: number): string + + /** + * Returns a string consisting of this string enclosed in a tag. + */ + sup(): string + + /** + * Returns a new string which contains all the characters of the original string converted to lowercase (localized). + * The original string is unchanged. + */ + toLocaleLowerCase(): string + + /** + * Returns a new string which contains all the characters of the original string converted to uppercase (localized). + * The original string is unchanged. + */ + toLocaleUpperCase(): string + + /** + * Returns a new string which contains all the characters of the original string converted to lowercase. + * The original string is unchanged. + */ + toLowerCase(): string + + /** + * Creates a string representation of this object that can be fed back to eval() to re-create an object. Works only with built-in classes. + */ + toSource(): string + + /** + * Returns itself. + */ + toString(): string + + /** + * Returns a new string which contains all the characters of the original string converted to uppercase. + * The original string is unchanged. + */ + toUpperCase(): string + + /** + * The valueOf() method returns the number of milliseconds that have passed since midnight, Returns an integer. + */ + valueOf(): string +} + +interface NumberConstructor { + readonly prototype: Number + + /** + * Returns a new Number object set to the value of the argument converted to a number. + * @param value The value of the object being created. + */ + new (value?: any): Number + (value: any): number + + /** + * A constant representing the largest representable number. + */ + readonly MAX_VALUE: number + + /** + * A constant representing the smallest representable number. + */ + readonly MIN_VALUE: number + + /** + * A constant representing negative infinity. + */ + readonly NEGATIVE_INFINITY: number + + /** + * A constant representing the special "Not a Number" value. + */ + readonly NaN: number + + /** + * A constant representing positive infinity. + */ + readonly POSITIVE_INFINITY: number +} +declare const Number: NumberConstructor + +/** + * Wraps a numeric value. + */ +interface Number { + /** + * Converts the Number object to a string in scientific notation. + * @param decimals The number of decimals. + */ + toExponential(decimals: number): string + + /** + * Converts the Number object to a string with fixed decimals. + * @param decimals The number of decimals. + */ + toFixed(decimals: number): string + + /** + * Returns the value of a Number object converted to a string, using localized conventions. + */ + toLocaleString(): string + + /** + * Converts the Number object to a string in either scientific or fixed notation, epending on its value. + * @param decimals The number of decimals. + */ + toPrecision(decimals: number): string + + /** + * Creates a string representation of this object that can be fed back to eval() to re-create an object. Works only with built-in classes. + */ + toSource(): string + + /** + * Returns the value of a Number object converted to a string. + * @param radix The optional conversion radix. + */ + toString(radix?: number): string + + /** + * Returns the value of a Number object as a primitive number. + */ + valueOf(): number +} + +interface BooleanConstructor { + readonly prototype: Boolean + + /** + * Creates and returns a new Boolean object set to the value of the argument converted to a boolean. + * @param value The value to be converted to a Boolean. + */ + new (value?: any): Boolean + (value: any): boolean +} +declare const Boolean: BooleanConstructor + +/** + * Wraps a Boolean value. + */ +interface Boolean { + /** + * Creates a string representation of this object that can be fed back to eval() to re-create an object. Works only with built-in classes. + */ + toSource(): string + + /** + * Returns the string representation of the value of bool. + * The method returns the string true if the primitive value of bool is true; otherwise it returns the string false. + */ + toString(): string + + /** + * Returns the primitive value of bool. + * The method returns true if the primitive value of bool is true; otherwise it returns false. + */ + valueOf(): boolean +} + +interface RegExpConstructor { + readonly prototype: RegExp + + /** + * Creates and returns a new RegExp object set to the value of the argument converted to a regular expression. + * @param pattern The pattern to convert. + * @param flags Flags that control how the conversion is performed. A string containing any combination of the letters i, m, g: "i" -- ignore case in pattern matching "m" -- treat the string as multiple lines "g" -- do global pattern matching + */ + new (pattern: string | RegExp, flags?: string): RegExp + (pattern: string | RegExp, flags?: string): RegExp + + /** + * The matched subexpression #1. + */ + readonly $1: string + + /** + * The matched subexpression #2. + */ + readonly $2: string + + /** + * The matched subexpression #3. + */ + readonly $3: string + + /** + * The matched subexpression #4. + */ + readonly $4: string + + /** + * The matched subexpression #5. + */ + readonly $5: string + + /** + * The matched subexpression #6. + */ + readonly $6: string + + /** + * The matched subexpression #7. + */ + readonly $7: string + + /** + * The matched subexpression #8. + */ + readonly $8: string + + /** + * The matched subexpression #9. + */ + readonly $9: string + + /** + * Indicates whether the match is a global match. + */ + global: boolean + + /** + * Indicates whether the match is not case sensitive. + */ + ignoreCase: boolean + + /** + * The original input string. + */ + input: string + + /** + * The last match. + */ + readonly lastMatch: string + + /** + * The value of the last matched subexpression. + */ + readonly lastParen: string + + /** + * The string before the match. + */ + readonly leftContext: string + + /** + * Indicates whether the match matches multiple lines. + */ + multiline: boolean + + /** + * The string after the match. + */ + readonly rightContext: string +} +declare const RegExp: RegExpConstructor + +/** + * Wraps a regular expression. + */ +interface RegExp { + /** + * Compiles a string to a regular expression. Returns true if the compilation was successful. + * @param pattern The pattern to compile. + */ + compile(pattern: string): boolean + + /** + * Execute a regular expression. + * The return value is an array of matches, with the first element containing the match, and successive elements containing the results of any matching subexpression in their order of appearance. If there is no match, the result is null. + * @param text The string to match. + */ + exec(text: string): RegExpExecArray | null + + /** + * Execute a regular expression, and return true if there is a match. + * @param text The string to match. + */ + test(text: string): boolean + + /** + * Converts this RegExp object to a string. + */ + toString(): string +} + +interface RegExpMatchArray extends Array { + index?: number + input?: string +} + +interface RegExpExecArray extends Array { + index: number + input: string +} + +interface ErrorConstructor { + readonly prototype: Error + + /** + * Creates a new Error object. + * @param msg The error message. + * @param file The name of the file. + * @param line The line number. + */ + new (msg: string, file?: string, line?: number): Error + (msg: string, file?: string, line?: number): Error +} +declare const Error: ErrorConstructor + +/** + * Wraps a runtime error. + */ +interface Error { + /** + * The error message. + */ + description: string + + /** + * Creates a string representation of this object that can be fed back to eval() to re-create an object. Works only with built-in classes. + */ + toSource(): string + + /** + * Convert this object to a string. + */ + toString(): string +} + +interface FileConstructor { + readonly prototype: File + + /** + * Creates and returns a new File object referring to a given file system location. + * @param path The full or partial path name of the file,in platform-specific or URI format. The value stored in the object is the absolute path. The file that the path refers to does not need to exist.If the path refers to an existing folder: The File function returns a Folder object instead of a File object. The new operator returns a File object for a nonexisting file with the same name. + */ + new (path?: string): File + (path?: string): File + + /** + * The name of the file system. + * This is a class property accessed through the File constructor. Valid values are "Windows", "Macintosh", and "Unix". + */ + readonly fs: string + + /** + * Decodes a UTF-8 encoded string as required by RFC 2396, and returns the decoded string. + * See also String.decodeURI(). + * @param uri The UTF-8 encoded string to decode. + */ + decode(uri: string): string + + /** + * Encodes a string as required by RFC 2396, and returns the encoded string. + * All special characters are encoded in UTF-8 and stored as escaped characters starting with the percent sign followed by two hexadecimal digits. For example, the string "my file" is encoded as "my%20file". + * Special characters are those with a numeric value greater than 127, except the following: / - _ . ! ~ * ' ( ) + * See also encodeURI(). + * @param name The string to encode. + */ + encode(name: string): string + + /** + * Reports whether a given encoding is available. + * @param name The encoding name. Typical values are "ASCII", "binary", or "UTF-8".For a complete list of supported encodings, see the JavaScript Tools Guide. + */ + isEncodingAvailable(name: string): boolean + + /** + * Opens a dialog so the user can select one or more files to open. + * Opens the built-in platform-specific file-browsing dialog in which a user can select an existing file or multiple files, and creates new File objects to represent the selected files. + * If the user clicks OK, returns a File object for the selected file, or an array of objects if multiple files are selected. + * If the user cancels, returns null. + * @param prompt The prompt text, displayed if the dialog allows a prompt. + * @param filter A filter that limits the types of files displayed in the dialog. In Windows,a filter expression such as "Javascript files:*.jsx;All files:*.*". In Mac OS, a filter function that takes a File instance and returns true if the file should be included in the display, false if it should not. + * @param multiSelect When true, the user can select multiple files and the return value is an array. + */ + openDialog(prompt?: string, filter?: string | Function, multiSelect?: boolean): File | File[] + openDialog(prompt: string, filter: string | Function, multiSelect: false): File + openDialog(prompt: string, filter: string | Function, multiSelect: true): File[] + + /** + * Opens a dialog so the user can select a file name to save to. + * Opens the built-in platform-specific file-browsing dialog in which a user can select an existing file location to which to save information, and creates a new File object to represent the selected file location. + * If the user clicks OK, returns a File object for the selected file location. + * If the user cancels, returns null. + * @param prompt The prompt text, displayed if the dialog allows a prompt. + * @param filter In Windows only, a filter that limits the types of files displayed in the dialog. In Windows only,a filter expression such as "Javascript files:*.jsx;All files:*.*". Not used In Mac OS. + */ + saveDialog(prompt?: string, filter?: any): File +} +declare const File: FileConstructor + +/** + * Represents a file in the local file system in a platform-independent manner. + */ +interface File { + /** + * The full path name for the referenced file in URI notation. + */ + readonly absoluteURI: string + + /** + * If true, the object refers to a file system alias or shortcut. + */ + readonly alias: boolean + + /** + * The creation date of the referenced file, or null if the object does not refer to a file on disk. + */ + readonly created: Date + + /** + * In Mac OS, the file creator as a four-character string. In Windows or UNIX, value is "????". + */ + readonly creator: string + + /** + * The localized name of the referenced file, without the path specification. + */ + readonly displayName: string + + /** + * Gets or sets the encoding for subsequent read/write operations. + * One of the encoding constants listed in the JavaScript Tools Guide. If the value is not recognized, uses the system default encoding.A special encoder, BINARY, is used to read binary files. It stores each byte of the file as one Unicode character regardless of any encoding. When writing, the lower byte of each Unicode character is treated as a single byte to write. + */ + encoding: string + + /** + * When true, a read attempt caused the current position to be at the end of the file, or the file is not open. + */ + readonly eof: boolean + + /** + * A string containing a message describing the most recent file system error. + * Typically set by the file system, but a script can set it. Setting this value clears any error message and resets the error bit for opened files. Contains the empty string if there is no error. + */ + error: string + + /** + * If true, this object refers to a file or file-system alias that actually exists in the file system. + */ + readonly exists: boolean + + /** + * The platform-specific full path name for the referenced file. + */ + readonly fsName: string + + /** + * The full path name for the referenced file in URI notation. + */ + readonly fullName: string + + /** + * When true, the file is not shown in the platform-specific file browser. + * If the object references a file-system alias or shortcut, the flag is altered on the alias, not on the original file. + */ + hidden: boolean + + /** + * The size of the file in bytes. + * Can be set only for a file that is not open, in which case it truncates or pads the file with 0-bytes to the new length. + */ + length: number + + /** + * How line feed characters are written in the file system. + * One of the values "Windows", "Macintosh", or "Unix". + */ + lineFeed: string + + /** + * The date of the referenced file's last modification, or null if the object does not refer to a file on the disk. + */ + readonly modified: Date + + /** + * The file name portion of the absolute URI for the referenced file, without the path specification. + */ + readonly name: string + + /** + * The Folder object for the folder that contains this file. + */ + readonly parent: Folder + + /** + * The path portion of the absolute URI for the referenced file, without the file name. + */ + readonly path: string + + /** + * When true, prevents the file from being altered or deleted. + * If the referenced file is a file-system alias or shortcut, the flag is altered on the alias, not on the original file. + */ + readonly: boolean + + /** + * The path name for the object in URI notation, relative to the current folder. + */ + readonly relativeURI: string + + /** + * The file type as a four-character string. + * In Mac OS, the Mac OS file type. + * In Windows, "appl" for .EXE files, "shlb" for .DLL files and "TEXT" for any other file. + */ + readonly type: string + + /** + * Changes the path specification of the referenced file. + * @param path A string containing the new path, absolute or relative to the current folder. + */ + changePath(path: string): boolean + + /** + * Closes this open file. + * Returns true if the file was closed successfully, false if an I/O error occurred. + */ + close(): boolean + + /** + * Copies this object’s referenced file to the specified target location. + * Resolves any aliases to find the source file. If a file exists at the target location, it is overwritten. + * Returns true if the copy was successful. + * @param target A string with the URI path to the target location, or a File object that references the target location. + */ + copy(target: string): boolean + + /** + * Makes this file a file-system alias or shortcut to the specified file. + * The referenced file for this object must not yet exist on disk. Returns true if the operation was successful. + * @param path A string containing the path of the target file. + */ + createAlias(path: string): void + + /** + * Executes or opens this file using the appropriate application, as if it had been double-clicked in a file browser. + * You can use this method to run scripts, launch applications, and so on.Returns true immediately if the application launch was successful. + */ + execute(): boolean + + /** + * Retrieves and returns the path for this file, relative to the specified base path, in URI notation. + * If no base path is supplied, the URI is relative to the path of the current folder.Returns a string containing the relative URI. + * @param basePath A base path in URI notation. + */ + getRelativeURI(basePath: string): string + + /** + * Opens the referenced file for subsequent read/write operations. The method resolves any aliases to find the file. + * Returns true if the file was opened successfully.The method attempts to detect the encoding of the open file. It reads a few bytes at the current location and tries to detect the Byte Order Mark character 0xFFFE. If found, the current position is advanced behind the detected character and the encoding property is set to one of the strings UCS-2BE, UCS-2LE, UCS4-BE, UCS-4LE, or UTF-8. If the marker character is not found, it checks for zero bytes at the current location and makes an assumption about one of the above formats (except UTF-8). If everything fails, the encoding property is set to the system encoding. + * IMPORTANT: Be careful about opening a file more than once. The operating system usually permits you to do so, but if you start writing to the file using two different File objects, you can destroy your data. + * @param mode The read-write mode, a single-character string. One of these characters: r (read) Opens for reading. If the file does not exist or cannot be found, the call fails. w (write) Opens a file for writing. If the file exists, its contents are destroyed. If the file does not exist, creates a new, empty file. e (edit) Opens an existing file for reading and writing. a (append) Opens an existing file for reading and writing, and moves the current position to the end of the file. + * @param type In Mac OS, the type of a newly created file, a 4-character string. Ignored in Windows and UNIX. + * @param creator In Mac OS, the creator of a newly created file, a 4-character string. Ignored in Windows and UNIX. + */ + open(mode: string, type?: string, creator?: string): boolean + + /** + * Opens the built-in platform-specific file-browsing dialog, in which the user can select an existing file or files, and creates new File objects to represent the selected files. + * Differs from the class method openDialog() in that it presets the current folder to this File object’s parent folder and the current file to this object’s associated file. + * If the user clicks OK, returns a File or Folder object for the selected file or folder, or an array of objects. + * If the user cancels, returns null. + * @param prompt A string containing the prompt text, if the dialog allows a prompt. + * @param filter A filter that limits the types of files displayed in the dialog. In Windows,a filter expression such as "Javascript files:*.jsx;All files:*.*". In Mac OS, a filter function that takes a File instance and returns true if the file should be included in the display, false if it should not. + * @param multiSelect When true, the user can select multiple files and the return value is an array. + */ + openDlg(prompt?: string, filter?: string | Function, multiSelect?: boolean): File | File[] + openDlg(prompt: string, filter: string | Function, multiSelect: false): File + openDlg(prompt: string, filter: string | Function, multiSelect: true): File[] + + /** + * Reads the contents of the file, starting at the current position. + * Returns a string that contains up to the specified number of characters. If a number of characters is not supplied, reads from the current position to the end of the file. If the file is encoded, multiple bytes might be read to create single Unicode characters. + * @param chars An integer specifying the number of characters to read. + */ + read(chars?: number): string + + /** + * Reads a single text character from the file at the current position. + * Line feeds are recognized as CR, LF, CRLF or LFCR pairs.If the file is encoded, multiple bytes might be read to create a single Unicode character. Returns a string that contains the character. + */ + readch(): string + + /** + * Reads a single line of text from the file at the current position. + * Line feeds are recognized as CR, LF, CRLF or LFCR pairs.. If the file is encoded, multiple bytes might be read to create single Unicode characters. Returns a string that contains the text. + */ + readln(): string + + /** + * Deletes the file associated with this object from disk immediately, without moving it to the system trash. + * Does not resolve aliases; instead, deletes the referenced alias or shortcut file itself. Returns true if the file was successfully removed. + * IMPORTANT: Cannot be undone. It is recommended that you prompt the user for permission before deleting. + */ + remove(): boolean + + /** + * Renames the associated file. + * Does not resolve aliases, but renames the referenced alias or shortcut file itself. Returns true if the file was successfully renamed. + * @param newName The new file name, with no path information. + */ + rename(newName: string): boolean + + /** + * Attempts to resolve the file-system alias or shortcut that this object refers to. + * If successful, creates and returns a new File object that points to the resolved file system element. Returns null if this object does not refer to an alias, or if the alias could not be resolved. + */ + resolve(): File + + /** + * Opens the built-in platform-specific file-browsing dialog, in which the user can select an existing file location to which to save information, and creates a new File object to represent the selected file. + * Differs from the class method saveDialog() in that it presets the current folder to this File object’s parent folder and the file to this object’s associated file. + * If the user clicks OK, returns a File object for the selected file. + * If the user cancels, returns null. + * @param prompt A string containing the prompt text, if the dialog allows a prompt. + * @param filter In Windows only, a filter that limits the types of files displayed in the dialog. In Windows only,a filter expression such as "Javascript files:*.jsx;All files:*.*". Not used In Mac OS. + */ + saveDlg(prompt?: string, filter?: any): File + + /** + * Seeks to a given position in the file. + * The new position cannot be less than 0 or greater than the current file size. Returns true if the position was changed. + * @param pos The new current position in the file as an offset in bytes from the start, current position, or end, depending on the mode. + * @param mode The seek mode. One of: 0: Seek to absolute position, where pos=0 is the first byte of the file. This is the default. 1: Seek relative to the current position. 2. Seek backward from the end of the file. + */ + seek(pos: number, mode?: number): boolean + + /** + * Retrieves the current position as a byte offset from the start of the file. + * Returns a number, the position index. + */ + tell(): number + + /** + * Creates and returns a serialized string representation of this object. + * Pass the resulting string to eval() to recreate the object. + */ + toSource(): string + + /** + * Converts this object to a string. + */ + toString(): string + + /** + * Writes the specified text to the file at the current position. + * You can supply multiple text values; the strings are concatenated to form a single string.For encoded files, writing a single Unicode character may write multiple bytes. Returns true if the write was successful.IMPORTANT: Be careful not to write to a file that is open in another application or object, as this can overwrite existing data. + * @param text A text string to be written. + */ + write(text: string): boolean + + /** + * Writes a string to the file at the current position and appends a line-feed sequence. + * You can supply multiple text values. The strings are concatenated into a single string, which is written in the file followed by one line-feed sequence, of the style specified by this object's linefeed property.For encoded files, writing a single Unicode character may write multiple bytes.Returns true if the write was successful.IMPORTANT: Be careful not to write to a file that is open in another application or object, as this can overwrite existing data. + * @param text A text string to be written. + */ + writeln(text: string): boolean +} + +interface FolderConstructor { + readonly prototype: Folder + + /** + * Creates and returns a new Folder object referring to a given file-system location. + * If the path name refers to an already existing disk file, a File object is returned instead.Returns the new Folder object. + * @param path The absolute or relative path to the folder associated with this object, specified in URI format. The value stored in the object is the absolute path.The path need not refer to an existing folder. If the path refers to an existing file, rather than a folder: The Folder() function returns a File object instead of a Folder object. The new operator returns a Folder object for a nonexisting folder with the same name. + */ + new (path?: string): Folder + (path?: string): Folder + + /** + * The folder containing the application data for all users. + * In Windows, the value of %APPDATA% (by default, C:\\Documents and Settings\\All Users\\Application Data) + * In Mac OS, /Library/Application Support + */ + readonly appData: Folder + + /** + * In Mac OS, a Folder object for the folder containing the bundle of the running application. + */ + readonly appPackage: Folder + + /** + * A Folder object for the folder containing common files for all programs installed by the user. + * In Windows, the value of %CommonProgramFiles% (by default, C:\\Program Files\\Common Files) + * In Mac OS, /Library/Application Support + */ + readonly commonFiles: Folder + + /** + * A Folder object for the current folder. + * Assign a Folder object or a string containing the new path name to set the current folder. This is a class property accessed through the Folder constructor. + */ + current: Folder + + /** + * A Folder object for the folder that contains the user’s desktop. + * In Windows, C:\\Documents and Settings\\username\\Desktop + * In Mac OS, ~/Desktop + */ + readonly desktop: Folder + + /** + * The name of the current file system. + * One of "Windows", "Macintosh", or "Unix". + */ + readonly fs: string + + /** + * A folder pointing to the user's My Documents folder. + * In Windows, C:\\Documents and Settings\\username\\My Documents + * In Mac OS,~/Documents + */ + readonly myDocuments: Folder + + /** + * A Folder object for the folder containing the executable image of the running application. + */ + readonly startup: Folder + + /** + * A Folder object for the folder containing the operating system files. + * In Windows, the value of %windir% (by default, C:\\Windows) + * In Mac OS, /System + */ + readonly system: Folder + + /** + * A Folder object for the default folder for temporary files. + */ + readonly temp: Folder + + /** + * A Folder object for the folder containing deleted items. On Windows, the trash folder is a virtual + * folder containing a database; therefore, the property value is null on Windows. + */ + readonly trash: Folder + + /** + * A Folder object for the folder containing the user's application data. + * In Windows, the value of %USERDATA% (by default, C:\\Documents and Settings\\username\\Application Data) + * In Mac OS,~/Library/Application Support. + */ + readonly userData: Folder + + /** + * Decodes a UTF-8 encoded string as required by RFC 2396, and returns the decoded string. + * See also String.decodeURI(). + * @param uri The UTF-8 string to decode. + */ + decode(uri: string): string + + /** + * Encodes a string as required by RFC 2396, and returns the encoded string. + * All special characters are encoded in UTF-8 and stored as escaped characters starting with the percent sign followed by two hexadecimal digits. For example, the string "my file" is encoded as "my%20file". + * Special characters are those with a numeric value greater than 127, except the following: / - _ . ! ~ * ' ( ) + * See also encodeURI(). + * @param name The string to encode. + */ + encode(name: string): string + + /** + * Reports whether a given encoding is available. + * @param name The encoding name. Typical values are "ASCII", "binary", or "UTF-8".For a complete list of supported encodings, see the JavaScript Tools Guide. + */ + isEncodingAvailable(name: string): boolean + + /** + * Opens the built-in platform-specific file-browsing dialog, and creates a new File or Folder object for the selected file or folder. + * Differs from the object method selectDlg() in that it does not preselect a folder. + * If the user clicks OK, returns a File or Folder object for the selected file or folder. + * If the user cancels, returns null. + * @param prompt The prompt text, if the dialog allows a prompt. + */ + selectDialog(prompt?: string): Folder +} +declare const Folder: FolderConstructor + +/** + * Represents a file-system folder or directory in a platform-independent manner. + */ +interface Folder { + /** + * The full path name for the referenced folder in URI notation. + */ + readonly absoluteURI: string + + /** + * When true, the object refers to a file system alias or shortcut. + */ + readonly alias: boolean + + /** + * The creation date of the referenced folder, or null if the object does not refer to a folder on disk. + */ + readonly created: Date + + /** + * The localized name portion of the absolute URI for the referenced folder, without the path specification. + */ + readonly displayName: string + + /** + * A message describing the most recent file system error. + * Typically set by the file system, but a script can set it. Setting this value clears any error message and resets the error bit for opened files. Contains the empty string if there is no error. + */ + error: string + + /** + * When true, this object refers to a folder that currently exists in the file system. + */ + readonly exists: boolean + + /** + * The platform-specific name of the referenced folder as a full path name. + */ + readonly fsName: string + + /** + * The full path name for the referenced folder in URI notation. . + */ + readonly fullName: string + + /** + * The date of the referenced folder's last modification, or null if the object does not refer to a folder on disk. + */ + readonly modified: Date + + /** + * The folder name portion of the absolute URI for the referenced file, without the path specification. + */ + readonly name: string + + /** + * TThe Folder object for the folder that contains this folder, or null if this object refers to the root folder of a volume. + */ + readonly parent: Folder + + /** + * The path portion of the object absolute URI for the referenced file, without the folder name. + */ + readonly path: string + + /** + * The path name for the referenced folder in URI notation, relative to the current folder. + */ + readonly relativeURI: string + + /** + * Changes the path specification of the referenced folder. + * @param path A string containing the new path, absolute or relative to the current folder. + */ + changePath(path: string): boolean + + /** + * Creates a folder at the location given by this object's path property. + * Returns true if the folder was created. + */ + create(): boolean + + /** + * Opens this folder in the platform-specific file browser (as if it had been double-clicked in the file browser). + * Returns true immediately if the folder was opened successfully. + */ + execute(): boolean + + /** + * Retrieves the contents of this folder, filtered by the supplied mask. + * Returns an array of File and Folder objects, or null if this object's referenced folder does not exist. + * @param mask A search mask for file names, specified as a string or a function. A mask string can contain question mark (?) and asterisk (*) wild cards. Default is "*", which matches all file names. Can also be the name of a function that takes a File or Folder object as its argument. It is called for each file or folder found in the search; if it returns true, the object is added to the return array. NOTE: In Windows, all aliases end with the extension .lnk. ExtendScript strips this from the file name when found, in order to preserve compatibility with other operating systems. You can search for all aliases by supplying the search mask "*.lnk", but note that such code is not portable. + */ + getFiles(mask?: any): Array + + /** + * Retrieves and returns the path for this file, relative to the specified base path, in URI notation. + * If no base path is supplied, the URI is relative to the path of the current folder.Returns a string containing the relative URI. + * @param basePath A base path in URI notation. + */ + getRelativeURI(basePath?: string): string + + /** + * Deletes the folder associated with this object from disk immediately, without moving it to the system trash. + * Folders must be empty before they can be deleted. Does not resolve aliases; instead, deletes the referenced alias or shortcut file itself. Returns true if the file was successfully removed. + * IMPORTANT: Cannot be undone. It is recommended that you prompt the user for permission before deleting. + */ + remove(): boolean + + /** + * Renames the associated folder. + * Does not resolve aliases, but renames the referenced alias or shortcut file itself. Returns true if the folder was successfully renamed. + * @param newName The new folder name, with no path information. + */ + rename(newName: string): boolean + + /** + * Attempts to resolve the file-system alias or shortcut that this object refers to. + * If successful, creates and returns a new Folder object that points to the resolved file system element. Returns null if this object does not refer to an alias, or if the alias could not be resolved. + */ + resolve(): Folder + + /** + * Opens the built-in platform-specific file-browsing dialog, and creates a new File or Folder object for the selected file or folder. + * Differs from the class method selectDialog() in that it preselects this folder. + * If the user clicks OK, returns a File or Folder object for the selected file or folder. + * If the user cancels, returns null. + * @param prompt The prompt text, if the dialog allows a prompt. + */ + selectDlg(prompt?: string): Folder + + /** + * Creates and returns a serialized string representation of this object. + * Pass the resulting string to eval() to recreate the object. + */ + toSource(): string + + /** + * Converts this object to a string. + */ + toString(): string +} + +interface SocketConstructor { + readonly prototype: Socket + + /** + * Creates a new Socket object. + */ + new (): Socket + (): Socket +} +declare const Socket: SocketConstructor + +/** + * Creates a TCP/IP connection, or establishes a TCP/IP server. + */ +interface Socket { + /** + * When true, the connection is active. + */ + readonly connected: boolean + + /** + * Sets or retrieves the name of the encoding used to transmit data. + * Typical values are "ASCII", "BINARY", or "UTF-8". + */ + encoding: string + + /** + * When true, the receive buffer is empty. + */ + readonly eof: boolean + + /** + * A message describing the most recent error. Setting this value clears any error message. + */ + error: string + + /** + * The name of the remote computer when a connection is established. + * If the connection is shut down or does not exist, the property contains the empty string. + */ + readonly host: string + + /** + * The timeout in seconds to be applied to read or write operations. + */ + timeout: number + + /** + * Terminates the open connection. + * Returns true if the connection was closed, false on I/O errors. + * Deleting the object also closes the connection, but not until JavaScript garbage-collects the object. The connection might stay open longer than you wish if you do not close it explicitly. + */ + close(): boolean + + /** + * Instructs the object to start listening for an incoming connection. + * The call to open() and the call to listen()are mutually exclusive. Call one function or the other, not both. + * @param port The TCP/IP port number to listen on. Valid port numbers are 1 to 65535. Typical values are 80 for a Web server, 23 for a Telnet server and so on. + * @param encoding The encoding to be used for the connection Typical values are "ASCII", "BINARY", or "UTF-8". + */ + listen(port: number, encoding?: string): boolean + + /** + * Opens the connection for subsequent read/write operations. + * The call to open() and the call to listen() are mutually exclusive. Call one function or the other, not both. + * @param host The server to connect to. This can be a DNS name, an IPv4 address, or an IPv6 address, followed by a colon and a port number. + * @param encoding The encoding to be used for the connection Typical values are "ASCII", "binary", or "UTF-8". + */ + open(host: string, encoding?: string): boolean + + /** + * Checks a listening object for a new incoming connection. + * If a connection request was detected, the method returns a new Socket object that wraps the new connection. Use this connection object to communicate with the remote computer. After use, close the connection and delete the JavaScript object. If no new connection request was detected, the method returns null. + */ + poll(): Socket + + /** + * Reads up to the specified number of characters from the connection. CR characters are ignored unless the encoding is set to "BINARY". + * Returns a string that contains up to the number of characters that were supposed to be read, or the number of characters read before the connection closed or timed out. + * @param count The number of characters to read. If not supplied, the connection attempts to read as many characters it can get and returns immediately. + */ + read(count?: number): string + + /** + * Reads one line of text up to the next line feed. + * Line feeds are recognized as LF or CRLF pairs. CR characters are ignored. Returns a string containing the characters. + */ + readln(): string + + /** + * Concatenates all arguments into a single string and writes that string to the connection. + * @param text Any number of string values. All arguments are concatenated to form the string to be written. CRLF sequences are converted to LFs unless the encoding is set to "BINARY". + */ + write(text: string): boolean + + /** + * Concatenates all arguments into a single string, appends a LF character, and writes that string to the connection. + * @param text Any number of string values. All arguments are concatenated to form the string to be written. CRLF sequences are converted to LFs unless the encoding is set to "BINARY". + */ + writeln(text: string): boolean +} + +/** + * Provides information about a method, a property or a method parameters. + */ +interface ReflectionInfo { + /** + * The description of method or function arguments. + */ + readonly arguments: ReflectionInfo[] + + /** + * The data type. + */ + readonly dataType: string + + /** + * The default value. + */ + readonly defaultValue: any + + /** + * The long description text. + */ + readonly description: string + + /** + * The short description text. + */ + readonly help: string + + /** + * Contains true if the class describes a collection class. + */ + readonly isCollection: boolean + + /** + * The maximum value. + */ + readonly max: number + + /** + * The minimum value. + */ + readonly min: number + + /** + * The element name. + */ + readonly name: string + + /** + * The class object that this element belongs to. + */ + readonly parent: Reflection + + /** + * Sample code, if present. + */ + readonly sampleCode: string + + /** + * A file containing sample code. May be null. + */ + readonly sampleFile: File + + /** + * The element type. + * One of unknown, readonly, readwrite, createonly, method or parameter. + */ + readonly type: string +} +declare const ReflectionInfo: ReflectionInfo + +/** + * Provides information about a class. + */ +interface Reflection { + /** + * The long description text. + */ + readonly description: string + + /** + * The short description text. + */ + readonly help: string + + /** + * An array of method descriptions. + */ + readonly methods: ReflectionInfo[] + + /** + * The class name. + */ + readonly name: string + + /** + * An array of property descriptions. + */ + readonly properties: ReflectionInfo[] + + /** + * Sample code, if present. + */ + readonly sampleCode: string + + /** + * A file containing sample code. May be null. + */ + readonly sampleFile: File + + /** + * An array of class method descriptions. + */ + readonly staticMethods: ReflectionInfo[] + + /** + * An array of class property descriptions. + */ + readonly staticProperties: ReflectionInfo[] + + /** + * Finds an element description by name. + * @param name The name of the element to find. + */ + find(name: string): ReflectionInfo + + /** + * Returns this class information as XML in OMV format. + */ + toXML(): XML +} +declare const Reflection: Reflection + +interface QNameConstructor { + readonly prototype: QName + + /** + * Creates a QName object. + * @param uri The URI, specified as a Namespace object, an existing QName object, or string. If this is a Namespace object, the URI is set to the namespace URI, and there is no local name. If this is a QName object, the URI and localName is set to those of that object. If this is a string, the URI is set to that string. + * @param name The local name. Used only if URI is given as a string. + */ + new (uri: any, name?: string): QName + (uri: any, name?: string): QName +} +declare const QName: QNameConstructor + +/** + * A qualified XML name, containing the URI and the local name. + */ +interface QName { + /** + * The local name part of the qualified name. + */ + readonly localName: string + + /** + * The URI part of the qualified name. + */ + readonly uri: string +} + +interface NamespaceConstructor { + readonly prototype: Namespace + + /** + * Creates a Namespace object. + * @param prefix The URIprefix, specified as an existing Namespace object, QName object, or string. If this is a Namespace or a QName object, the URI and prefix are set to that of the object. If this is a string, the prefix is set to that string, and the URI must be specified. + * @param uri The URI if the prefix is specified as a string. + */ + new (prefix: any, uri?: string): Namespace + (prefix: any, uri?: string): Namespace +} +declare const Namespace: NamespaceConstructor + +/** + * A XML namespace object. + */ +interface Namespace { + /** + * The named prefix. + */ + readonly prefix: string + + /** + * The URI. + */ + readonly uri: string +} + +interface XMLConstructor { + readonly prototype: XML + + /** + * Parses an XML string. Throws an error if the XML is incorrect. + * @param text The text to parse. + */ + new (text: string): XML + (text: string): XML + + /** + * Controls whether XML comments should be parsed (false) or ignored (true). + */ + ignoreComments: boolean + + /** + * Controls whether XML preprocessing instructions should be parsed (false) or ignored (true). + */ + ignoreProcessingInstructions: boolean + + /** + * Controls whether whitespace should be parsed (false) or ignored (true). + */ + ignoreWhitespace: boolean + + /** + * The number of spaces used to indent pretty-printed XML. + */ + prettyIndent: number + + /** + * When true, XML is pretty-printed when converting to a string. + */ + prettyPrinting: boolean + + /** + * Returns an object containing the default parsing and print settings for XML. + */ + defaultSettings(): object + + /** + * Sets the parsing and print setting for XML using an object returned by the settings() method. + * @param obj The object containing the settings to set. + */ + setSettings(obj: object): void + + /** + * Returns an object containing the current parsing and print settings for XML. + */ + settings(): object +} +declare const XML: XMLConstructor + +/** + * Wraps XML into an object. + */ +interface XML { + /** + * Adds a namespace declaration to the node. Returns the XML object itself. + * @param namespace The namespace to add. + */ + addNamespace(namespace: Namespace): XML + + /** + * Appends the given XML to this XML as a child. Returns the XML object itself. + * If the argument is not XML, creates a new XML element containing the argument as text. The element name of that new XML is the same as the last element in the original XML. + * @param child The child XML to add. + */ + appendChild(child: XML): XML + + /** + * Returns a list containing all attribute elements matching the given name. + * @param name The attribute name to look for. + */ + attribute(name: string): XML + + /** + * Returns a list containing all attribute elements. + */ + attributes(): XML + + /** + * Returns a list containing all children of this XML matching the given element name. + * If the argument is a number, uses the number as index into the array of children. + * @param name The name or the index of the child element. + */ + child(name: string): XML + + /** + * Returns a number representing the ordinal position of this XML object within the context of its parent. + */ + childIndex(): number + + /** + * Returns an XML object containing all the properties of this XML object in order. + */ + children(): XML + + /** + * Returns an XML object containing the properties of this XML object that represent XML comments. + */ + comments(): XML + + /** + * Checks if this XML object contains the given XML object. + * @param xml The XML to search for. + */ + contains(xml: XML): boolean + + /** + * Creates a copy of this XML object. + */ + copy(): XML + + /** + * Returns all the XML-valued descendants of this XML object with the given name. + * If the name parameter is omitted, returns all descendants of this XML object. + * @param name The name of the descendant to find. + */ + descendants(name?: string): XML + + /** + * Returns a list of XML children that are elements with a given name, or all children that are XML elements. + * @param name The element name. If not supplied, gets all children that are XML elements. + */ + elements(name?: string): XML + + /** + * Reports whether this XML object contains complex content. + * An XML object is considered to contain complex content if it represents an XML element that has child elements. XML objects representing attributes, comments, processing instructions and text nodes do not have complex content. The existence of attributes, comments, processing instructions and text nodes within an XML object is not significant in determining if it has complex content. + */ + hasComplexContent(): boolean + + /** + * Reports whether this XML object contains simple content. + * An XML object is considered to contain simple content if it represents a text node, represents an attribute node or if it represents an XML element that has no child elements. XML objects representing comments and processing instructions do not have simple content. The existence of attributes, comments, processing instructions and text nodes within an XML object is not significant in determining if it has simple content. + */ + hasSimpleContent(): boolean + + /** + * Returns an array of Namespace objects mirroring the current list of valid namespaces at this element. + * The last element of thereturned array is the default namespace. + */ + inScopeNamespaces(): Namespace[] + + /** + * Inserts the given child2 after the given child1 in this XML object and returns this XML object. + * If child1 is null, the method inserts child2 before all children of this XML object (that is, after none of them). If child1 does not exist in this XML object, the method returns without modifying this XML object. + * @param child1 The child to insert the other child after. If null, the method inserts child2 before all children of this XML object. + * @param child2 The XML to insert. + */ + insertChildAfter(child1: XML, child2: XML): void + + /** + * Inserts the given child2 before the given child1 in this XML object and returns this XML object. + * If child1 is null, the method inserts child2 after all children of this XML object (that is, before none of them). If child1 does not exist in this XML object, the method returns without modifying this XML object. + * @param child1 The child to search for. If null, the method inserts child2 after all children of this XML object. + * @param child2 The XML to insert. + */ + insertChildBefore(child1: XML, child2: XML): void + + /** + * Returns the number of elements contained in an XML list. If this XML object is not a list, returns 1. + */ + length(): number + + /** + * Returns the local name of this XML object. + * This value corresponds to the element name unless the name has a namespace prefix. For example, if the element has the name "ns:tag", the return value is "tag". + */ + localName(): string + + /** + * Returns a QName object containing the URI and the local name of the element. + */ + name(): QName + + /** + * Returns a Namespace object containing the namespace URI of the current element. + */ + namespace(): Namespace + + /** + * Returns an array containing all namespace declarations of this XML object. + */ + namespaceDeclarations(): Namespace[] + + /** + * Returns the type of this XML object as one of the strings "element", "attribute", "comment", "processing-instruction", or "text". + */ + nodeKind(): string + + /** + * Puts all text nodes in this and all descendant XML objects into a normal form by merging adjacent text nodes and eliminating empty text nodes. Returns this XML object. + */ + normalize(): XML + + /** + * Returns the parent object of this XML object. + * The root object, as returned by the XML constructor, does not have a parent and returns null. Note that the E4X standard does not define what happens if this XML object is a list containing elements with multiple parents. + */ + parent(): XML + + /** + * Inserts a given child into this object before its existing XML properties, and returns this XML object. + * @param child The XML to insert. + */ + prependChild(child: XML): XML + + /** + * Returns a list of preprocessing instructions. + * Collects processing-instructions with the given name, if supplied. Otherwise, returns an XML list containing all the children of this XML object that are processing-instructions regardless of their name. + * @param name The name of the preprocessing instruction to return. + */ + processingInstructions(name?: string): XML + + /** + * Removes the given namespace from this XML, and returns this XML. + * @param namespace The namespace to remove. + */ + removeNamespace(namespace: Namespace): XML + + /** + * Replaces the value of specified XML properties of this XML object returns this XML object. + * This method acts like the assignment operator. + * @param name The property name. Can be a numeric property name, a name for a set of XML elements, or the properties wildcard “*”. If this XML object contains no properties that match the name, the method returns without modifying this XML object. + * @param value The XML with which to replace the value of the matching property. Can be an XML object, XML list or any value that can be converted to a String with toString(). + */ + replace(name: string, value: XML): XML + + /** + * Replaces all of the XML-valued properties in this object with a new value, and returns this XML object. + * @param value The new value, which can be a single XML object or an XML list. + */ + setChildren(value: XML): XML + + /** + * Replaces the local name of this XML objectwith a string constructed from the given name + * The local name is any part behind a colon character. If there is no colon, it is the entire name. + * @param name The name to set. + */ + setLocalName(name: string): void + + /** + * Replaces the name of this XML object with the given QName object. + * @param name The fully qualified name. + */ + setName(name: QName): void + + /** + * Sets the namespace for this XML element. + * If the namespace has not been declared in the tree above this element, adds a namespace declaration. + * @param namespace The namespace to set. + */ + setNamespace(namespace: Namespace): void + + /** + * Returns an XML list containing all XML properties of this XML object that represent XML text nodes. + */ + text(): XML + + /** + * Returns the string representation of this object. + * For text and attribute nodes, this is the textual value of the node; for other elements, this is the result of calling the toXMLString() method. If this XML object is a list, concatenates the result of calling toString() on each element. + */ + toString(): string + + /** + * Returns an XML-encoded string representation of this XML object. + * Always includes the start tag, attributes and end tag of the XML object regardless of its content. It is provided for cases when the default XML to string conversion rules are not desired. Interprets the global settings XML.prettyPrint and XML.prettyIndent. + */ + toXMLString(): string + + /** + * Evaluates the given XPath expression in accordance with the W3C XPath recommendation, using this XML object as the context node. + * @param expr The XPath expression to use. + */ + xpath(expr: string): XML +} + +/** + * An XML list object. + * In this implementation, an XMLList object is synonymous to the XML object. The constructor accepts an XML list, but everything else works like theXML object. + */ +interface XMLList {} +declare const XMLList: XMLList +type UnitNameAbbrev = 'in' | 'ft' | 'yd' | 'mi' | 'mm' | 'cm' | 'm' | 'km' | + 'pt' | 'pc' | 'tpt' | 'tpc' | 'ci' | 'px' | '%' + +type UnitName = UnitNameAbbrev | + 'inch' | 'inches' | + 'foot' | 'feet' | + 'yard' | 'yards' | + 'mile' | 'miles' | + 'millimeter' | 'millimeters' | + 'centimeter' | 'centimeters' | + 'meter' | 'meters' | + 'kilometer' | 'kilometers' | + 'point' | 'points' | + 'pica' | 'picas' | + 'traditional point' | 'traditional points' | + 'traditional pica' | 'traditional picas' | + 'cicero' | 'ciceros' | + 'pixel' | 'pixels' | + 'percent' | 'percent' + +interface UnitValueConstructor { + readonly prototype: UnitValue + + /** + * Creates a new UnitValue object. + */ + new (value: string | number | UnitValue, unitName?: UnitName): UnitValue + (value: string | number | UnitValue, unitName?: UnitName): UnitValue + + /** + * The base unit for all conversions. + */ + baseUnit: UnitValue +} +declare const UnitValue: UnitValueConstructor + +/** + * Represents a measurement as a combination of values and unit. + * Note that this object is not available in all applications. + */ +interface UnitValue { + /** + * The base unit. + */ + baseUnit: UnitValue + + /** + * The unit name. + */ + readonly type: UnitNameAbbrev | '?' + + /** + * The numeric value. + */ + value: number + + /** + * Returns this instance as a different unit. + * @param unitName The unit name. + */ + as(unitName: UnitNameAbbrev): UnitValue + + /** + * Converts this instance to a different unit. + * @param unitName The unit name. + */ + convert(unitName: UnitNameAbbrev): boolean +} + +/** + * Only for TypeScript compatibility + */ +interface CallableFunction extends Function { + +} + +interface NewableFunction extends Function { + +} + +interface IArguments { + [index: number]: any + length: number + callee: Function +} + +/** + * Make all properties in T optional + */ +type Partial = { [P in keyof T]?: T[P] } + +/** + * Make all properties in T readonly + */ +type Readonly = { readonly [P in keyof T]: T[P] } + +/** + * From T pick a set of properties K + */ +type Pick = { [P in K]: T[P] } + +/** + * Construct a type with a set of properties K of type T + */ +type Record = { [P in K]: T } diff --git a/src/types/PlugPlugExternalObject.d.ts b/src/types/PlugPlugExternalObject.d.ts new file mode 100644 index 0000000..8138887 --- /dev/null +++ b/src/types/PlugPlugExternalObject.d.ts @@ -0,0 +1,91 @@ +/// + +interface ExternalObjectConstructor { + readonly prototype: ExternalObject + + /** + * Creates a new ExternalObject object. + */ + new (lib: string): ExternalObject + (lib: string): ExternalObject +} +declare const ExternalObject: ExternalObjectConstructor + +interface ExternalObject { + /** + * Set to true to write status information to standard output (the + * JavaScript Console in the ExtendScript Toolkit). Set to false to turn + * logging off. Default is false. + */ + log: boolean + + /** + * A set of alternate paths in which to search for the shared library files, a + * single string with multiple path specifications delimited by semicolons + * (;). Paths can be absolute or relative to the Folder.startup location. + */ + searchFolders: string + + /** + * The version of the library, as returned by ESGetVersion() + */ + version: number + + /** + * Reports whether a compiled C/C++ library can be found, but does not load it. If logging is on, the + * paths searched are reported to the JavaScript Console in the ExtendScript Toolkit. + * Returns true if the library is found, false otherwise. + * @param spec The file specification for the compiled library, with or without path information. + */ + search(spec: string): boolean + + /** + * Explicitly shuts down the ExternalObject dynamic library wrapped by this instance. + * It can be helpful to force a shutdown of the external library if termination of external libraries during + * the shutdown of the hosting application does not occur in the correct order. + */ + terminate(): undefined +} + +interface CSXSEventConstructor { + readonly prototype: CSXSEvent + + /** + * Creates a new CSXSEvent object. + */ + new (type?: string, scope?: string, data?: string): CSXSEvent + (type?: string, scope?: string, data?: string): CSXSEvent +} +declare const CSXSEvent: CSXSEventConstructor + +interface CSXSEvent { + /** + * Retrieves the unique identifier of the application from which this event was dispatched. + */ + readonly appId: string + + /** + * Retrieves or sets the payload of this event. + */ + data: string + + /** + * Retrieves the unique identifier of the extension from which this event was dispatched. + */ + readonly extensionId: string + + /** + * Retrieves the scope of this event. + */ + scope: string + + /** + * Retrieves the type of this event. + */ + type: string + + /** + * Dispatch the event + */ + dispatch(): void +} diff --git a/src/types/ScriptUI.d.ts b/src/types/ScriptUI.d.ts new file mode 100644 index 0000000..b578dcc --- /dev/null +++ b/src/types/ScriptUI.d.ts @@ -0,0 +1,3007 @@ +/// + +declare enum _Alignment { + TOP = 1, + BOTTOM = 2, + LEFT = 3, + RIGHT = 4, + FILL = 5, + CENTER = 6, +} + +declare enum _FontStyle { + REGULAR, + BOLD, + ITALIC, + BOLDITALIC, +} + +declare const enum _BrushOrPenType { + SOLID_COLOR, + THEME_COLOR, +} + +type _Bounds = Bounds +type _Dimension = Dimension + +type _Margins = Margins | number + +type _AlignmentProperty = + | "left" + | "right" + | "fill" + | "center" + | "top" + | "bottom" + | "fill" + | "center" + | ["left" | "right" | "fill" | "center", "top" | "bottom" | "fill" | "center"] + | [ + _Alignment.LEFT | _Alignment.RIGHT | _Alignment.FILL | _Alignment.CENTER, + _Alignment.TOP | _Alignment.BOTTOM | _Alignment.FILL | _Alignment.CENTER, + ] + +type _AlignmentPropertyTitleLayout = + | ["left" | "right" | "center", "top" | "bottom" | "center"] + | [ + _Alignment.LEFT | _Alignment.RIGHT | _Alignment.CENTER, + _Alignment.TOP | _Alignment.BOTTOM | _Alignment.CENTER, + ] + +type _Justify = "left" | "center" | "right" + +type _Orientation = "row" | "column" | "stack" + +type _Truncate = "middle" | "end" | "none" + +/** + * A global class containing central information about ScriptUI. Not instantiable. + */ +declare class ScriptUI { + /** + * Collects the enumerated values that can be used in the alignment and alignChildren properties of controls and containers. + * Predefined alignment values are: TOP, BOTTOM, LEFT, RIGHT, FILL, CENTER + */ + static readonly Alignment: _Alignment + + /** + * Collects the enumerated values that can be used as the style argument to the ScriptUI.newFont() method. + * Predefined styles are REGULAR, BOLD, ITALIC, BOLDITALIC. + */ + static readonly FontStyle: _FontStyle + + /** + * The font constants defined by the host application. + */ + static readonly applicationFonts: object + + /** + * An object whose properties are the names of compatibility modes supported by the host application. + * The presence of ScriptUI.compatibility.su1PanelCoordinates means that the application allows backward compatibility with the coordinate system of Panel elements in ScriptUI version 1. + */ + static readonly compatibility: object + + /** + * A string containing the internal version number of the ScriptUI module. + */ + static readonly coreVersion: string + + /** + * An object whose properties define attributes of the environment in which ScriptUI operates. + */ + static readonly environment: Environment + + /** + * An object whose properties and methods provide access to objects used in the ScriptUI event system. + * It contains one function, createEvent(), which allows you to create event objects in order to simulate user-interaction event + */ + static readonly events: Events + + /** + * A string containing the name of the UI component framework with which this version of ScriptUI is compatible. + */ + static readonly frameworkName: string + + /** + * A string containing the version number of the ScriptUI component framework + */ + static readonly version: any + + /** + * Finds and returns the resource for a given text string from the host application's resource data. + * If no string resource matches the given text, the text itself is returned. + * @param text The text to match. + */ + static getResourceText(text: string): string + + /** + * Creates a new font object for use in text controls and titles. + * @param name The font name, or the font family name. + * @param style The font style; can be string, or one of the values of ScriptUI.FontStyle. + * @param size The font size in points. + */ + static newFont(name: string, style: string, size: number): ScriptUIFont + + /** + * Loads a new image from resources or disk files into an image object. + * Creates a new global image object for use in controls that can display images, loading the associated images from the specified resources or image files. + * @param normal The resource name or the disk file path to the image used for the normal state. + * @param disabled The resource name, or the disk file path to the image used for the disabled state. + * @param pressed The resource name, or the file-system path to the image used for the pressed state. + * @param rollover The resource name, or the file-system path to the image used for the rollover state. + */ + static newImage( + normal: string, + disabled?: string, + pressed?: string, + rollover?: string, + ): ScriptUIImage +} + +/** + * The instance represents a top-level window or dialog box, which contains user-interface elements. + * The globally available Window object provides access to predefined and script-defined windows. + */ +declare class Window extends _Control { + /** + * Set to true to make this window active. + * A modal dialog that is visible is by definition the active dialog. + * An active palette is the front-most window. + * An active control is the one with focus—that is, the one that accepts keystrokes, or in the case of a Button, be selected when the user typesReturn or Enter. + */ + active: boolean + + /** + * Tells the layout manager how unlike-sized children of this container should be aligned within a column or row. + * Order of creation determines which children are at the top of a column or the left of a row; the earlier a child is created, the closer it is to the top or left of its column or row. If defined, alignment for a child element overrides the alignChildren setting for the parent container. See alignment property for values. + */ + alignChildren: _AlignmentProperty + + /** + * For windows of type dialog, the UI element to notify when the user presses a cancellation key combination. + * The cancellation key is the Esc key. By default, looks for a button whose name or text is "cancel" (case disregarded). + */ + cancelElement: object + + /** + * A number of characters for which to reserve space when calculating the preferred size of the window. + */ + characters: number + + /** + * The collection of UI elements that have been added to this container. + * An array indexed by number or by a string containing an element's name. The length property of this array is the number of child elements for container elements, and is zero for controls. + */ + readonly children: _Control[] + + /** + * For windows of type dialog, the UI element to notify when the user presses a Enter key. + * By default, looks for a button whose name or text is "ok" (case disregarded). + */ + defaultElement: object + + /** + * The bounds of the window frame in screen coordinates. + * The frame consists of the title bar and borders that enclose the content region of a window, depending on the windowing system. + */ + readonly frameBounds: _Bounds + + /** + * The top left corner of the window frame in screen coordinates. + * The same as [frameBounds.x, frameBounds.y]. Set this value to move the window frame to the specified location on the screen. The frameBounds value changes accordingly. + */ + frameLocation: Point + + /** + * The size and location of the window's frame in screen coordinates. + */ + readonly frameSize: _Dimension + + /** + * Deprecated. Use ScriptUI.frameworkName instead. + */ + static readonly frameworkName: string + + /** + * The graphics object that can be used to customize the window’s appearance, in response to the onDraw event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The default text justification style for child text elements. + * One of left, center, or right. Justification only works if this value is set on creation of the element. + */ + justify: _Justify + + /** + * The layout manager for this container. + * The first time a container object is made visible, ScriptUI invokes this layout manager by calling its layout() function. Default is an instance of the LayoutManager class that is automatically created when the container element is created. + */ + layout: AutoLayoutManager + + /** + * The number of pixels between the edges of a container and the outermost child elements. + * You can specify different margins for each edge of the container. The default value is based on the type of container, and is chosen to match the standard Adobe UI guidelines. + */ + margins: _Margins + + /** + * True if the window is expanded. + */ + maximized: boolean + + /** + * True if the window is minimized or iconified. + */ + minimized: boolean + + /** + * The opacity of the window, in the range [0..1]. + * A value of 1.0 (the default) makes the window completely opaque, a value of 0 makes it completely transparent. Intermediate values make it partially transparent to any degree. + */ + opacity: number + + /** + * The layout orientation of children in a container. + * Interpreted by the layout manager for the container. The default LayoutManager  Object accepts the (case-insensitive) values row, column, or stack.For window and panel, the default is column, and for group the default is row. The allowed values for the container’s alignChildren and its children’s alignment properties depend on the orientation. + */ + orientation: _Orientation + + /** + * The keypress combination that invokes this element's onShortcutKey() callback. + */ + shortcutKey: string + + /** + * The number of pixels separating one child element from its adjacent sibling element. + * Because each container holds only a single row or column of children, only a single spacing value is needed for a container. The default value is based on the type of container, and is chosen to match standard Adobe UI guidelines. + */ + spacing: number + + /** + * The title, label, or displayed text, a localizable string. + * Does not apply to containers of type group. + */ + text: string + + /** + * Deprecated. Use ScriptUI.version instead. + */ + static readonly version: any + + /** + * Creates a new window. + * @param type The window type. One of: window: Creates a simple window that can be used as a main window for an application. (Not supported by Photoshop CS3.) palette: Creates a modeless dialog, also called a floating palette. (Not supported by Photoshop CS3.) dialog: Creates a modal dialog. This argument can also be a ScriptUI resource specification; in that case, all other arguments are ignored. + * @param title The window title, a localizable string. + * @param bounds The window's position and size. + * @param properties An object containing creation-only properties. + */ + constructor( + type: "dialog" | "palette" | "window", + title?: string, + bounds?: _Bounds, + properties?: _AddControlPropertiesWindow, + ) + + /** + * Creates and returns a new control or container object and adds it to the children of this window. + * @param type The type of the child element, as specified for the type property. Control types are listed in the JavaScript Tools Guide. + * @param bounds A bounds specification that describes the size and position of the new control or container, relative to its parent. If supplied, this value creates a new Bounds object which is assigned to the new object’s bounds property. + * @param text The text or label, a localizable string. Initial text to be displayed in the control as the title, label, or contents, depending on the control type. If supplied, this value is assigned to the new object’s text property. + * @param properties An object that contains one or more creation properties of the new child (properties used only when the element is created). The creation properties depend on the element type. See properties property of each control type. + */ + add: _AddControl + + /** + * Displays a platform-standard dialog containing a short message and an OK button. + * @param message TThe string for the displayed message. + * @param title A string to appear as the title of the dialog, if the platform supports a title. Ignored in Mac OS, which does not support titles for alert dialogs. The default title string is "Script Alert". + * @param errorIcon When true, the platform-standard alert icon is replaced by the platform-standard error icon in the dialog. Ignored in Mac OS, which does not support icons for alert dialogs. + */ + static alert(message: string, title?: string, errorIcon?: boolean): void + + /** + * Centers this window on screen or with respect to another window. + * @param window The relative window. If not specified, centers on the screen. + */ + center(window?: Window): void + + /** + * Closes this window. + * . If an onClose() callback is defined for the window, calls that function before closing the window. + * @param return_ A number to be returned from the show() method that invoked this window as a modal dialog. + */ + close(return_?: any): void + + /** + * Displays a platform-standard dialog containing a short message and two buttons labeled Yes and No. + * Returns true if the user clicked Yes, false if the user clicked No. + * @param message The string for the displayed message. + * @param noAsDefault When true, the No button is the default choice, selected when the user types Enter. Default is false, meaning that Yes is the default choice. + * @param title A string to appear as the title of the dialog, if the platform supports a title. Ignored in Mac OS, which does not support titles for alert dialogs. The default title string is "Script Alert". + */ + static confirm(message: string, noAsDefault: boolean, title?: string): boolean + + /** + * Use this method to find an existing window. + * This includes windows defined by ScriptUI resource strings, windows already created by a script, and windows created by the application (if the application supports this case). This function is not supported by all applications. Returns a Window object found or generated from the resource, or null if no such window or resource exists. + * @param type The name of a predefined resource available to JavaScript in the current application; or the window type. If a title is specified, the type is used if more than one window with that title is found. Can be null or the empty string. + * @param title The window title. + */ + static find(type: string, title: string): Window + + /** + * Sends a notification message to all listeners, simulating the specified user interaction event. + * @param eventName The event name; if omitted, the default event is sent. One of: onClose, onMove, onMoving, onResize, onResizing, onShow + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the window acquires the keyboard focus. + * Called when the user gives the window the keyboard focus by clicking it or otherwise making it the active window. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the window is about to be closed. + * Called when a request is made to close the window, either by an explicit call to the close() function or by a user action (clicking the OS-specific close icon in the title bar). The function is called before the window actually closes; it can return false to cancel the close operation. + */ + onClose(): boolean + + /** + * An event-handler callback function, called when the window loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active window to another window. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window has been moved + */ + onMove(): void + + /** + * An event-handler callback function, called when the window is being moved + * Called while a window in being moved, each time the position changes. A handler can monitor the move operation. + */ + onMoving(): void + + /** + * An event-handler callback function, called after the window has been resized + */ + onResize(): void + + /** + * An event-handler callback function, called while a window is being resized + * Called while a window is being resized, each time the height or width changes. A handler can monitor the resize operation. + */ + onResizing(): void + + /** + * In Windows only, an event-handler callback function, called a shortcut-key sequence is typed that matches the shortcutKey value for this window. + */ + onShortcutKey(): void + + /** + * An event-handler callback function, called just before the window is displayed + * Called when a request is made to open the window using the show() method, before the window is made visible, but after automatic layout is complete. A handler can modify the results of the automatic layout. + */ + onShow(): void + + /** + * Displays a modal dialog that returns the user’s text input. + * Returns the value of the text edit field if the user clicked OK, null if the user clicked Cancel. + * @param prompt The string for the displayed message. + * @param default_ The initial value to be displayed in the text edit field. + * @param title A string to appear as the title of the dialog. In Windows, this appears in the window’s frame; in Mac OS it appears above the message. The default title string is "Script Prompt". + */ + static prompt(prompt: string, default_?: string, title?: string): string | null + + /** + * Removes the specified child control from this window’s children array. + * No error results if the child does not exist. + * @param what The child control to remove, specified by 0-based index, text property value, or as a control object. + */ + remove(what: any): void +} + +/** + * Controls the automatic layout behavior for a window or container. + * The subclass AutoLayoutManager implements the default automatic layout behavior. + */ +declare class AutoLayoutManager { + /** + * Invokes the automatic layout behavior for the managed container. + * Adjusts sizes and positions of the child elements of this window or container according to the placement and alignment property values in the parent and children. + * Invoked automatically the first time the window is displayed. Thereafter, the script must invoke it explicitly to change the layout in case of changes in the size or position of the parent or children. + * + * @param recalculate Optional. When true, forces the layout manager to recalculate the container size for this and any child containers. Default is false. + */ + layout(recalculate?: boolean): void + + /** + * Performs a layout after a Window is resized, based on the new size. + * Resizes the child elements of the managed container with a given alignment type, after the window has been resized by the user. + */ + resize(): void +} + +/** + * A drawing pen that defines a color and line width used to stroke paths. + * Create with ScriptUIGraphics.newPen(). Use as a value of  foregroundColor properties, and pass as an argument to drawString() and strokePath() methods. + */ +declare class ScriptUIPen { + /** + * The pen color. + * The paint color to use when the type is SOLID_COLOR. An array in the form [R, B, G, A] specifying the red, green, blue values of the color and the opacity (alpha channel) value as numbers in the range [0.0..1.0]. An opacity of 0 is fully transparent, and an opacity of 1 is fully opaque. + */ + readonly color: number[] + + /** + * The pixel width of the drawing line. + */ + lineWidth: number + + /** + * The theme name. + * The name of a color theme to use for drawing when the type is THEME_COLOR. Theme colors are defined by the host application. + */ + readonly theme: string + + /** + * The pen type, solid or theme. + * One of these constants: ScriptUIGraphics.PenType.SOLID_COLOR or ScriptUIGraphics.PenType.THEME_COLOR + */ + readonly type: typeof ScriptUIGraphics.PenType +} + +/** + * A painting brush that encapsulates a color or pattern used to fill paths. + * Create with ScriptUIGraphics.newBrush(). Use as a value of  backgroundColor properties, and pass as an argument to the fillPath() method. + */ +declare class ScriptUIBrush { + /** + * The brush color. + * The paint color to use when the type is SOLID_COLOR. An array in the form [R, B, G, A] specifying the red, green, blue values of the color and the opacity (alpha channel) value as numbers in the range [0.0..1.0]. An opacity of 0 is fully transparent, and an opacity of 1 is fully opaque. + */ + readonly color: number[] + + /** + * The theme name. + * The name of a color theme to use for drawing when the type is THEME_COLOR. Theme colors are defined by the host application. + */ + readonly theme: string + + /** + * The brush type, solid or theme. + * One of these constants: ScriptUIGraphics.BrushType.SOLID_COLOR or ScriptUIGraphics.BrushType.THEME_COLOR + */ + readonly type: typeof ScriptUIGraphics.BrushType +} + +/** + * A helper object that encapsulates a drawing path for a figure to be drawn into a window or control. + * Create with the newPath(), moveto(), lineto(), rectPath(), and ellipsePath() methods.Used as value of currentPath, where it is acted upon by methods such as closePath().Pass as optional argument to fillPath() and strokePath(), which otherwise act upon the current path. + */ +declare class ScriptUIPath {} + +/** + * An object used to draw custom graphics, found in the graphics property of window, container, and control objects. + * Allows a script to customize aspects of the element’s appearance, such as the color and font. Use an onDraw callback function to set these properties or call the functions.All measurements are in pixels. + */ +declare class ScriptUIGraphics { + /** + * Contains the enumerated constants for the type argument of newBrush(). + * Type constants are: SOLID_COLOR, THEME_COLOR. + */ + static readonly BrushType: _BrushOrPenType + + /** + * Contains the enumerated constants for the type argument of newPen(). + * Type constants are: SOLID_COLOR, THEME_COLOR. + */ + static readonly PenType: _BrushOrPenType + + /** + * The background color for containers; for non-containers, the parent background color. + * The paint color and style is defined in this brush object.This property is only supported for controls like dropdownlist, edittext, and listbox. + */ + backgroundColor: ScriptUIBrush + + /** + * The current drawing path, encapsulated in a path object. + */ + readonly currentPath: ScriptUIPath + + /** + * The current position in the current drawing path. + */ + readonly currentPoint: Point + + /** + * The background color for containers when disabled or inactive; for non-containers, the parent background color. + * The paint color and style is defined in this brush object.This property is only supported for controls like dropdownlist, edittext, and listbox. + */ + disabledBackgroundColor: ScriptUIBrush + + /** + * The text color when the element is disabled or inactive. + * The paint color and style is defined in this pen object. + */ + disabledForegroundColor: ScriptUIPen + + /** + * The default font to use for displaying text. + */ + font: ScriptUIFont + + /** + * The text color. + * The paint color and style is defined in this pen object. + */ + foregroundColor: ScriptUIPen + + /** + * Closes the current path. + * Defines a line from the current position (currentPoint) to the start point of the current path (the value of currentPath). + */ + closePath(): void + + /** + * Draws a focus ring within a region of this element. + * @param left The left coordinate of the region. Value is relative to the origin of this element. + * @param top The top coordinate of the region. Value is relative to the origin of this element. + * @param width The width of the region in pixels. + * @param height The height of the region in pixels. + */ + drawFocusRing(left: number, top: number, width: number, height: number): void + + /** + * Draws an image within a given region of the element. + * Uses the version of the image that is appropriate to the element's current state. + * @param image The image to draw. This object contains different versions of an image appropriate to various element states, such as a dimmed version for the disabled state. + * @param left The left coordinate of the region, relative to the origin of this element. + * @param top The top coordinate of the region, relative to the origin of this element. + * @param width The width in pixels. If provided, the image is stretched or shrunk to fit. If omitted, uses the original image width. + * @param height The height in pixels. If provided, the image is stretched or shrunk to fit. If omitted, uses the original image height. + */ + drawImage(image: ScriptUIImage, left: number, top: number, width?: number, height?: number): void + + /** + * Draw the platform-specific control associated with this element. + */ + drawOSControl(): void + + /** + * Draw a string of text starting at a given point in this element, using a given drawing pen and font. + * @param text The text string. + * @param pen The drawing pen to use. + * @param x The left coordinate, relative to the origin of this element. + * @param y The top coordinate, relative to the origin of this element. + * @param font The font to use. Default is the  font value in this object. + */ + drawString(text: string, pen: ScriptUIPen, x: number, y: number, font?: ScriptUIFont): void + + /** + * Defines an elliptical path within a given rectangular area in the currentPath object, which can be filled using fillPath() or stroked using strokePath(). + * Returns a Point object for the upper left corner of the area, which is the new currentPoint. + * @param left The left coordinate of the region, relative to the origin of this element. + * @param top The top coordinate of the region, relative to the origin of this element. + * @param width The width of the region in pixels. + * @param height The height of the region in pixels. + */ + ellipsePath(left: number, top: number, width: number, height: number): Point + + /** + * Fills a path using a given painting brush. + * @param brush The brush object that defines the fill color. + * @param path The path object. Default is the currentPath. + */ + fillPath(brush: ScriptUIBrush, path?: ScriptUIPath): void + + /** + * Adds a path segment to the currentPath. + * The line is defined from the currentPoint to the specified destination point. Returns the Point object for the destination point, which becomes the new value of currentPoint. + * @param x The X coordinate for the destination point, relative to the origin of this element. + * @param y The Y coordinate for the destination point, relative to the origin of this element. + */ + lineTo(x: number, y: number): Point + + /** + * Calculates the size needed to display a string using the given font. + * Returns a Dimension object that contains the height and width of the string in pixels. + * @param text The text string to measure. + * @param font The font to use. Default is the font value in this object. + * @param boundingWidth The bounding width. + */ + measureString(text: string, font?: ScriptUIFont, boundingWidth?: number): _Dimension + + /** + * Adds a given point to the currentPath, and makes it the current drawing position. + * Returns the Point object which is the new value of currentPoint. + * @param x The X coordinate for the new point, relative to the origin of this element. + * @param y The Y coordinate for the new point, relative to the origin of this element. + */ + moveTo(x: number, y: number): Point + + /** + * Creates a new painting brush object. + * @param type The brush type, solid or theme. One of the constants ScriptUIGraphics.BrushType.SOLID_COLOR or ScriptUIGraphics.BrushType.THEME_COLOR. + * @param color The brush color. If type is SOLID_COLOR, the color expressed as an array of three or four values, in the form [R, B, G, A] specifying the red, green, and blue values of the color and, optionally, the opacity (alpha channel). All values are numbers in the range [0.0..1.0]. An opacity of 0 is fully transparent, and an opacity of 1 is fully opaque. If the type is THEME_COLOR, the name string of the theme. Theme colors are defined by the host application. + */ + newBrush(type: typeof ScriptUIGraphics.BrushType, color: number[]): ScriptUIBrush + + /** + * Creates a new, empty path object. + * Replaces any existing path in currentPath. + */ + newPath(): ScriptUIPath + + /** + * Creates a new drawing pen object. + * @param type The pen type, solid or theme. One of the constants ScriptUIGraphics.PenType.SOLID_COLOR or ScriptUIGraphics.PenType.THEME_COLOR. + * @param color The pen color. If type is SOLID_COLOR, the color expressed as an array of three or four values, in the form [R, B, G, A] specifying the red, green, and blue values of the color and, optionally, the opacity (alpha channel). All values are numbers in the range [0.0..1.0]. An opacity of 0 is fully transparent, and an opacity of 1 is fully opaque. If the type is THEME_COLOR, the name string of the theme. Theme colors are defined by the host application. + * @param width The width of the pen line in pixels. The line is centered around the current point. For example, if the value is 2, drawing a line from (0, 10) to (5, 10) paints the two rows of pixels directly above and below y-position 10. + */ + newPen(type: typeof ScriptUIGraphics.PenType, color: number[], width: number): ScriptUIPen + + /** + * Defines a rectangular path in the currentPath object. + * The rectangle can be filled using fillPath() or stroked using strokePath().Returns the Point object for the upper left corner of the rectangle, which becomes the new value of currentPoint. + * @param left The left coordinate relative to the origin of this element. + * @param top The top coordinate relative to the origin of this element. + * @param width The width in pixels. + * @param height The height in pixels. + */ + rectPath(left: number, top: number, width: number, height: number): Point + + /** + * Strokes the path segments of a path with a given drawing pen. + * @param pen The drawing pen that defines the color and line width. + * @param path The path object. Default is the currentPath. + */ + strokePath(pen: ScriptUIPen, path?: ScriptUIPath): void +} + +/** + * Describes an input state at the time of the triggering  ScriptUIGraphics.onDraw() event. + * Contains properties that report whether the current control has the input focus, and the particular mouse button and keypress state. Passed in as argument to ScriptUIGraphics.onDraw(). + */ +declare class DrawState { + /** + * True if the Alt key is being pressed (in Windows only). + */ + readonly altKeyPressed: boolean + + /** + * True if the Caps Lock key is being pressed. + */ + readonly capsLockKeyPressed: boolean + + /** + * True if the Command key is being pressed (in Mac OS only). + */ + readonly cmdKeyPressed: boolean + + /** + * True if the Ctrl key is being pressed. + */ + readonly ctrlKeyPressed: boolean + + /** + * True if the element has the input focus. + */ + readonly hasFocus: boolean + + /** + * True if the left mouse button is being pressed. + */ + readonly leftButtonPressed: boolean + + /** + * True if the middle mouse button is being pressed. + */ + readonly middleButtonPressed: boolean + + /** + * True if the cursor is hovering over this element. + */ + readonly mouseOver: boolean + + /** + * True if the Num Lock key is being pressed. + */ + readonly numLockKeyPressed: boolean + + /** + * True if the Option key is being pressed (in Mac OS only). + */ + readonly optKeyPressed: boolean + + /** + * True if the right mouse button is being pressed. + */ + readonly rightButtonPressed: boolean + + /** + * True if the Shift key is being pressed. + */ + readonly shiftKeyPressed: boolean +} + +/** + * Encapsulates the qualities of a font used to draw text into a control. + * Create with the newFont() method.Used as a value of font. Passed as an argument to drawString() and measureString(). + */ +declare class ScriptUIFont { + /** + * The font family name. + */ + readonly family: string + + /** + * The complete font name, consisting of the family and style, if specified. + */ + readonly name: string + + /** + * The font point size. + */ + readonly size: number + + /** + * The font style. One of the constants in ScriptUI.FontStyle. + */ + readonly style: typeof ScriptUI.FontStyle + + /** + * The name of a substitution font, a fallback font to substitute for this font if the requested font family or style is not available. + */ + readonly substitute: string +} + +/** + * Encapsulates a set of images that can be drawn into a control. + * Different images can reflect the current state, such as a dimmed version for a disabled control. Create with the newImage() method. Passed as an argument to drawImage(). + */ +declare class ScriptUIImage { + /** + * The image format. One of: resource, JPEG, GIF, TIFF, PNG, or PICT (Macintosh). + */ + readonly format: string + + /** + * The image name. Either the file name, or the resource name. + */ + readonly name: string + + /** + * The full path to the file that contains the image. + */ + readonly pathname: string + + /** + * The image size in pixels. + */ + readonly size: _Dimension +} + +/** + * A text label that the user cannot change. + */ +declare class StaticText extends _Control { + /** + * Always false. This element cannot have input focus. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * A number of characters for which to reserve space when calculating the preferred size of the element. + */ + characters: number + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The text justification style. + * One of left, center, or right. Justification only works if this value is set on creation of the element. + */ + justify: _Justify + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * The text to display, a localizable string. + */ + text: string + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * A pushbutton element containing a mouse-sensitive text string. + * Calls the onClick() callback if the control is clicked or if its notify() method is called. + */ +declare class Button extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * A number of characters for which to reserve space when calculating the preferred size of the element. + */ + characters: number + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The text justification style. + * One of left, center, or right. Justification only works if this value is set on creation of the element. + */ + justify: _Justify + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * The text to display, a localizable string. + */ + text: string + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the element has been clicked + */ + onClick(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * A mouse-sensitive pushbutton that displays an image instead of text. + * Calls the onClick() callback if the control is clicked or if its notify() method is called. + */ +declare class IconButton extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The image object that defines the image to be drawn. + */ + image: ScriptUIImage + + /** + * The image object that defines the image to be drawn. + * Same as IconButton.image. + */ + icon: ScriptUIImage + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + title: string + titleLayout: _TitleLayout + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the element has been clicked. + */ + onClick(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * Displays an icon or image. + */ +declare class Image extends _Control { + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The image object that defines the image to be drawn. + */ + image: ScriptUIImage + + /** + * The image object that defines the image to be drawn. + * Same as Image.image. + */ + icon: ScriptUIImage + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + title: string + titleLayout: _TitleLayout + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * An editable text field that the user can select and change. + * Calls the onChange() callback if the text is changed and the user types Enter or the control loses focus, or if its notify() method is called. Calls the onChanging() callback when any change is made to the text. The textselection property contains currently selected text. + */ +declare class EditText extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * A number of characters for which to reserve space when calculating the preferred size of the element. + */ + characters: number + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The text justification style. + * One of left, center, or right. Justification only works if this value is set on creation of the element. + */ + justify: _Justify + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * The current text displayed in the field, a localizable string. + */ + text: string + + /** + * The currently selected text, or the empty string if there is no text selected. + * Setting the value replaces the current text selection and modifies the value of the text property. If there is no current selection, inserts the new value into the text string at the current insertion point. The textselection value is reset to an empty string after it modifies the text value. Note that setting the textselection property before the element’s parent Window exists is an undefined operation. + */ + textselection: string + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the content of the element has been changed + * The handler is called only when the change is complete—that is, when focus moves to another control, or the user types Enter. The exact behavior depends on the creation parameter enterKeySignalsOnChange;see the properties property. + */ + onChange(): void + + /** + * An event-handler callback function, called when the content of the element is in the process of changing + * The handler is called for each keypress while this control has the input focus. + */ + onChanging(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * Displays a list of choices, represented by ListItem objects. + * When you create the object, you specify whether it allows the user to select only one or multiple items. If a list contains more items than can be displayed in the available area, a scrollbar may appear that allows the user to scroll through all the list items.You can specify the items on creation of the list object, or afterward using the list object’s add() method. You can remove items programmatically with the list object’s remove() and removeAll() methods. You can create a list box with multiple columns; in this case, each row is a selectable choice, and each ListItem represents one row. + */ +declare class ListBox extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * An array of child ListItem elements. + */ + readonly children: object[] + + /** + * For a multi-column list box, the column properties. + * A JavaScript object with two read-only properties whose values are set by the creation parameters: + * titles: An array of column title strings, whose length matches the number of columns specified at creation. + * preferredWidths: An array of column widths, whose length matches the number of columns specified at creation. + * visible: An array of boolean visible attributes, whose length matches the number of columns specified at creation.This property can be used to show/hide a column. Available in ScriptUI Version 6.0 or later provided ScriptUI.frameworkName == 'Flex'. + */ + readonly columns: object + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The width and height in pixels of each item in the list. + * Used by auto-layout to determine the preferredSize of the list, if not otherwise specified. If not set explicitly, the size of each item is set to match the largest height and width among all items in the list + */ + itemSize: _Dimension + + /** + * The array of choice items displayed in the list. + * Access this array with a 0-based index. To obtain the number of items in the list, use items.length.The objects are created when items are specified on creation of the parent list object, or afterward using the list control’s add() method. Each item has a selected property that is true when it is in the selected state. + */ + readonly items: ListItem[] + + /** + * The currently selected item for a single-selection list, or an array of items for current selection in a multi-selection list. + * Setting this value causes the selected item to be highlighted and to be scrolled into view if necessary. If no items are selected, the value is null. Set to null to deselect all items. You can set the value using the index of an item or an array of indices, rather than object references. If set to an index value that is out of range, the operation is ignored. When set with index values, the property still returns object references. + * If you set the value to an array for a single-selection list, only the first item in the array is selected. + * If you set the value to a single item for a multi-selection list, that item is added to the current selection. + */ + selection: ListItem | number + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * Adds an item to the choices in this list. + * Returns the item control object. If this is a multi-column list box, each added ListItem represents one selectable row.Its text and image values specify the label in the first column, and the subitems property specifies the labels in the additional columns. + * @param type The type of the child element, the string "item". + * @param text The localizable text label for the item. + * @param index The index into the current item list after which this item is inserted. If not supplied, or greater than the current list length, the new item is added at the end. + */ + add(type: "item", text?: string, index?: number): ListItem + + /** + * Retrieves an item object from the list that has a given text label. + * @param text The text string to match. + */ + find(text: string): ListItem + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the content of the element has been changed + */ + onChange(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when an item in the listbox is double-clicked + * Check the selection property to identify the item that was double-clicked. + */ + onDoubleClick(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void + + /** + * Removes a child item from the list. + * @param what The item or child to remove, specified by 0-based index, text value, or as a ListItem object. + */ + remove(what: any): void + + /** + * Removes all child items from the list. + */ + removeAll(): void +} + +/** + * Displays a single visible item. When you click the control, a list drops down or pops up, and allows you to select one of the other items in the list. + * Drop-down lists can have nonselectable separator items for visually separating groups of related items, as in a menu. You can specify the items on creation of the list object, or afterward using the list object’s add() method. You can remove items programmatically with the list object’s remove() and removeAll() methods. Calls the onChange() callback if the item selection is changed or if its notify() method is called. + */ +declare class DropDownList extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The width and height in pixels of each item in the list. + * Used by auto-layout to determine the preferredSize of the list, if not otherwise specified. If not set explicitly, the size of each item is set to match the largest height and width among all items in the list + */ + itemSize: _Dimension + + /** + * The array of choice items displayed in the drop-down or pop-up list. + * Access this array with a 0-based index. To obtain the number of items in the list, use items.length.The objects are created when items are specified on creation of the parent list object, or afterward using the list control’s add() method. Items in a drop-down list can be of type separator, in which case they cannot be selected, and are shown as a horizontal line. Each item has a selected property that is true when it is in the selected state. + */ + readonly items: ListItem[] + + /** + * The currently selectedlist item. + * Setting this value causes the selected item to be highlighted and to be scrolled into view if necessary. If no items are selected, the value is null. Set to null to deselect all items.You can set the value using the index of an item, rather than an object reference. If set to an index value that is out of range, the operation is ignored. When set with an index value, the property still returns an object reference. + */ + selection: ListItem | number + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + title: string + titleLayout: _TitleLayout + + /** + * Adds an item or separator to the choices in this list. + * Returns the item control object for type="item", or null for type="separator". + * @param type The type of the child element. Either item (a basic, selectable item with a text label) or separator + * @param text The localizable text label for the item. + * @param index The index into the current item list after which this item is inserted. If not supplied, or greater than the current list length, the new item is added at the end. + */ + add(type: "item", text?: string, index?: number): ListItem + add(type: "separator", text?: string, index?: number): null + + /** + * Retrieves an item object from the list that has a given text label. + * @param text The text string to match. + */ + find(text: string): ListItem + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the content of the element has been changed + */ + onChange(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void + + /** + * Removes a child item from the list. + * @param what The item or child to remove, specified by 0-based index, text value, or as a ListItem object. + */ + remove(what: any): void + + /** + * Removes all child items from the list. + */ + removeAll(): void +} + +/** + * An item in a list box, drop-down list, or tree view. + * You can specify initial items in the creation parameters when creating the parent list. Create new items using the add() method (ListBox.add(), DropDownList.add(), TreeView.add()) in the parent list with control type="item", or, for DropDownList controls, type="separator".For a multi-column list box, the object represents one selectable row. Its text and image values specify the label in the first column, and the subitems property specifies the labels in the additional columns. + */ +declare class ListItem { + /** + * The checked state of an item in a list. + * When true, the item is marked with the platform-appropriate checkmark. When false, no checkmark is drawn, but space is reserved for it in the left margin, so that the item lines up with other checkable items. When undefined, no space is reserved for a checkmark. + */ + checked: boolean + + /** + * The expansion state of an item of type node that is a child of a TreeView list control. + * When true, the item is in the expanded state and its children are shown, when false, it is collapsed and children are hidden. + */ + expanded: boolean + + /** + * An image object for an icon to display in the item. + * When specified, the image appropriate to the selections state is drawn to the left of the text label. If the parent is a multi-column list box, this describes the label in the first column. Labels in additional columns are described by the subitems property. + */ + image: ScriptUIImage + + /** + * The 0-based index of this item in the items collection of its parent list control. + */ + readonly index: number + + /** + * The parent element, a list control. + */ + readonly parent: _Control + + /** + * The selection state of this item. + * When true, the item is part of the selection for its parent list. When false, the item is not selected. Set to true to select this item in a single-selection list, or to add it to the selection array for a multi-selection list. + */ + selected: boolean + + /** + * When the parent is a multi-column ListBox, this describes the labels for this selectable row in additional columns. + * A array of JavaScript objects whose length is one less than the number of columns. The first member describes the label in the second column. Each member object has two properties, of which you can specify one or both: + * text: A display string for the corresponding label. + * image: An ScriptUIImage object for the corresponding label. + */ + readonly subItems: any[] + + /** + * The label text to display for the item, a localizable string. + * If the parent is a multi-column list box, this describes the label in the first column. Labels in additional columns are described by the subitems property. + */ + text: string + + /** + * The element type. + * Normally "item", but an item whose parent is a DropDownList control can have type "separator". A separator item is not mouse-sensitive and is drawn as a horizontal line across the drop-down or pop-up menu. + */ + readonly type: string + + /** + * Adds an item to the choices in this list. + * Returns the item control object. + * @param type The type of the child element, the string "item" or "node". + * @param text The localizable text label for the item. + * @param index The index into the current item list after which this item is inserted. If not supplied, or greater than the current list length, the new item is added at the end. + */ + add(type: "item" | "node", text?: string, index?: number): ListItem +} + +/** + * A dual-state control showing a box that has a checkmark when the value is true, and is empty when the value is false. + * Calls the onClick() callback if the control is clicked or if its notify() method is called. + */ +declare class Checkbox extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * A number of characters for which to reserve space when calculating the preferred size of the element. + */ + characters: number + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The default text justification style for child text elements. + * One of left, center, or right. Justification only works if this value is set on creation of the element. + */ + justify: _Justify + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * The text to display, a localizable string. + */ + text: string + + /** + * The selection state of the control. + * When true, the control is in the selected or set state and displays the check mark. When false, shows an empty box. + */ + value: boolean + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the element has been clicked. + */ + onClick(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * A scrollbar with a draggable scroll indicator and stepper buttons to move the indicator. + * The scrollbar control has a horizontal orientation if the width is greater than the height at creation time, or vertical if its height is greater than its width. + * Calls the onChange() callback after the position of the indicator is changed or if its notify() method is called. Calls the onChanging() callback repeatedly while the user is moving the indicator. Scrollbars are often created with an associated EditText field to display the current value of the scrollbar, and to allow setting the scrollbar's position to a specific value. + */ +declare class Scrollbar extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The amount to increment or decrement a scrollbar indicator's position when the user clicks ahead or behind the moveable element. + * Default is 20% of the range between the maxvalue and minvalue property values. + */ + jumpdelta: number + + /** + * The maximum value allowed in the value property. + * Together with minvalue, sets the scrolling range. Default is 100. + */ + maxvalue: number + + /** + * The minimum value allowed in the value property. + * Together with  maxvalue, sets the scrolling range.Default is 0. + */ + minvalue: number + + /** + * The key sequence that invokes the  onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * The amount by which to increment or decrement a scrollbar element's position when the user clicks a stepper button. + */ + stepdelta: number + + /** + * The current position of the indicator. + * If set to a value outside the range specified by minvalue and maxvalue, it is automatically reset to the closest boundary. + */ + value: number + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the user has finished dragging the position indicator, or has clicked the control. + */ + onChange(): void + + /** + * An event-handler callback function, called when the content of the element is in the process of changing + * The handler is called for any motion of the position indicator while this control has the input focus. + */ + onChanging(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * A dual-state control, grouped with other radiobuttons, of which only one can be in the selected state. + * Shows the selected state when value=true, empty when value=false. Calls the onClick() callback if the control is clicked or if its notify() method is called. + */ +declare class RadioButton extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * A number of characters for which to reserve space when calculating the preferred size of the element. + */ + characters: number + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The default text justification style for child text elements. + * One of left, center, or right. Justification only works if this value is set on creation of the element. + */ + justify: _Justify + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * The label text for this button, a localizable string. + */ + text: string + + /** + * The selection state of this button, selected when true. + */ + value: boolean + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the element has been clicked. + */ + onClick(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * A slider bar that indicates a numeric value with a moveable position indicator. + * All slider controls have a horizontal orientation. Calls the onChange() callback after the position of the indicator is changed or if its notify() method is called. Calls the onChanging() callback repeatedly while the user is moving the indicator. The value property contains the current position of the indicator within the range of minvalue to maxvalue. + */ +declare class Slider extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The maximum value allowed in the value property. + * Together with minvalue, sets therange.Default is 100. + */ + maxvalue: number + + /** + * The minimum value allowed in the value property. + * Together with maxvalue, sets the range.Default is 0. + */ + minvalue: number + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * The current position of the indicator. + * If set to a value outside the range specified by minvalue and maxvalue, it is automatically reset to the closest boundary. + */ + value: number + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the user has finished dragging the position indicator, or has clicked the control. + */ + onChange(): void + + /** + * An event-handler callback function, called when the content of the element is in the process of changing + * The handler is called for any motion of the position indicator while this control has the input focus. + */ + onChanging(): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void +} + +/** + * A horizontal bar with an indicator that shows the progress of an operation. + * All progressbar controls have a horizontal orientation. The value property contains the current position of the progress indicator; the default is 0. There is a minvalue property, but it is always 0; attempts to set it to a different value are silently ignored. + */ +declare class Progressbar extends _Control { + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The maximum value in the range. Default is 100. + */ + maxvalue: number + + /** + * The minimum value in the range; always 0. If set to a different value, it is ignored. + */ + minvalue: number + + /** + * The current position of the indicator. + * If set to a value outside the range specified by 0 to maxvalue, it is automatically reset to the closest boundary. + */ + value: number + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void +} + +/** + * A hierarchical list whose items can contain child items. + * The ListItem children of this control (in the items array) can be of type node, which means that they can contain child items. An item with child items can expanded, so that the child items are displayed, or collapsed, so that the child items are hidden Individual items can be selected at any level of the tree. + */ +declare class TreeView extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + /** + * An array of child elements. + */ + readonly children: object[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The width and height in pixels of each item in the list. + * Used by auto-layout to determine the preferredSize of the list, if not otherwise specified. If not set explicitly, the size of each item is set to match the largest height and width among all items in the list + */ + itemSize: _Dimension + + /** + * The array of top-level items displayed in the list. + * Access this array with a 0-based index. To obtain the number of items in the list, use items.length.The objects are created when items are specified on creation of the parent list object, or afterward using the list control’s add() method. + */ + readonly items: ListItem[] + + /** + * The currently selectedlist item. + * Setting this value causes the selected item to be highlighted and to be scrolled into view if necessary. If no items are selected, the value is null. Set to null to deselect all items.You can set the value using the index of an item, rather than an object reference. If set to an index value that is out of range, the operation is ignored. When set with an index value, the property still returns an object reference. + */ + selection: ListItem + + /** + * The key sequence that invokes the onShortcutKey() callback for this element (in Windows only). + */ + shortcutKey: string + + /** + * Adds an item to the top-level choices in this list. + * Returns the item control object. + * @param type The type of the child element, the string "item" or "node". + * @param text The localizable text label for the item. + * @param index The index into the current item list after which this item is inserted. If not supplied, or greater than the current list length, the new item is added at the end. + */ + add(type: "item" | "node", text?: string, index?: number): ListItem + + /** + * Retrieves an item object from the list that has a given text label. + * @param text The text string to match. + */ + find(text: string): ListItem + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * An event-handler callback function, called when the element acquires the keyboard focus. + * Called when the user gives the control the keyboard focus by clicking it or tabbing into it. + */ + onActivate(): void + + /** + * An event-handler callback function, called when the content of the element has been changed + */ + onChange(): void + + /** + * An event-handler callback function, called when the user collapses (closes) an expanded node in the treeview. + * @param item The ListItem node that collapsed. + */ + onCollapse(item: ListItem): void + + /** + * An event-handler callback function, called when the element loses the keyboard focus. + * Called when the user moves the keyboard focus from the previously active control to another control. + */ + onDeactivate(): void + + /** + * An event-handler callback function, called when the window is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * An event-handler callback function, called when the user expands (opens) a collapsed node in the treeview. + * @param item The ListItem node that expanded. + */ + onExpand(item: ListItem): void + + /** + * An event-handler callback function, called when the element's shortcutKey sequence is typed in the active window. + * In Windows only. + */ + onShortcutKey(): void + + /** + * Removes a child item from the list. + * @param what The item or child to remove, specified by 0-based index in the top-level item list, text value, or as a ListItem object. + */ + remove(what: any): void + + /** + * Removes all child items from the list. + */ + removeAll(): void +} + +/** + * A control that contains a Flash Player, which can load and play Flash movies stored in SWF files. + * The ScriptUI FlashPlayer element runs the Flash application within an Adobe application. The Flash application runs ActionScript, a different implementation of JavaScript from the ExtendScript version of JavaScript that Adobe applications run. A control object of this type contains functions that allow your script to load SWF files, control movie playback, and communicate with the ActionScript environment. + */ +declare class FlashPlayer extends _Control { + /** + * True if this element is active. + * An active control is the one with keyboard focus—that is, the one that accepts keystrokes, or in the case of a Button, is selected when the user types Return or Enter in Windows, or the space bar in Mac OS. + */ + active: boolean + + title: string + titleLayout: _TitleLayout + + /** + * A function definition for a callback from the Flash ActionScript environment. + * The Flash ActionScript code can call any callback function defined on the ExtendScript side of the FlashPlayer object, invoking it by name as a property of the control object. The function can take any arguments of a supported data types, and can return any value of a supported data type. data types:Number, String, Boolean, null, undefined, Object, Array. + */ + callback(): void + + /** + * Invokes an ActionScript function defined in the Flash application. + * Returns the result of the invoked function, which must be one of the allowed types. The ActionScript class and date objects are not supported as return values. + * @param name The name of a Flash ActionScript function that has been registered with the ExternalInterface object by the currently loaded SWF file. + * @param argument An argument to pass through to the function. There can be any number of arguments. An argument must be one of these data types:Number, String, Boolean, null, undefined, Object, Array. No other data types are supported. + */ + invokePlayerFunction(name: string, argument?: any): any + + /** + * Loads a movie into the Flash Player, and begins playing it. + * @param file The File object for the SWF file to load. + */ + loadMovie(file: File): void + + /** + * Sends a notification message, simulating the specified user interaction event. + * @param eventName The name of the control event handler to call. One of: onClick, onChange, onChanging. By default, simulates the onChange event for an edittext control, an onClick event for controls that support that event. + */ + notify(eventName?: string): void + + /** + * Restarts a movie that has been stopped. + * Do not use on a movie that is currently playing.The stopMovie()-playMovie() sequence does not work for SWF files produced by Flex, or for some files produced by Flash Authoring (depending on how they were implemented). + * @param rewind When true, restarts the movie from the beginning; otherwise, starts playing from the point where it was stopped. + */ + playMovie(rewind: boolean): void + + /** + * Halts playback of the current movie. + * The stopMovie()-playMovie() sequence does not work for SWF files produced by Flex, or for some files produced by Flash Authoring (depending on how they were implemented).Using stopMovie() from the player's hosting environment has no effect on an SWF file playing in a ScriptUI Flash Player element. It is, however, possible to produce an SWF using Flash Authoring that can stop itself in response to user interaction. + */ + stopMovie(): void +} + +/** + * A container for other controls within a window. + * A group can specify layout options for its child elements. Hiding a group hides all its children. Making it visible makes visible those children that are not individually hidden. + */ +declare class Group extends _Control { + /** + * Tells the layout manager how unlike-sized children of this container should be aligned within a column or row. + * Order of creation determines which children are at the top of a column or the left of a row; the earlier a child is created, the closer it is to the top or left of its column or row. If defined, alignment for a child element overrides the alignChildren setting for the parent container. See alignment property for values. + */ + alignChildren: _AlignmentProperty + + /** + * An array of child elements. + */ + readonly children: _Control[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The layout manager for this container. + * The first time a container object is made visible, ScriptUI invokes this layout manager by calling its layout() function. Default is an instance of the LayoutManager class that is automatically created when the container element is created. + */ + layout: AutoLayoutManager + + /** + * The number of pixels between the edges of a container and the outermost child elements. + * You can specify different margins for each edge of the container. The default value is based on the type of container, and is chosen to match the standard Adobe UI guidelines. + */ + margins: _Margins + + /** + * The layout orientation of children in a container. + * Interpreted by the layout manager for the container. The default LayoutManager  Object accepts the (case-insensitive) values row, column, or stack.For window and panel, the default is column, and for group the default is row. The allowed values for the container’s alignChildren and its children’s alignment properties depend on the orientation. + */ + orientation: _Orientation + + /** + * The number of pixels separating one child element from its adjacent sibling element. + * Because each container holds only a single row or column of children, only a single spacing value is needed for a container. The default value is based on the type of container, and is chosen to match standard Adobe UI guidelines. + */ + spacing: number + + /** + * Adds a child element to this container. + * Creates and returns a new control or container object and adds it to the children of this group. + * @param type The type of the child element, as specified for the type property. Control types are listed in the JavaScript Tools Guide. + * @param bounds A bounds specification that describes the size and position of the new control or container, relative to its parent. If supplied, this value creates a new Bounds object which is assigned to the new object’s bounds property. + * @param text The text or label, a localizable string. Initial text to be displayed in the control as the title, label, or contents, depending on the control type. If supplied, this value is assigned to the new object’s text property. + * @param properties An object that contains one or more creation properties of the new child (properties used only when the element is created). The creation properties depend on the element type. See properties property of each control type. + */ + add: _AddControl + + /** + * An event-handler callback function, called when the group is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * Removes the specified child control from this group's children array. + * No error results if the child does not exist. + * @param what The child control to remove, specified by 0-based index, text property value, or as a control object. + */ + remove(what: any): void +} + +/** + * A container for other types of controls, with an optional frame. + * A panel can specify layout options for its child elements. Hiding a panel hides all its children. Making it visible makes visible those children that are not individually hidden. + */ +declare class Panel extends _Control { + /** + * Specifies how to align the child elements. + */ + alignChildren: _AlignmentProperty + + /** + * Reserve space for the specified number of characters; affects calculation of preferredSize . + */ + characters: number + + /** + * An array of child elements. + */ + readonly children: _Control[] + + /** + * The graphics object that can be used to customize the element's appearance, in response to the onDraw() event. + */ + readonly graphics: ScriptUIGraphics + + /** + * The default text justification style for child text elements. + * One of left, center, or right. Justification only works if this value is set on creation of the element. + */ + justify: _Justify + + /** + * The layout manager for this container. + * The first time a container object is made visible, ScriptUI invokes this layout manager by calling its layout() function. Default is an instance of the LayoutManager class that is automatically created when the container element is created. + */ + layout: AutoLayoutManager + + /** + * The number of pixels between the edges of a container and the outermost child elements. + * You can specify different margins for each edge of the container. The default value is based on the type of container, and is chosen to match the standard Adobe UI guidelines. + */ + margins: _Margins + + /** + * The layout orientation of children in a container. + * Interpreted by the layout manager for the container. The default LayoutManager  Object accepts the (case-insensitive) values row, column, or stack.For window and panel, the default is column, and for group the default is row. The allowed values for the container’s alignChildren and its children’s alignment properties depend on the orientation. + */ + orientation: _Orientation + + /** + * The number of pixels separating one child element from its adjacent sibling element. + * Because each container holds only a single row or column of children, only a single spacing value is needed for a container. The default value is based on the type of container, and is chosen to match standard Adobe UI guidelines. + */ + spacing: number + + /** + * The title or label text, a localizable string. + */ + text: string + + /** + * Adds a child element to this container. + * Creates and returns a new control or container object and adds it to the children of this group. + * @param type The type of the child element, as specified for the type property. Control types are listed in the JavaScript Tools Guide. + * @param bounds A bounds specification that describes the size and position of the new control or container, relative to its parent. If supplied, this value creates a new Bounds object which is assigned to the new object’s bounds property. + * @param text The text or label, a localizable string. Initial text to be displayed in the control as the title, label, or contents, depending on the control type. If supplied, this value is assigned to the new object’s text property. + * @param properties An object that contains one or more creation properties of the new child (properties used only when the element is created). The creation properties depend on the element type. See properties property of each control type. + */ + add: _AddControl + + /** + * An event-handler callback function, called when the panel is about to be drawn. + * Allows the script to modify or control the appearance, using the control’s associated ScriptUIGraphics object. Handler takes one argument, a DrawState object. + */ + onDraw(): void + + /** + * Removes the specified child control from this group's children array. + * No error results if the child does not exist. + * @param what The child control to remove, specified by 0-based index, text property value, or as a control object. + */ + remove(what: any): void +} + +/** + * A container for other types of controls. + * Differs from a panel element in that is must be a direct child of a tabbedpanel element, the title is shown in the selection tab, and it does not have a script-definable border. + */ +declare class Tab extends Panel { + /** + * The parent element. + */ + readonly parent: TabbedPanel +} + +/** + * A container for selectable tab containers. + * Differs from a panel element in that it can contain only tab elements as direct children. + */ +declare class TabbedPanel extends _Control { + /** + * An array of child elements. + */ + readonly children: Tab[] + + /** + * The currently selected tab. + * Setting this value causes the specified tab to be enabled in the panel. + * You can set the value using the index of an item, rather than an object reference. + * If set to an index value that is out of range, the operation is ignored. + * When set with an index value, the property still returns an object reference. + * When the value of the selection property changes, either by a user selecting a different tab, or by a script setting the property, the TabbedPanel receives an onChange notification. + */ + selection: Tab | number + + title: string + titleLayout: _TitleLayout + + /** + * Adds a tab to this tabbed panel. + * Returns the created tab control object. + * + * Note: `bounds` is not used; pass `undefined` + */ + add(type: "tab", bounds?: undefined, text?: string, properties?: _AddControlProperties): Tab + + /** + * An event-handler callback function, called when the selected tab has changed. + */ + onChange(): void +} + +/** + * Defines the location of a window or UI element. Contains a 2-element array. + * Specifies the origin point of an element as horizontal and vertical pixel offsets from the origin of the element's coordinate space. + * A Point object is created when you set an element’s location property. You can set the property using a JavaScript object with properties named x and y, or an array with 2 values in the order [x, y]. + */ +declare class Point extends Array { + /** + * The left coordinate. + */ + left: number + + /** + * The top coordinate. + */ + top: number + + /** + * The horizontal coordinate, a pixel offset from the origin of the element's coordinate space. + */ + x: number + + /** + * The vertical coordinate, a pixel offset from the origin of the element's coordinate space. + */ + y: number +} + +/** + * Defines the size of a window or UI element. Contains a 2-element array. + * Specifies the height and width of an element in pixels. A Dimension object is created when you set an element’s size property. You can set the property using a JavaScript object with named properties {width: wd, height: ht}, or an array with 2 values in the order [wd, ht]. + */ +declare class Dimension extends Array { + /** + * The height in pixels. + */ + height?: number + + /** + * The width in pixels. + */ + width?: number +} + +/** + * Defines the boundaries of a window within the screen’s coordinate space, or of a UI element within the container’s coordinate space. + * A Bounds object is created when you set an element’s bounds property. You can set the property using a JavaScript object with properties named left, top, right, bottom or x, y, width, height, or an array with 4 values in the order [x, y, wd, ht]. + */ +declare class Bounds extends Array { + /** + * The vertical coordinate, a pixel offset from the origin of the element's coordinate space. + */ + bottom?: number + + /** + * The height in pixels. + */ + height?: number + + /** + * The horizontal coordinate, a pixel offset from the origin of the element's coordinate space. + */ + left?: number + + /** + * The width in pixels. + */ + right?: number + + /** + * The height in pixels. + */ + top?: number + + /** + * The width in pixels. + */ + width?: number + + /** + * The horizontal coordinate, a pixel offset from the origin of the element's coordinate space. + */ + x?: number + + /** + * The vertical coordinate, a pixel offset from the origin of the element's coordinate space. + */ + y?: number +} + +/** + * Defines the number of pixels between the edges of a container and its outermost child elements. + * Contains an array [ left, top, right, bottom ] whose elements define the margins between the left edge of a container and its leftmost child element, and so on. + * + * A Margins object is created when you set an element’s margins property. + * An object must contain properties named left, top, right, and bottom. + * An array must have values in the order [ left, top, right, bottom ]. + * You can also set the margins property to a number; all of the array values are then set to this number. + */ +declare class Margins extends Array { + /** + * Defines the number of pixels between the left edge of a container and its leftmost child element. + */ + left: number + /** + * Defines the number of pixels between the right edge of a container and its rightmost child element. + */ + right: number + /** + * Defines the number of pixels between the top edge of a container and its top child element. + */ + top: number + /** + * Defines the number of pixels between the bottom edge of a container and its bottom child element. + */ + bottom: number +} + +/** + * Encapsulates input event information for an event that propagates through a container and control hierarchy. + * Implements W3C standard event handling. This object is passed to a function that you register to respond to events of a certain type that occur in a window or control. Use windowObj.addEventListener() or controlObj.addEventListener() to register a handler function. + */ +declare class UIEvent { + /** + * True if the event is of a type that bubbles. + */ + readonly bubbles: boolean + + /** + * True if the default action associated with the event can be canceled with preventDefault(). + */ + readonly cancelable: boolean + + /** + * True if this event can be captured. + */ + readonly captures: boolean + + /** + * The event target object which is currently handling the event. During capturing and bubbling, this is different from the property target. + */ + readonly currentTarget: boolean + + /** + * The click count for a mouse-click event. + */ + readonly detail: any + + /** + * The current phase of event propagation; one of none, target, capture, bubble. + */ + readonly eventPhase: number + + /** + * The event target object for this event. + */ + readonly target: object + + /** + * The date and time at which the event occurred. + */ + readonly timeStamp: Date + + /** + * The name of the event that thisobject represents. + * Event types are listed in the JavaScript Tools Guide. + */ + readonly type: string + + /** + * The ScriptUI element that this event relates to. + */ + readonly view: any + + /** + * Creates an event. + * The UIEvent object is normally created by ScriptUI and passed to your event handler. However, you can simulate a user action by constructing an event object and sending it to a target object’s dispatchEvent() function. + * @param type The event type. See UIEvent.type property. + * @param captures Set to true if this event can be captured. + * @param bubbles Set to true if the event bubbles. + * @param view The ScriptUI element that this event relates to. + * @param detail The click count for a mouse-click event. + */ + constructor(type: string, captures: boolean, bubbles: boolean, view?: object, detail?: number) + + /** + * Initializes a UI event as a core W3C event. + * @param type The event type. + * @param captures Set to true if this event can be captured. + * @param bubbles Set to true if the event bubbles. + * @param cancelable Set to true if the default action is cancelable. + */ + initEvent(type: string, captures: boolean, bubbles: boolean, cancelable: boolean): void + + /** + * Initializes an event. + * @param type The event type. + * @param captures Set to true if this event can be captured. + * @param bubbles Set to true if the event bubbles. + * @param view The ScriptUI element that this event relates to. + * @param detail The click count for a mouse-click event. + */ + initUIEvent( + type: string, + captures: boolean, + bubbles: boolean, + view?: object, + detail?: number, + ): void + + /** + * Prevents the default action associated with this event from being called. + */ + preventDefault(): void + + /** + * Stops the propagation of this event. + */ + stopPropagation(): void +} + +/** + * Base class for UIEvent. + * Encapsulates input event information for an event that propagates through a container and control hierarchy.Implements W3C standard event handling. + */ +declare class Event { + /** + * + */ + static readonly AT_TARGET: any + + /** + * + */ + static readonly BUBBLING_PHASE: any + + /** + * + */ + static readonly CAPTURING_PHASE: any + + /** + * + */ + static readonly NOT_DISPATCHING: any + + /** + * True if the event is of a type that bubbles. + */ + readonly bubbles: boolean + + /** + * True if the default action associated with the event can be canceled with preventDefault(). + */ + readonly cancelable: boolean + + /** + * True if this event can be captured. + */ + readonly captures: boolean + + /** + * The event target object which is currently handling the event. During capturing and bubbling, this is different from the property target. + */ + readonly currentTarget: boolean + + /** + * The current phase of event propagation; one of none, target, capture, bubble. + */ + readonly eventPhase: number + + /** + * The event target object for this event. + */ + readonly target: object + + /** + * The date and time at which the event occurred. + */ + readonly timeStamp: Date + + /** + * The name of the event that this object represents. + * Event types are listed in the JavaScript Tools Guide. + */ + readonly type: string + + /** + * Prevents the default action associated with this event from being called. + */ + preventDefault(): void + + /** + * Stops the propagation of this event. + */ + stopPropagation(): void +} + +/** + * Defines attributes of the ScriptUI environment. + * Access through the ScriptUI.environment property. + */ +declare class Environment { + /** + * An object that reports the active state of the keyboard at any time. + * Provides access to the key state independent of the event-handling framework. + */ + readonly keyboardState: KeyboardState +} + +/** + * Provides access to objects used in the ScriptUI event system. + * Access through the ScriptUI.events property. + */ +declare class Events { + /** + * Creates an instance of the specified Event subclass. + * The Event returned is a UIEvent, + * KeyboardEvent or MouseEvent object, + * depending on the requested type. This object can be passed as a parameter to an element's dispatchEvent + * function in order to simulate a user-interaction event. + * @param eventType The name of an event type: one of "UIEvent", "KeyboardEvent", or "MouseEvent". + */ + createEvent(eventType: string): Event +} + +/** + * Reports the active state of the keyboard. + * Access through the ScriptUI.environment.keyboardState property. + * Query the properties of this object at any time to determine the current key that is down and any modifiers that are pressed. + */ +declare class KeyboardState { + /** + * True if the Alt or Option key is pressed. + */ + readonly altKey: boolean + + /** + * True if the Ctrl key is pressed. + */ + readonly ctrlKey: boolean + + /** + * A string containing the name of the currently pressed key, such as "a", or an empty string. + */ + readonly keyName: string + + /** + * True if the Cmd key (in Mac OS) or Windows key (in Windows) is pressed. + */ + readonly metaKey: boolean + + /** + * True if the Shift key is pressed. + */ + readonly shiftKey: boolean +} + +declare class KeyboardEvent extends UIEvent implements KeyboardState { + altKey: boolean + ctrlKey: boolean + metaKey: boolean + shiftKey: boolean + keyIdentifier: string + keyLocation: number + keyName: string + type: string + getModifierState( + keyIdentifier: "Alt" | "CapsLock" | "Control" | "Meta" | "NumLock" | "Scroll" | "Shift", + ): boolean + initKeyboardEvent( + eventName: string, + bubble: boolean, + isCancelable: boolean, + view: _Control, + keyID: string, + keyLocation: number, + modifiersList: string, + ): void +} + +/** + * A Control class. + */ +declare class _Control { + /** + * The alignment style for child elements of a container. If defined, this value overrides the alignChildren setting for the parent container. + * This can be a single string, which indicates the alignment for the orientation specified in the parent container, or an array of two strings, indicating both the horizontal and vertical alignment (in that order). Allowed values depend on the orientation value of the parent container. They are not case sensitive. + * For orientation = row: top, bottom, fill + * For orientation = column: left, right, fill + * For orientation = stack: top, bottom, left, right, fill + */ + alignment: _AlignmentProperty + + /** + * The boundaries of the element, in parent-relative coordinates. + * Setting an element's size or location changes its bounds property, and vice-versa. + */ + bounds: _Bounds + + /** + * True if this element is enabled. + * An enabled element can accept input, according to its type. When false, control elements do not accept input, and all types of elements have a dimmed appearance. + */ + enabled: boolean + + /** + * The help text that is displayed when the mouse hovers over the element. + */ + helpTip: string + + /** + * The number of pixels to indent the element during automatic layout. + * Applies for column orientation and left alignment, or row orientation and top alignment. + */ + indent: number + + /** + * The upper left corner of this element relative to its parent. + * The location is defined as [bounds.x, bounds.y]. Setting an element's location changes its bounds property, and vice-versa. + */ + location: Point + + /** + * The maximum height and width to which the element can be resized. + */ + maximumSize: _Dimension + + /** + * The minimum height and width to which the element can be resized. + */ + minimumSize: _Dimension + + /** + * The parent element. + */ + readonly parent: _Control + + /** + * The preferred size, used by layout managers to determine the best size for each element. + * If not explicitly set by a script, value is established by the UI framework in which ScriptUI is employed, and is based on such attributes of the element as its text, font, font size, icon size, and other UI framework-specific attributes. A script can explicitly set this value before the layout manager is invoked in order to establish an element size other than the default. + * To set a specific value for only one dimension, specify the other dimension as -1. + */ + preferredSize: _Dimension + + /** + * The current dimensions of this element. + * Initially undefined, and unless explicitly set by a script, it is defined by a LayoutManager . A script can explicitly set size before the layout manager is invoked to establish an element size other than the preferredSize or the default size, but this is not recommended. Defined as [bounds.width, bounds.height]. Setting an element's size changes its bounds property, and vice-versa. + */ + size: _Dimension + + /** + * The element type. + */ + readonly type: string + + /** + * True if this element is shown, false if it is hidden. + * When a container is hidden, its children are also hidden, but they retain their own visibility values, and are shown or hidden accordingly when the parent is next shown. + */ + visible: boolean + + /** + * The window that this element belongs to. + */ + readonly window: Window + + /** + * The bounds of this element relative to the top-level parent window. + */ + readonly windowBounds: _Bounds + + /** + * Registers an event handler for a particular type of event occurring in this element. + * @param eventName The name of the event. Event names are listed in the JavaScript Tools Guide. + * @param handler The function that handles the event. This can be the name of a function defined in the extension, or a locally defined handler function to be executed when the event occurs. A handler function takes one argument, the UIEvent object. + * @param capturePhase When true, the handler is called only in the capturing phase of the event propagation. Default is false, meaning that the handler is called in the bubbling phase if this object is an ancestor of the target, or in the at-target phase if this object is itself the target. + */ + addEventListener(eventName: string, handler: Function, capturePhase?: boolean): boolean + + /** + * Simulates the occurrence of an event in this target. + * A script can create a UIEvent object for a specific event and pass it to this method to start the event propagation for the event. + */ + dispatchEvent(): Event + + /** + * Hides this element. + */ + hide(): void + + /** + * Unregisters an event handler for a particular type of event occurring in this element. + * All arguments must be identical to those that were used to register the event handler. + * @param eventName The name of the event. + * @param handler The function that handles the event. + * @param capturePhase Whether to call the handler only in the capturing phase of the event propagation. + */ + removeEventListener(eventName: string, handler: Function, capturePhase?: boolean): boolean + + /** + * Shows this element. + * When a window or container is hidden, its children are also hidden, but when it is shown again, the children retain their own visibility states. + * If an onShow() callback is defined for a window, calls that function before showing the window.When a window or container is hidden, its children are also hidden, but when it is shown again, the children retain their own visibility states. For a modal dialog, opens the dialog and does not return until the dialog is dismissed. If it is dismissed via the close() method, this method returns any result value passed to that method. Otherwise, returns 0. + */ + show(): number | undefined +} + +/** + * Creation properties. + * @param name A unique name for the control. + */ +interface _AddControlProperties { + name?: string +} + +/** + * Creation properties of a DropDownList. + * @param name A unique name for the control. + * @param items An array of strings for the text of each list item. An item object is created for each item. An item with the text string "-" creates a separator item. Supply this property, or the items argument to the add() method, not both. This form is most useful for elements defined using Resource Specifications. + */ +interface _AddControlPropertiesDropDownList { + name?: string + items?: string[] +} + +/** + * Creation properties of an EditText. + * @param name A unique name for the control. + * @param multiline When false (the default), the control displays a single line of text. When true, the control displays multiple lines, in which case the text wraps within the width of the control. + * @param borderless When true, the control is drawn with no border. Default is false. + * @param scrollable For multiline elements only. When true (the default), the text field has a vertical scrollbar that is enabled when the element contains more text than fits in the visible area. When false, no vertical scrollbar appears; if the element contains more text than fits in the visible area, the arrow keys can be used to scroll the text up and down. + * @param readonly When false (the default), the control accepts text input. When true, the control does not accept input but only displays the contents of the text property. + * @param noecho When false (the default), the control displays input text. When true, the control does not display input text (used for password input fields). + * @param enterKeySignalsOnChange When false (the default), the control signals an onChange event when the editable text is changed and the control loses the keyboard focus (that is, the user tabs to another control, clicks outside the control, or types Enter). When true, the control only signals an onChange() event when the editable text is changed and the user types Enter; other changes to the keyboard focus do not signal the event. + * @param wantReturn Only applies to multiple line edit controls in ScriptUI Version 6.0 or later. When true the RETURN/ENTER keystroke is considered as text-input advancing the cursor to the next line. The default value is false. + */ +interface _AddControlPropertiesEditText { + name?: string + multiline?: boolean + borderless?: boolean + scrollable?: boolean + readonly?: boolean + noecho?: boolean + enterKeySignalsOnChange?: boolean + wantReturn?: boolean +} + +/** + * Creation properties of an IconButton. + * @param name A unique name for the control. + * @param style A string for the visual style, either "button", which has a visible border with a raised or 3D appearance, or "toolbutton", which has a flat appearance, appropriate for inclusion in a toolbar. + * @param toggle For a button-style control, a value of true causes it to get a button-pressed appearance the first time it is clicked, and alternate with the unpressed appearance each time it is clicked. The toggle state is reflected in the control’s value property. + */ +interface _AddControlPropertiesIconButton { + name?: string + style?: "button" | "toolbutton" + toggle?: boolean +} + +/** + * Creation properties of a ListBox. + * @param name A unique name for the control. + * @param multiselect When false (the default), only one item can be selected. When true, multiple items can be selected. + * @param selected When true, multiple items can be selected. + * @param items An array of strings for the text of each list item. An item object is created for each item. An item with the text string "-" creates a separator item. Supply this property, or the items argument to the add() method, not both. This form is most useful for elements defined using Resource Specifications. + * @param numberOfColumns A number of columns in which to display the items; default is 1. When there are multiple columns, each ListItem object represents a selectable row. Its text and image values specify the label in the first column, and the subitems property specifies the labels in the additional columns. + * @param showHeaders True to display column titles. + * @param columnWidths An array of numbers for the preferred width in pixels of each column. + * @param columnTitles A corresponding array of strings for the title of each column, to be shown if showHeaders is true. + */ +interface _AddControlPropertiesListBox { + name?: string + multiselect?: boolean + selected?: boolean + items?: string[] + numberOfColumns?: number + showHeaders?: boolean + columnWidths?: number[] + columnTitles?: string[] +} + +/** + * Creation properties of a Panel. + * @param name A unique name for the control. + * @param borderStyle A string that specifies the appearance of the border drawn around the panel. One of black, etched, gray, raised, sunken. Default is etched. + * @param su1PanelCoordinates Photoshop only. When true, this panel automatically adjusts the positions of its children for compatibility with Photoshop CS. Default is false, meaning that the panel does not adjust the positions of its children, even if the parent window has automatic adjustment enabled. + */ +interface _AddControlPropertiesPanel { + name?: string + borderStyle?: string + su1PanelCoordinates?: boolean +} + +/** + * Creation properties of a StaticText. + * @param name A unique name for the control. + * @param multiline When false (the default), the control displays a single line of text. When true, the control displays multiple lines, in which case the text wraps within the width of the control. + * @param scrolling When false (the default), the displayed text cannot be scrolled. When true, the displayed text can be vertically scrolled using the Up Arrow and Down Arrow; this case implies multiline=true. + * @param truncate If middle or end, defines where to remove characters from the text and replace them with an ellipsis if the specified title does not fit within the space reserved for it. If none, and the text does not fit, characters are removed from the end, without any replacement ellipsis character. + */ +interface _AddControlPropertiesStaticText { + name?: string + multiline?: boolean + scrolling?: boolean + truncate?: _Truncate +} + +/** + * Creation properties of a TreeView. + * @param name A unique name for the control. + * @param items An array of strings for the text of each top-level list item. An item object is created for each item. An item with the text string "-" creates a separator item. Supply this property, or the items argument to the add() method, not both. This form is most useful for elements defined using Resource Specifications. + */ +interface _AddControlPropertiesTreeView { + name?: string + items?: string[] +} + +/** + * Creation properties of a Window. + * @param resizeable When true, the window can be resized by the user. Default is false. + * @param su1PanelCoordinates Photoshop only. When true, the child panels of this window automatically adjust the positions of their children for compatibility with Photoshop CS (in which the vertical coordinate was measured from outside the frame). Default is false. Individual panels can override the parent window’s setting. + * @param closeButton Bridge only. When true, the title bar includes a button to close the window, if the platform and window type allow it. When false, it does not. Default is true. Not used for dialogs. + * @param maximizeButton Bridge only. When true, the title bar includes a button to expand the window to its maximum size (typically, the entire screen), if the platform and window type allow it. When false, it does not. Default is false for type palette, true for type window. Not used for dialogs. + * @param minimizeButton Bridge only. When true, the title bar includes a button to minimize or iconify the window, if the platform and window type allow it. When false, it does not. Default is false for type palette, true for type window. Main windows cannot have a minimize button in Mac OS. Not used for dialogs. + * @param independent When true, a window of type window is independent of other application windows, and can be hidden behind them in Windows. In Mac OS, has no effect. Default is false. + * @param borderless When true, the window has no title bar or borders. Properties that control those features are ignored. + */ +interface _AddControlPropertiesWindow { + resizeable?: boolean + su1PanelCoordinates?: boolean + closeButton?: boolean + maximizeButton?: boolean + minimizeButton?: boolean + independent?: boolean + borderless?: boolean +} + +interface _AddControl { + /** + * Creation of a Button. + * The third argument can be the initial text value. + * Special name "ok" makes the button primary for parent dialog, and the special name "cancel" makes the button default cancel button for parent dialog. + */ + (type: "button", bounds?: _Bounds, text?: string, properties?: _AddControlProperties): Button + + /** + * Creation of a CheckBox. + * The third argument is the text to be displayed. + */ + (type: "checkbox", bounds?: _Bounds, text?: string, properties?: _AddControlProperties): Checkbox + + /** + */ + ( + type: "dropdownlist", + bounds?: _Bounds, + items?: string[], + properties?: _AddControlPropertiesDropDownList, + ): DropDownList + + /** + */ + ( + type: "edittext", + bounds?: _Bounds, + text?: string, + properties?: _AddControlPropertiesEditText, + ): EditText + + /** + */ + ( + type: "flashplayer", + bounds?: _Bounds, + movieToLoad?: string | File, + properties?: _AddControlProperties, + ): FlashPlayer + + /** + */ + (type: "group", bounds?: _Bounds, properties?: _AddControlProperties): Group + + /** + */ + ( + type: "iconbutton", + bounds?: _Bounds, + icon?: string | File, + properties?: _AddControlPropertiesIconButton, + ): IconButton + + /** + */ + (type: "image", bounds?: _Bounds, icon?: string | File, properties?: _AddControlProperties): Image + + /** + */ + ( + type: "listbox", + bounds?: _Bounds, + items?: string[], + properties?: _AddControlPropertiesListBox, + ): ListBox + + /** + */ + (type: "panel", bounds?: _Bounds, text?: string, properties?: _AddControlPropertiesPanel): Panel + + /** + * Creation of a ProgressBar. + * The third argument is the initial value (default 0), and the fourth argument is the maximum value of the range (default 100). + */ + ( + type: "progressbar", + bounds?: _Bounds, + value?: number, + max?: number, + properties?: _AddControlProperties, + ): Progressbar + + /** + * Creation of a RadioButton. + * The third argument can be the label text. + */ + ( + type: "radiobutton", + bounds?: _Bounds, + text?: string, + properties?: _AddControlProperties, + ): RadioButton + + /** + * Creation of a Scrollbar. + * The third argument is the initial value, and the fourth and fifth arguments are the minimum and maximum values of the range. + */ + ( + type: "scrollbar", + bounds?: _Bounds, + value?: number, + min?: number, + max?: number, + properties?: _AddControlProperties, + ): Scrollbar + + /** + * Creation of a Slider. + * The third argument is the initial value, and the fourth and fifth arguments are the minimum and maximum values of the range. + */ + ( + type: "slider", + bounds?: _Bounds, + value?: number, + min?: number, + max?: number, + properties?: _AddControlProperties, + ): Slider + + /** + */ + ( + type: "statictext", + bounds?: _Bounds, + text?: string, + properties?: _AddControlPropertiesStaticText, + ): StaticText + + /** + */ + ( + type: "tabbedpanel", + bounds?: _Bounds, + text?: string, + properties?: _AddControlProperties, + ): TabbedPanel + + /** + */ + ( + type: "treeview", + bounds?: _Bounds, + items?: string[], + properties?: _AddControlPropertiesTreeView, + ): TreeView +} + +interface _TitleLayout { + alignment?: _AlignmentPropertyTitleLayout + characters?: number + spacing?: number + margins?: [number, number, number, number] + justify?: _Justify + truncate?: _Truncate +} diff --git a/src/types/XMPScript.d.ts b/src/types/XMPScript.d.ts new file mode 100644 index 0000000..8900c24 --- /dev/null +++ b/src/types/XMPScript.d.ts @@ -0,0 +1,72 @@ +/// + +// A commonly used construct for loading XMPScript into +// ExtendScript contexts. +interface ExternalObjectConstructor { + AdobeXMPScript: ExternalObject | undefined +} + +interface XMPMetaConstructor { + /** Creates an empty object. */ + new (): XMPMetaInstance + /** + * @param packet A String containing an XML file or an XMP packet. + */ + new (packet: string): XMPMetaInstance + /** + * @param buffer The UTF-8 or UTF-16 encoded bytes of an XML file + * or an XMP packet. This array is the result of a call to `serializeToArray` + * on an `XMPMeta` instance. + */ + new (buffer: number[]): XMPMetaInstance + /** + * @param prefix The prefix of the namespace. + * @example XMPMeta.getNamespacePrefix('xmp'); // 'http://ns.adobe.com/xap/1.0/' + */ + getNamespaceURI(prefix: string): string + /** + * @param uri The URI of the namespace. + * @example XMPMeta.getNamespacePrefix('http://ns.adobe.com/xap/1.0/'); // 'xmp:' + */ + getNamespacePrefix(uri: string): string +} +type XMPProperty = { + locale: string + namespace: string + options: string + path: string + value: string +} +interface XMPMetaInstance { + doesPropertyExist(namespace: string, value: string): boolean + getProperty(namespace: string, property: string): XMPProperty + setProperty(namespace: string, property: string, value: string): boolean + countArrayItems(namespace: string, property: string): number + getArrayItem(namespace: string, property: string, itemIndex: number): XMPProperty + deleteProperty(namespace: string, property: string): boolean + appendArrayItem( + namespace: string, + property: string, + arrayOptions: string, + valueToAppend: string, + valueOptions: string, + ): boolean + dumpObject(): string + serialize(): string + getNamespaceURI(ns: string): string +} + +declare const XMPMeta: XMPMetaConstructor | undefined + +interface XMPConstConstructor { + new (): XMPConstInstance + NS_DM: string + NS_DC: string + ARRAY_IS_ORDERED: string +} + +interface XMPConstInstance { + // Instance stuff. +} + +declare const XMPConst: XMPConstConstructor | undefined diff --git a/src/types/global.d.ts b/src/types/global.d.ts new file mode 100644 index 0000000..acbaa3e --- /dev/null +++ b/src/types/global.d.ts @@ -0,0 +1,152 @@ +/// +/// + +/** + * The global BridgeTalk object. + */ +declare var BridgeTalk: any + +/** + * The Infinity global property is a predefined variable with the value for infinity. + */ +declare var Infinity: number + +/** + * The NaN global property is a predefined variable with the value NaN (Not-a-Number), as specified by the IEEE-754 standard. + */ +declare var NaN: number + +/** + * The application object + */ +declare var app: Application +declare interface Application {} + +/** + * Displays an alert box + * @param message The text to display + * @param title The title of the alert; ignored on the Macintosh + * @param errorIcon Display an Error icon; ignored on the Macintosh + */ +declare function alert(message: string, title?: string, errorIcon?: boolean): void + +/** + * Displays an alert box with Yes and No buttons; returns true for Yes + * @param message The text to display + * @param noAsDefault Set to true to set the No button as the default button + * @param title The title of the alert; ignored on the Macintosh + */ +declare function confirm(message: string, noAsDefault?: boolean, title?: string): boolean + +/** + * Decodes a string created with encodeURI(). + * @param uri The text to decode. + */ +declare function decodeURI(uri: string): string + +/** + * Decodes a string created with encodeURIComponent(). + * @param uri The text to decode. + */ +declare function decodeURIComponent(uri: string): string + +/** + * Encodes a string after RFC2396. + * Create an UTF-8 ASCII encoded version of this string. The string is converted into UTF-8. Every non-alphanumeric character is encoded as a percent escape + * character of the form %xx, where xx is the hex value of the character. After the conversion to UTF-8 encoding and escaping, it is guaranteed that the string does not contain characters codes greater than 127. The list of characters not to be encoded is -_.!~*'();/?:@&=+$,#. The method returns false on errors. + * @param text The text to encode. + */ +declare function encodeURI(text: string): string + +/** + * Encodes a string after RFC2396. + * Create an UTF-8 ASCII encoded version of this string. The string is converted into UTF-8. Every non-alphanumeric character is encoded as a percent escape + * character of the form %xx, where xx is the hex value of the character. After the conversion to UTF-8 encoding and escaping, it is guaranteed that the string does not contain characters codes greater than 127. The list of characters not to be encoded is -_.!~*'(). The method returns false on errors. + * @param text The text to encode. + */ +declare function encodeURIComponent(text: string): string + +/** + * Creates a URL-encoded string from aString. + * In the new string, characters of aString that require URL encoding are replaced with the format %xx, where xx is the hexadecimal value of the character code in the Unicode character set.This format is used to transmit information appended to a URL during, for example, execution of the GET method.Use the unescape() global function to translate the string back into its original format. Returns a string which is aString URL-encoded. + * @param aString The string to be encoded. + */ +declare function escape(aString: string): string + +/** + * Evaluates its argument as a JavaScript script, and returns the result of evaluation. + * You can pass the result of an object's toSource() method to reconstruct that object. + * @param stringExpression The string to evaluate. + */ +declare function eval(stringExpression: string): any + +/** + * Evaluates an expression and reports whether the result is a finite number. + * Returns true if the expression is a finite number, false otherwise. False if the value is infinity or negative infinity. + * @param expression Any valid JavaScript expression. + */ +declare function isFinite(expression: number): boolean + +/** + * Evaluates an expression and reports whether the result is "Not-a-Number" (NaN). + * Returns true if the result of evaluation is not a number (NaN), false if the value is a number. + * @param expression Any valid JavaScript expression. + */ +declare function isNaN(expression: number): boolean + +/** + * Returns true if the supplied string is a valid XML name. + * @param name The XML name to test. + */ +declare function isXMLName(name: string): boolean + +/** + * Localizes a ZString-encoded string and merges additional arguments into the string. + * @param what The string to localize. A ZString-encoded string that can contain placeholder for additional arguments in the form %1 to %n. + * @param arguments Optional argument(s) to be merged into the string. There may be more than one argument. + */ +declare function localize(what: string, ...arguments: any[]): string + +/** + * Extracts a floating-point number from a string. + * Parses a string to find the first set of characters that can be converted to a floating point number, and returns that number, or NaN if it does not encounter characters that it can converted to a number.The function supports exponential notation. + * @param text The string from which to extract a floating point number. + */ +declare function parseFloat(text: string): number + +/** + * Extracts an integer from a string. + * Parses a string to find the first set of characters, in a specified base, that can be converted to an integer, and returns that integer, or NaN if it does not encounter characters that it can convert to a number. + * @param text The string from which to extract an integer. + * @param base The base of the string to parse (from base 2 to base 36). If not supplied, base is determined by the format of string. + */ +declare function parseInt(text: string, base?: number): number + +/** + * Displays a dialog allowing the user to enter text + * Returns null if the user cancelled the dialog, the text otherwise + * @param prompt The text to display + * @param default_ The default text to preset the edit field with + * @param title The title of the dialog; + */ +declare function prompt(prompt: string, default_?: string, title?: string): string | null + +/** + * Defines the default XML namespace. + * This is a replacement function for the standard JavaScript statement set default xml namespace. + * @param namespace The namespace to use. Omit this parameter to return to the empty namespace. This is either a Namespace object or a string. + */ +declare function setDefaultXMLNamespace(namespace: Namespace): void + +/** + * Translates URL-encoded string into a regular string, and returns that string. + * Use the escape() global function to URL-encode strings. + * @param stringExpression The URL-encoded string to convert. + */ +declare function unescape(stringExpression: string): string + +/** + * Creates a source code representation of the supplied argument, and returns it as a string. + * @param what The object to uneval. + */ +declare function uneval(what: any): string diff --git a/src/types/index.d.ts b/src/types/index.d.ts new file mode 100644 index 0000000..be91ab5 --- /dev/null +++ b/src/types/index.d.ts @@ -0,0 +1,2933 @@ +/// +/// + +/** + * The global System object. + */ +declare var system: System + +declare interface _AppVersion { + CS3: 8.0 + CS4: 9.0 + CS5: 10.0 + CS5_5: 10.5 + CS6: 11.0 + CC: 12.0 + CC2014: 13.0 + CC2015: 13.5 + CC2015_1: 13.6 + CC2015_2: 13.7 + CC2015_3: 13.8 + CC2017: 14.0 + CC2018: 15.0 + CC2019: 16.0 + CC2020: 17.0 +} + +declare const enum _CommandID { + /** + * File + */ + NewProject = 2, + NewFolder = 2139, + NewAdobePhotoshopFile = 3147, + NewMAXONCINEMA4DFile = 4007, + OpenProject = 3, + OpenRecentProject1 = 2330, + OpenRecentProject2 = 2331, + OpenRecentProject3 = 2332, + OpenRecentProject4 = 2333, + OpenRecentProject5 = 2334, + BrowseInBridge = 3689, + + Close = 4, + CloseProject = 3154, + Save = 5, + SaveAs = 6, + SaveACopy = 2166, + SaveACopyAsXML = 3785, + IncrementAndSave = 3088, + Revert = 7, + + ImportFile = 2003, + ImportMultipleFiles = 2236, + ImportPlaceholder = 2126, + ImportSolid = 3000, + ImportRecentFootage1 = 2310, + ImportRecentFootage2 = 2311, + ImportRecentFootage3 = 2312, + ImportRecentFootage4 = 2313, + ImportRecentFootage5 = 2314, + ImportRecentFootage6 = 2315, + ImportRecentFootage7 = 2316, + ImportRecentFootage8 = 2317, + ImportRecentFootage9 = 2318, + ImportRecentFootage10 = 2319, + ExportAddToAdobeMediaEncoderQueue = 3800, + ExportAddToRenderQueue = 2161, + + AddFootageToComp = 2005, + NewCompFromSelection = 2796, + + CollectFiles = 2482, + ConsolidateAllFootage = 2107, + RemoveUnusedFootage = 2109, + ReduceProject = 2735, + FindMissingEffects = 4002, + FindMissingFonts = 4003, + FindMissingFootage = 4004, + WatchFolder = 2457, + + RunScriptFile = 8000, + OpenScriptEditor = 8001, + + CreateProxyStill = 2778, + CreateProxyMovie = 2779, + SetProxyFile = 2003, + SetProxyNone = 2119, + InterpretFootageMain = 2077, + InterpretFootageProxy = 2103, + InterpretFootageRememberInterpretation = 2254, + InterpretFootageApplyInterpretation = 2255, + ReplaceFootageFile = 2003, + ReplaceFootageWithLayeredComp = 3070, + ReplaceFootagePlaceholder = 2126, + ReplaceFootageSolid = 3000, + ReloadFootage = 2257, + RevealInExplorer = 2562, + RevealInFinder = 2562, + RevealInBridge = 3690, + + ProjectSettings = 2611, + + /** + * Edit + */ + Undo = 16, + Redo = 2035, + Redo2 = 17, + + Cut = 18, + Copy = 19, + CopyWithPropertyLinks = 10310, + CopyExpressionOnly = 53, + Paste = 20, + Clear = 21, + + Duplicate = 2080, + SplitLayer = 2158, + LiftWorkArea = 2613, + ExtractWorkArea = 2614, + SelectAll = 23, + DeselectAll = 2004, + + PurgeAllMemoryAndDiskCache = 10200, + PurgeAllMemory = 2373, + PurgeUndo = 2371, + PurgeImageCacheMemory = 2372, + PurgeSnapshot = 2481, + + EditOriginal = 2142, + EditInAdobeAudition = 3697, + + TemplatesRenderSettings = 2149, + TemplatesOutputModule = 2150, + PasteMochaMask = 5006, + + /** + * Composition + */ + NewComposition = 2000, + + CompositionSettings = 2007, + SetPosterTime = 2012, + TrimCompToWorkArea = 2360, + CropCompToRegionOfInterest = 2997, + AddToAdobeMediaEncoderQueue = 3800, + AddToRenderQueue = 2161, + AddOutputModule = 2154, + + SaveFrameAs = 2233, + SaveFrameAsPhotoshopLayers = 5001, + PreRender = 2780, + + CompositionFlowchart = 2258, + CompositionMiniFlowchart = 3792, + + /** + * Layer + */ + NewText = 2836, + NewSolid = 2038, + NewLight = 2563, + NewCamera = 2564, + NewNullObject = 2767, + NewShapeLayer = 3736, + NewAdjustmentLayer = 2279, + // NewAdobePhotoshopFile = 3147, + // NewMAXONCINEMA4DFile = 4007, + LayerSettings = 2021, + + OpenLayer = 3784, + OpenLayerSource = 2523, + // RevealInExplorer = 2562, + // RevealInFinder = 2562, + + NewMask = 2367, + ResetMask = 2448, + RemoveMask = 2368, + RemoveAllMasks = 2369, + UnlockAllMasks = 2456, + LockOtherMasks = 2455, + HideLockedMasks = 2524, + + QualityBest = 2045, + QualityDraft = 2044, + QualityWireframe = 2042, + QualityBilinear = 10207, + QualityBicubic = 10208, + + HideOtherVideo = 2054, + ShowAllVideo = 2055, + UnlockAllLayers = 2244, + + FlipHorizontal = 3766, + FlipVertical = 3767, + CenterInView = 3819, + CenterAnchorPointInLayerContent = 10312, + FitToComp = 2156, + FitToCompWidth = 2732, + FitToCompHeight = 2733, + EnableTimeRemapping = 2153, + TimeReverseLayer = 2135, + TimeStretch = 2024, + FreezeFrame = 3695, + AddMarker = 2157, + + LayerStylesConvertToEditableStyles = 3740, + LayerStylesShowAll = 3743, + LayerStylesRemoveAll = 2072, + LayerStylesDropShadow = 9000, + LayerStylesInnerShadow = 9001, + LayerStylesOuterGlow = 9002, + LayerStylesInnerGlow = 9003, + LayerStylesBevelAndEmboss = 9004, + LayerStylesSatin = 9005, + LayerStylesColorOverlay = 9006, + LayerStylesGradientOverlay = 9007, + LayerStylesStroke = 9008, + + GroupShapes = 3741, + UngroupShapes = 3742, + + ConvertToEditableText = 3799, + CreateShapesFromText = 3781, + CreateMasksFromText = 2933, + CreateShapesFromVectorLayer = 3973, + CreateStereo3DRig = 3843, + CreateOrbitNull = 3844, + LinkFocusDistanceToPointOfInterest = 3845, + LinkFocusDistanceToLayer = 3847, + SetFocusDistanceToLayer = 3846, + AutoTrace = 3044, + PreCompose = 2071, + + /** + * Animation + */ + SaveAnimationPreset = 3075, + ApplyAnimationPreset = 2450, + RecentAnimationPreset1 = 2460, + RecentAnimationPreset2 = 2461, + RecentAnimationPreset3 = 2462, + RecentAnimationPreset4 = 2463, + RecentAnimationPreset5 = 2464, + BrowsePresets = 3691, + + ConvertAudioToKeyframes = 5015, + ConvertExpressionToKeyframes = 2639, + RPFCameraImport = 5018, + SequenceLayers = 5003, + TimeReverseKeyframes = 3693, + + RemoveAllTextAnimators = 3058, + + AddExpression = 2702, + SeparateDimensions = 3764, + TrackCamera = 3983, + TrackInMochaAE = 5007, + WarpStabilizerVFX = 3986, + TrackMotion = 2568, + TrackMask = 10311, + TrackThisProperty = 2643, + + RevealPropertiesWithKeyframes = 2387, + RevealPropertiesWithAnimation = 4011, + RevealAllModifiedProperties = 2771, + + /** + * View + */ + ZoomIn = 2092, + ZoomOut = 2093, + + ResolutionFull = 2048, + ResolutionHalf = 2047, + ResolutionThird = 2081, + ResolutionQuarter = 2046, + ResolutionCustom = 2049, + + UseDisplayColorManagement = 3704, + + ShowRulers = 2280, + + ShowGuides = 2274, + SnapToGuides = 2286, + LockGuides = 2275, + ClearGuides = 2276, + + ShowGrid = 2277, + SnapToGrid = 2278, + + ShowLayerControls = 2435, + + /** + * Window + */ + Align = 5022, + Audio = 2029, + Brushed = 3014, + Character = 3011, + EffectsAndPresets = 3718, + Info = 2028, + MaskInterpolation = 5027, + MediaBrowser = 4013, + Metadata = 3788, + MotionSketch = 5024, + Paint = 3045, + Paragraph = 3012, + Preview = 2031, + Progress = 4005, + Smoother = 5028, + Tools = 2010, + Tracker = 5005, + Wiggler = 5030, +} + +declare enum AlphaMode { + IGNORE = 5413, + PREMULTIPLIED = 5414, + STRAIGHT = 5412, +} + +declare enum AutoOrientType { + /** Layer faces in the direction of the motion path. */ + ALONG_PATH = 4213, + + /** Layer always faces the active camera or points at its point of interest. */ + CAMERA_OR_POINT_OF_INTEREST = 4214, + + /** Each character in a per-character 3D text layer automatically faces the active camera. */ + CHARACTERS_TOWARD_CAMERA = 4215, + + /** Layer rotates freely, independent of any motion path, point of interest, or other layers. */ + NO_AUTO_ORIENT = 4212, +} + +declare enum BlendingMode { + ADD = 5220, + ALPHA_ADD = 5244, + CLASSIC_COLOR_BURN = 5219, + CLASSIC_COLOR_DODGE = 5225, + CLASSIC_DIFFERENCE = 5234, + COLOR = 5238, + COLOR_BURN = 5218, + COLOR_DODGE = 5224, + DANCING_DISSOLVE = 5214, + DARKEN = 5215, + DARKER_COLOR = 5247, + DIFFERENCE = 5233, + DISSOLVE = 5213, + DIVIDE = 5249, + EXCLUSION = 5235, + HARD_LIGHT = 5228, + HARD_MIX = 5232, + HUE = 5236, + LIGHTEN = 5221, + LIGHTER_COLOR = 5246, + LINEAR_BURN = 5217, + LINEAR_DODGE = 5223, + LINEAR_LIGHT = 5229, + LUMINESCENT_PREMUL = 5245, + LUMINOSITY = 5239, + MULTIPLY = 5216, + NORMAL = 5212, + OVERLAY = 5226, + PIN_LIGHT = 5231, + SATURATION = 5237, + SCREEN = 5222, + SILHOUETE_ALPHA = 5242, + SILHOUETTE_LUMA = 5243, + SOFT_LIGHT = 5227, + STENCIL_ALPHA = 5240, + STENCIL_LUMA = 5241, + SUBTRACT = 5248, + VIVID_LIGHT = 5230, +} + +declare enum ChannelType { + CHANNEL_ALPHA = 7816, + CHANNEL_ALPHA_BOUNDARY = 7822, + CHANNEL_ALPHA_OVERLAY = 7821, + CHANNEL_BLUE = 7815, + CHANNEL_BLUE_COLORIZE = 7819, + CHANNEL_GREEN = 7814, + CHANNEL_GREEN_COLORIZE = 7818, + CHANNEL_RED = 7813, + CHANNEL_RED_COLORIZE = 7817, + CHANNEL_RGB = 7812, + CHANNEL_RGB_STRAIGHT = 7820, +} + +declare enum CloseOptions { + /** Close without saving. */ + DO_NOT_SAVE_CHANGES = 1212, + + /** Prompt for whether to save changes before close. */ + PROMPT_TO_SAVE_CHANGES = 1213, + + /** Save automatically on close. */ + SAVE_CHANGES = 1214, +} + +declare enum FastPreviewType { + FP_ADAPTIVE_RESOLUTION = 8013, + FP_DRAFT = 8014, + FP_FAST_DRAFT = 8015, + FP_OFF = 8012, + FP_WIREFRAME = 8016, +} + +declare enum FeetFramesFilmType { + MM16 = 2412, + MM35 = 2413, +} + +declare enum FieldSeparationType { + LOWER_FIELD_FIRST = 5614, + OFF = 5613, + UPPER_FIELD_FIRST = 5612, +} + +declare enum FootageTimecodeDisplayStartType { + FTCS_START_0 = 2213, + FTCS_USE_SOURCE_MEDIA = 2212, +} + +declare enum FrameBlendingType { + FRAME_MIX = 4013, + NO_FRAME_BLEND = 4012, + PIXEL_MOTION = 4014, +} + +declare enum FramesCountType { + FC_START_0 = 2612, + FC_START_1 = 2613, + FC_TIMECODE_CONVERSION = 2614, +} + +declare enum GetSettingsFormat { + NUMBER = 3413, + NUMBER_SETTABLE = 3414, + SPEC = 3412, + STRING = 3415, + STRING_SETTABLE = 3416, +} + +declare enum GpuAccelType { + CUDA = 1813, + METAL = 1814, + OPENCL = 1812, + SOFTWARE = 1816, + VULKAN = 1815, +} + +declare enum ImportAsType { + COMP = 3814, + COMP_CROPPED_LAYERS = 3812, + FOOTAGE = 3813, + PROJECT = 3815, +} + +declare enum KeyframeInterpolationType { + BEZIER = 6613, + HOLD = 6614, + LINEAR = 6612, +} + +declare enum Language { + CHINESE = 1619, + ENGLISH = 1612, + FRENCH = 1615, + GERMAN = 1614, + ITALIAN = 1616, + JAPANESE = 1613, + KOREAN = 1618, + PORTUGUESE = 1621, + RUSSIAN = 1620, + SPANISH = 1617, +} + +declare enum LayerQuality { + BEST = 4614, + DRAFT = 4613, + WIREFRAME = 4612, +} + +declare enum LayerSamplingQuality { + BICUBIC = 4813, + BILINEAR = 4812, +} + +declare enum LightType { + AMBIENT = 4415, + PARALLEL = 4412, + POINT = 4414, + SPOT = 4413, +} + +declare enum LogType { + ERRORS_AND_PER_FRAME_INFO = 3214, + ERRORS_AND_SETTINGS = 3213, + ERRORS_ONLY = 3212, +} + +declare enum MaskFeatherFalloff { + FFO_LINEAR = 7213, + FFO_SMOOTH = 7212, +} + +declare enum MaskMode { + ADD = 6813, + DARKEN = 6817, + DIFFERENCE = 6818, + INTERSECT = 6815, + LIGHTEN = 6816, + NONE = 6812, + SUBTRACT = 6814, +} + +declare enum MaskMotionBlur { + OFF = 7014, + ON = 7013, + SAME_AS_LAYER = 7012, +} + +declare enum ParagraphJustification { + CENTER_JUSTIFY = 7415, + FULL_JUSTIFY_LASTLINE_CENTER = 7418, + FULL_JUSTIFY_LASTLINE_FULL = 7419, + FULL_JUSTIFY_LASTLINE_LEFT = 7416, + FULL_JUSTIFY_LASTLINE_RIGHT = 7417, + LEFT_JUSTIFY = 7413, + MULTIPLE_JUSTIFICATIONS = 7412, + RIGHT_JUSTIFY = 7414, +} + +declare enum PostRenderAction { + IMPORT = 3613, + IMPORT_AND_REPLACE_USAGE = 3614, + NONE = 3612, + SET_PROXY = 3615, +} + +declare enum PREFType { + PREF_Type_MACHINE_INDEPENDENT = 8813, + PREF_Type_MACHINE_INDEPENDENT_COMPOSITION = 8816, + PREF_Type_MACHINE_INDEPENDENT_OUTPUT = 8815, + PREF_Type_MACHINE_INDEPENDENT_RENDER = 8814, + PREF_Type_MACHINE_SPECIFIC = 8812, + PREF_Type_MACHINE_SPECIFIC_PAINT = 8818, + PREF_Type_MACHINE_SPECIFIC_TEXT = 8817, +} + +declare enum PropertyType { + INDEXED_GROUP = 6214, + NAMED_GROUP = 6213, + PROPERTY = 6212, +} + +declare enum PropertyValueType { + COLOR = 6418, + CUSTOM_VALUE = 6419, + LAYER_INDEX = 6421, + MARKER = 6420, + MASK_INDEX = 6422, + NO_VALUE = 6412, + OneD = 6417, + SHAPE = 6423, + TEXT_DOCUMENT = 6424, + ThreeD = 6414, + ThreeD_SPATIAL = 6413, + TwoD = 6416, + TwoD_SPATIAL = 6415, +} + +declare enum PulldownMethod { + ADVANCE_24P = 6013, + PULLDOWN_3_2 = 6012, +} + +declare enum PulldownPhase { + OFF = 5813, + SSWWW = 5814, + SWWWS = 5815, + SWWWW_24P_ADVANCE = 5821, + WSSWW = 5812, + WSWWW_24P_ADVANCE = 5820, + WWSSW = 5817, + WWSWW_24P_ADVANCE = 5819, + WWWSS = 5816, + WWWSW_24P_ADVANCE = 5818, + WWWWS_24P_ADVANCE = 5822, +} + +declare enum PurgeTarget { + /** Purges all data that After Effects has cached to physical memory. */ + ALL_CACHES = 1412, + + /** Purges all saved image data. */ + IMAGE_CACHES = 1415, + + /** Purges all data cached as composition/layer snapshots. */ + SNAPSHOT_CACHES = 1414, + + /** Purges all data saved in the undo cache. */ + UNDO_CACHES = 1413, +} + +declare enum ResolveType { + ACCEPT_THEIRS = 8612, + ACCEPT_THEIRS_AND_COPY = 8613, + ACCEPT_YOURS = 8614, +} + +declare enum RQItemStatus { + DONE = 3019, + ERR_STOPPED = 3018, + NEEDS_OUTPUT = 3013, + QUEUED = 3015, + RENDERING = 3016, + UNQUEUED = 3014, + USER_STOPPED = 3017, + WILL_CONTINUE = 3012, +} + +declare enum SceneEditDetectionMode { + MARKERS = 10012, + SPLIT = 10013, + SPLIT_PRECOMP = 10014, + NONE = 10015, +} + +declare enum TimeDisplayType { + FRAMES = 2013, + TIMECODE = 2012, +} + +declare enum ToolType { + Tool_Arrow = 9012, + Tool_CameraDollyCamera = 9017, + Tool_CameraDollyToCursor = 9048, + Tool_CameraDollyTowardsCursor = 9047, + Tool_CameraMaya = 9014, + Tool_CameraOrbit = 9015, + Tool_CameraOrbitCamera = 9015, + Tool_CameraOrbitCursor = 9044, + Tool_CameraOrbitScene = 9045, + Tool_CameraPanCamera = 9016, + Tool_CameraPanCursor = 9046, + Tool_CameraTrackXY = 9016, + Tool_CameraTrackZ = 9017, + Tool_CloneStamp = 9019, + Tool_Eraser = 9020, + Tool_Feather = 9032, + Tool_Hairbrush = 9042, + Tool_Hand = 9021, + Tool_Magnify = 9022, + Tool_Oval = 9026, + Tool_Paintbrush = 9018, + Tool_PanBehind = 9023, + Tool_Pen = 9031, + Tool_PenConvert = 9035, + Tool_PenMinus = 9034, + Tool_PenPlus = 9033, + Tool_Pin = 9036, + Tool_PinAdvanced = 9043, + Tool_PinBend = 9038, + Tool_PinDepth = 9040, + Tool_PinStarch = 9037, + Tool_Polygon = 9027, + Tool_Quickselect = 9041, + Tool_Rect = 9024, + Tool_Rotate = 9013, + Tool_RoundedRect = 9025, + Tool_Star = 9028, + Tool_TextH = 9029, + Tool_TextV = 9030, +} + +declare enum TrackMatteType { + ALPHA = 5013, + ALPHA_INVERTED = 5014, + LUMA = 5015, + LUMA_INVERTED = 5016, + NO_TRACK_MATTE = 5012, +} + +declare enum ViewerType { + VIEWER_COMPOSITION = 7612, + VIEWER_FOOTAGE = 7614, + VIEWER_LAYER = 7613, +} + +/** + * TYPES + */ +type _PropertyClasses = Property | PropertyGroup | MaskPropertyGroup +type _ItemClasses = CompItem | FootageItem | FolderItem + +/** Clears text from the Info panel. */ +declare var clearOutput: () => void + +/** Generates random numbers. */ +declare var generateRandomNumber: () => number + +/** Converts string time value to a numeric time value. */ +declare var currentFormatToTime: ( + formattedTime: string, + fps: number, + isDuration?: boolean, +) => number + +/** Converts a numeric time value to a string time value. */ +declare var timeToCurrentFormat: (time: number, fps: number, isDuration?: boolean) => string + +/** Writes text to the Info panel, with no line break added. */ +declare var write: (text: string) => void + +/** Writes text to the Info panel, adding a line break at the end. */ +declare var writeLn: (text: string) => void + +/** When true, the specified object exists. */ +declare var isValid: (obj: object) => boolean + +/** Provides access to objects and application settings within the After Effects application. The single global object is always available by its name, app. */ +declare class Application { + /** The current After Effects project. */ + readonly project: Project + + /** The version number of the After Effects application. */ + readonly version: string + + /** The name of this build of the application. */ + readonly buildName: string + + /** The number of this build of the application. */ + readonly buildNumber: number + + /** When true, the local application is running in Watch Folder mode. */ + readonly isWatchFolder: boolean + + /** When true, the local After Effects application is running as a render engine. */ + readonly isRenderEngine: boolean + + /** The language After Effects is running. */ + readonly language: Language + + /** Application settings that can be set via scripting. */ + readonly settings: Settings + + /** The locale (language and region) in which the application is running. */ + readonly isoLanguage: string + + /** Memory in use by this application. */ + readonly memoryInUse: number + + /** Preferences */ + readonly preferences: Preferences + + /** The currently focused or last-focused viewer panel. */ + readonly activeViewer: Viewer | null + + /** The effects available in the application. */ + readonly effects: { displayName: string; matchName: string; version: string; category: string }[] + + /** The Viewer object for the currently focused or active-focused viewer panel. */ + availableGPUAccelTypes: GpuAccelType + + /** Set to true to disable rendering as if Caps Lock were turned on. */ + disableRendering: boolean + + /** A callback function that is called when an error occurs in the application. */ + onError: string | null + + /** A numeric status code used when executing a script + * externally (that is, from a command line or AppleScript). + * 0 if no error occurred. A positive number indicates an + * error that occurred while running the script. + */ + exitCode: number + + /** When true, the application remains open after running a script from the command line on Windows. */ + exitAfterLaunchAndEval: boolean + + /** When true, the project is saved if the application closes unexpectedly. */ + saveProjectOnCrash: boolean + + /** Creates a new project in After Effects. */ + newProject(): Project | null + + /** Opens a project or an Open Project dialog box. */ + open(file?: File): Project | null + + /** Quits the application. */ + quit(): void + + /** Starts Watch Folder mode; does not return until Watch Folder mode is turned off. */ + watchFolder(folder_object_to_watch: Folder): void + + /** Pauses a current watch-folder process. */ + pauseWatchFolder(pause: boolean): void + + /** Ends a current watch-folder process. */ + endWatchFolder(): void + + /** Purges a targeted type of cached information(replicates Purge options in the Edit menu). */ + purge(target: PurgeTarget): void + + /** Groups the actions that follow it into a single undoable step. */ + beginUndoGroup(undoString: string): void + + /** Ends an undo group; needed only when a script contains more than one undo group. */ + endUndoGroup(): void + + /** Begins suppression of dialogs in the user interface. */ + beginSuppressDialogs(): void + + /** Ends suppression of dialogs in the user interface. */ + endSuppressDialogs(alert: boolean): void + + /** Sets memory usage limits as in the Memory & Cache preferences area. */ + setMemoryUsageLimits(imageCachePercentage: number, maximumMemoryPercentage: number): void + + /** + * Set the Multi-Frame Rendering configuration for the next render + * + * @param use_mfr Set to `true` to enable Multi-Frame Rendering. + * @param max_cpu_perc Value from 1-100 representing the maximum CPU percentage Multi-Frame Rendering should utilize. If `mfr_on` is set to `false`, pass in 100. + */ + setMultiFrameRenderingConfig(use_mfr: boolean, max_cpu_percent: number): void; + + /** Sets whether preferences are saved when the application is quit. */ + setSavePreferencesOnQuit(doSave: boolean): void + + /** Brings the After Effects main window to the front of the screen. */ + activate(): void + + /** Schedules a JavaScript script for delayed execution. */ + scheduleTask(stringToExecute: string, delay: number, repeat: boolean): number + + /** Cancels a scheduled task. */ + cancelTask(taskID: number): void + + /** Loads a color swatch from an Adobe Swatch Exchange (ASE) file. */ + parseSwatchFile(file: File): _Swatch + + findMenuCommandId(str: string): number + + executeCommand(id: number): void + + /** CC2015- */ + getenv(name: string): string + setTimeout(func: () => void, delay?: number): number + cancelTimeout(id: number): void +} + +declare class Preferences { + deletePref(section: string, key: string, type?: PREFType): void + getPrefAsBool(section: string, key: string, type?: PREFType): boolean + getPrefAsFloat(section: string, key: string, type?: PREFType): number + getPrefAsLong(section: string, key: string, type?: PREFType): number + getPrefAsString(section: string, key: string, type?: PREFType): string + havePref(section: string, key: string, type?: PREFType): boolean + reload(): void + savePrefAsBool(section: string, key: string, value: boolean, type?: PREFType): void + savePrefAsFloat(section: string, key: string, value: number, type?: PREFType): void + savePrefAsLong(section: string, key: string, value: number, type?: PREFType): void + savePrefAsString(section: string, key: string, value: string, type?: PREFType): void + saveToDisk(): void +} + +/** The AVItem object provides access to attributes and methods of audio/visual files imported into After Effects. */ +declare class AVItem extends Item { + /** The FootageItem object used as proxy for the item. */ + readonly proxySource: FootageSource + + /** The CompItem objects that use this item. */ + readonly usedIn: CompItem[] + + /** When true, the item has a video component. */ + readonly hasVideo: boolean + + /** When true, the item has an audio component. */ + readonly hasAudio: boolean + + /** When true, the item cannot be found or is a placeholder. */ + readonly footageMissing: boolean + + /** True if the AVItem can be used as an alternate source when calling Property.setAlternateSource */ + readonly isMediaReplacementCompatible: boolean + + /** The width of the item. */ + width: number + + /** The height of the item. */ + height: number + + /** The pixel aspect ratio of the item. */ + pixelAspect: number + + /** The frame rate of the item. */ + frameRate: number + + /** The frame duration for the item. */ + frameDuration: number + + /** The total duration of the item. */ + duration: number + + /** When true, a proxy source is used for this item. */ + useProxy: boolean + + /** Current time of the item. */ + time: number + + /** Sets a proxy for the item. */ + setProxy(file: File): void + + /** Sets a sequence as a proxy for the item. */ + setProxyWithSequence(file: File, forceAlphabetical: boolean): void + + /** Sets a solid as a proxy for the item. */ + setProxyWithSolid( + color: ThreeDColorValue, + name: string, + width: number, + height: number, + pixelAspect: number, + ): void + + /** Sets a placeholder as a proxy for the item. */ + setProxyWithPlaceholder( + name: string, + width: number, + height: number, + frameRate: number, + duration: number, + ): void + + /** Removes the proxy for the item. */ + setProxyToNone(): void +} + +/** The AVLayer object provides an interface to those layers that contain AVItem objects (composition layers, footage layers, solid layers, text layers, and sound layers). */ +declare class AVLayer extends Layer { + /** The source item for this layer. */ + readonly source: any + + /** When true, the layer has no expressly set name, but contains a named source. */ + readonly isNameFromSource: boolean + + /** The height of the layer. */ + readonly height: number + + /** The width of the layer. */ + readonly width: number + + /** When true, it is legal to change the value of collapseTransformation. */ + readonly canSetCollapseTransformation: boolean + + /** When true, frame blending is enabled. */ + readonly frameBlending: boolean + + /** When true, it is legal to change the value of timeRemapEnabled. */ + readonly canSetTimeRemapEnabled: boolean + + /** When true, the layer contains an audio component. */ + readonly hasAudio: boolean + + /** When true, the layer's audio is active at the current time. */ + readonly audioActive: boolean + + /** When true, this layer is being used as a track matte for the layer below it. */ + readonly isTrackMatte: boolean + + /** When true, the layer above is being used as a track matte on this layer. */ + readonly hasTrackMatte: boolean + + /** Returns the track matte layer for this layer. Returns null if this layer has no track matte layer. */ + readonly trackMatteLayer: AVLayer | null + + /** When true, the layer's audio is enabled. */ + audioEnabled: boolean + + /** When true, the layer's motion blur is enabled. */ + motionBlur: boolean + + /** When true, the layer's effects are active. */ + effectsActive: boolean + + /** When true, this is an adjustment layer. */ + adjustmentLayer: boolean + + /** When true, this is an environment layer. */ + environmentLayer: boolean + + /** When true, this is a guide layer. */ + guideLayer: boolean + + /** When true, this is a 3D layer. */ + threeDLayer: boolean + + /** When true, 3D is set on a per-character basis in this text layer. */ + threeDPerChar: boolean + + /** When true, collapse transformation is on. */ + collapseTransformation: boolean + + /** The type of frame blending for the layer. */ + frameBlendingType: FrameBlendingType + + /** When true, time remapping is enabled on this layer. */ + timeRemapEnabled: boolean + + /** The blending mode of the layer. */ + blendingMode: BlendingMode + + /** When true, preserve transparency is enabled. */ + preserveTransparency: boolean + + /** The layer sampling quality setting. */ + samplingQuality: LayerSamplingQuality + + /** + * If this layer has a track matte, specifies the way the track matte is applied. + * + * Legacy API; use `AVLayer.setTrackMatte()` and `AVLayer.removeTrackMatte()` instead. + * + * @deprecated since version 23.0. + */ + trackMatteType: TrackMatteType + + /** The layer quality setting. */ + quality: LayerQuality + + /** Reports whether this layer's audio is active at a given time. */ + audioActiveAtTime(time: number): boolean + + /** Calculates a transformation from a set of points in this layer. */ + calculateTransformFromPoints( + pointTopLeft: [number, number, number], + pointTopRight: typeof pointTopLeft, + pointBottomRight: typeof pointTopLeft, + ): object + + /** Converts composition coordinates, such as sourcePointToComp, to layer coordinates. */ + sourcePointToComp(point: [number, number]): [number, number] + + /** Converts composition coordinates, such as sourcePointToComp, to layer coordinates. */ + compPointToSource(point: [number, number]): [number, number] + + /** Opens the layer in a Layer panel. */ + openInViewer(): Viewer | null + + /** Changes the source item for this layer. */ + replaceSource(newSource: AVItem, fixExpressions: boolean): void + + /** Retrieves the source rectangle of a layer. */ + sourceRectAtTime( + timeT: number, + extents: boolean, + ): { top: number; left: number; width: number; height: number } + + /** Adds the layer to the Essential Graphics Panel for the specified composition. */ + addToMotionGraphicsTemplate(comp: CompItem): boolean + + /** Adds the layer to the Essential Graphics Panel for the specified composition. */ + addToMotionGraphicsTemplateAs(comp: CompItem, name: string): boolean + + /** True if the layer can be added to the EGP for the specified composition */ + canAddToMotionGraphicsTemplate(comp: CompItem): boolean + + /** Removes the track matte for this layer while preserving the TrackMatteType. Use setTrackMatteType() for another way of removing track matte. */ + removeTrackMatte(): void + + /** Sets the track matte layer and type for this layer. Passing in null to trackMatteLayer parameter removes the track matte. Use removeTrackMatte() for another way of removing track matte. */ + setTrackMatte(trackMatteLayer: AVLayer | null, trackMatteType: TrackMatteType): void + + /** Shortcuts */ + readonly timeRemap: OneDProperty + readonly mask: MaskPropertyGroup + readonly effect: PropertyGroup + readonly layerStyle: _LayerStyles + readonly geometryOption: _GeometryOptionsGroup + readonly materialOption: _MaterialOptionsGroup + readonly audio: _AudioGroup +} + +/** The CameraLayer object represents a camera layer within a composition. Create it using the LayerCollection object’s addCamera method */ +declare class CameraLayer extends Layer { + /** Shortcuts */ + readonly cameraOption: _CameraOptionsGroup +} + +/** Like an array, a collection associates a set of objects or values as a logical group and provides access to them by index. However, most collection objects are read-only. You do not assign objects to them yourself—their contents update automatically as objects are created or deleted. */ +declare class Collection { + /** The number of objects in the collection. */ + readonly length: number +} + +/** The CompItem object represents a composition, and allows you to manipulate and get information about it. Access the objects by position index number in a project’s item collection. */ +declare class CompItem extends AVItem { + /** The number of layers in the composition. */ + readonly numLayers: number + + /** The current active camera layer. */ + readonly activeCamera: CameraLayer | null + + /** The layers of the composition. */ + readonly layers: LayerCollection + + /** The markers of the composition. */ + readonly markerProperty: MarkerValueProperty + + /** The selected layers of the composition. */ + readonly selectedLayers: Layer[] + + /** The selected properties of the composition. */ + readonly selectedProperties: _PropertyClasses[] + + /** The set of available rendering plug-in modules. */ + readonly renderers: string[] + + /** The number of properties in the Essential Graphics panel for the composition. */ + readonly motionGraphicsTemplateControllerCount: number + + /** The duration of a single frame. */ + frameDuration: number + + /** The work area start time. */ + workAreaStart: number + + /** The work area duration. */ + workAreaDuration: number + + /** When true, shy layers are visible in the Timeline panel. */ + hideShyLayers: boolean + + /** When true, motion blur is enabled for this composition. */ + motionBlur: boolean + + /** When true, Draft 3D mode is enabled for the Composition panel. */ + draft3d: boolean + + /** When true, time filtering is enabled for this composition. */ + frameBlending: boolean + + /** When true, the frame rate of nested compositions is preserved. */ + preserveNestedFrameRate: boolean + + /** When true, the resolution of nested compositions is preserved. */ + preserveNestedResolution: boolean + + /** The background color of the composition. */ + bgColor: ThreeDColorValue + + /** Changes the display of the start time in the Timeline panel. */ + displayStartTime: number + + /** The factor by which the x and y resolution of the Composition panel is downsampled. */ + resolutionFactor: [number, number] + + /** The camera shutter angle. */ + shutterAngle: number + + /** The camera shutter phase. */ + shutterPhase: number + + /** The minimum number of motion blur samples per frame for Classic 3D layers, shape layers, and certain effects. */ + motionBlurSamplesPerFrame: number + + /** The maximum number of motion blur samples of 2D layer motion. */ + motionBlurAdaptiveSampleLimit: number + + /** Read or write the name property in the Essential Graphics panel for the composition. */ + motionGraphicsTemplateName: string + + /** The rendering plug-in module to be used to render this composition. */ + renderer: string + + /** When true, indicates that the composition uses drop-frame timecode. */ + dropFrame: boolean + + /** The frame value of the beginning of the composition. */ + displayStartFrame: number + + /** Creates and returns a duplicate of this composition. */ + duplicate(): CompItem + + /** Gets a layer from this composition. */ + layer(index: number): Layer + layer(otherLayer: Layer, relIndex: number): Layer + layer(name: string): Layer + + /** Opens the composition in a Composition panel. */ + openInViewer(): Viewer | null + + /** Save the specific frame to a png file */ + saveFrameToPng(time: number, file: File): void + + /** Open this Composition in the Preview panel, and change the zoom and exposure settings. */ + ramPreviewTest(unknown: any, zoom: number, exposure: number): void + + /** Exports the composition as a Motion Graphics template. */ + exportAsMotionGraphicsTemplate(doOverWriteFileIfExisting: boolean, file_path?: string): boolean + + /** Opens the composition in the Essential Graphics panel. */ + openInEssentialGraphics(): void + + /** Gets the name of a single property in the Essential Graphics panel. */ + getMotionGraphicsTemplateControllerName(index: number): string + + /** Sets the name of a single property in the Essential Graphics panel. */ + setMotionGraphicsControllerName(index: number, newName: string): string +} + +/** The FileSource object describes footage that comes from a file. */ +declare class FileSource extends FootageSource { + /** The file that defines this asset. */ + readonly file: File + + /** The file that contains footage missing from this asset. */ + readonly missingFootagePath: string + + /** Reloads the asset from the file, if it is a mainSource of a FootageItem. */ + reload(): void +} + +/** The FolderItem object corresponds to a folder in your Project panel. It can contain various types of items (footage, compositions, solids) as well as other folders. */ +declare class FolderItem extends Item { + /** The contents of this folder. */ + readonly items: ItemCollection + + /** The number of items contained in the folder. */ + readonly numItems: number + + /** Gets an item from the folder. */ + item(index: number): _ItemClasses +} + +/** The FootageItem object represents a footage item imported into a project, which appears in the Project panel. These are accessed by position index number in a project’s item collection. */ +declare class FootageItem extends AVItem { + /** The footage source file. */ + readonly file: File | null + + /** All settings related to the footage item. */ + readonly mainSource: FootageSource + + /** Opens the footage in a Footage panel. */ + openInViewer(): Viewer | null + + /** Replaces a footage file with another footage file. */ + replace(file: File): void + + /** Replaces a footage file with a placeholder object. */ + replaceWithPlaceholder( + name: string, + width: number, + height: number, + frameRate: number, + duration: number, + ): void + + /** Replaces a footage file with an image sequence. */ + replaceWithSequence(file: File, forceAlphabetical: boolean): void + + /** Replaces a footage file with a solid. */ + replaceWithSolid( + color: ThreeDColorValue, + name: string, + width: number, + height: number, + pixelAspect: number, + ): void +} + +declare class PlaceholderItem extends FootageItem {} + +/** The FootageSource object holds information describing the source of some footage. It is used as the mainSource of a FootageItem, or the proxySource of a CompItem or FootageItem. */ +declare class FootageSource { + /** The footage source file. */ + readonly file: File | null + + /** When true, footage is a still image. */ + readonly isStill: boolean + + /** The effective frame rate as displayed and rendered in compositions by After Effects. */ + readonly displayFrameRate: number + + /** When true, a footage clip or proxy includes an alpha channel. */ + hasAlpha: boolean + + /** The mode of an alpha channel. */ + alphaMode: AlphaMode + + /** The color to be premultiplied. */ + premulColor: ThreeDColorValue + + /** When true, an alpha channel in a footage clip or proxy should be inverted. */ + invertAlpha: boolean + + /** The field separation type. */ + fieldSeparationType: FieldSeparationType + + /** How the fields are to be separated in non-still footage. */ + highQualityFieldSeparation: boolean + + /** The pulldown type for the footage. */ + removePulldown: PulldownPhase + + /** How many times an image sequence is set to loop. */ + loop: number + + /** The native frame rate of the footage. */ + nativeFrameRate: number + + /** The rate to which footage should conform. */ + conformFrameRate: number + + /** Estimates the alphaMode setting. */ + guessAlphaMode(): void + + /** Estimates the pulldownType setting. */ + guessPulldown(method: PulldownMethod): void +} + +/** The ImportOptions object encapsulates the options used to import a file with the Project.importFile methods. */ +declare class ImportOptions { + constructor(file?: File) + + /** The type of file to be imported. */ + importAs: ImportAsType + + /** When true, import a sequence of files, rather than an individual file. */ + sequence: boolean + + /** When true, the “Force alphabetical order” option is set. */ + forceAlphabetical: boolean + + /** The file to import, or the first file of the sequence to import. */ + file: File + + /** Restricts input to a particular file type. */ + canImportAs(type: ImportAsType): boolean +} + +/** The Item object represents an item that can appear in the Project panel. */ +declare class Item { + /** A unique identifier for this item. */ + readonly id: number + + /** The type of item. */ + readonly typeName: string + + /** The name of the object as shown in the Project panel. */ + name: string + + /** A descriptive string. */ + comment: string + + /** The parent folder of this item. */ + parentFolder: FolderItem + + /** When true, this item is currently selected. */ + selected: boolean + + /** The label color for the item. */ + label: number + + /** Creates a new guide and adds it to the guides object of the Item. */ + addGuide(orientationType: number, position: number): number + + /** Removes an existing guide. */ + removeGuide(guideIndex: number): void + + /** Modifies the position of an existing guide. */ + setGuide(position: number, guideIndex: number): void + + /** Deletes the item from the project. */ + remove(): void +} + +/** The ItemCollection object represents a collection of items. The ItemCollection belonging to a Project object contains all the Item objects for items in the project. The ItemCollection belonging to a FolderItem object contains all the Item objects for items in that folder. */ +declare class ItemCollection extends Collection { + /** Retrieves a Item object in the collection by its index number. The first object is at index 1. */ + readonly [index: number]: _ItemClasses + + /** Creates a new CompItem object and adds it to the collection. */ + addComp( + name: string, + width: number, + height: number, + pixelAspect: number, + duration: number, + frameRate: number, + ): CompItem + + /** Creates a new FolderItem object and adds it to the collection. */ + addFolder(name: string): FolderItem +} + +/** The KeyframeEase object encapsulates the keyframe ease settings of a layer’s AE property. Keyframe ease is determined by the speed and influence values that you set using the property’s setTemporalEaseAtKey method. */ +declare class KeyframeEase { + constructor(speed: number, influence: number) + + /** The speed setting for a keyframe. */ + speed: number + + /** The influence setting for a keyframe. */ + influence: number +} + +declare class Layer extends PropertyGroup { + /** The unique and persistent identification number. */ + readonly id: number + + /** The index position of the layer. */ + readonly index: number + + /** The current time of the layer. */ + readonly time: number + + /** When true, the layer contains a video component. */ + readonly hasVideo: boolean + + /** When true, the layer is active at the current time. */ + readonly active: boolean + + /** When true, this is a null layer. */ + readonly nullLayer: boolean + + /** All selected AE properties in the layer. */ + readonly selectedProperties: _PropertyClasses[] + + /** The composition that contains this layer. */ + readonly containingComp: CompItem + + /** When true, the layer’s name has been explicitly set. */ + readonly isNameSet: boolean + + /** The name of the layer. */ + name: string + + /** The parent of this layer. */ + parent: Layer | null + + /** The start time of the layer. */ + startTime: number + + /** The time stretch percentage of the layer. */ + stretch: number + + /** The “in” point of the layer. */ + inPoint: number + + /** The “out” point of the layer. */ + outPoint: number + + /** When true, the layer is enabled. */ + enabled: boolean + + /** When true, the layer is soloed. */ + solo: boolean + + /** When true, the layer is shy. */ + shy: boolean + + /** When true, the layer is locked. */ + locked: boolean + + /** A descriptive comment for the layer. */ + comment: string + + /** The label color for the layer. */ + label: number + + /** The type of automatic orientation for the layer. */ + autoOrient: AutoOrientType + + /** Moves the layer to the top of the composition (makes it the first layer). */ + moveToBeginning(): void + + /** Moves the layer to the bottom of the composition (makes it the last layer). */ + moveToEnd(): void + + /** Moves the layer below another layer. */ + moveAfter(layer: Layer): void + + /** Moves the layer above another layer. */ + moveBefore(layer: Layer): void + + /** Duplicates the layer. */ + duplicate(): Layer + + /** Copies the layer to the top (beginning) of another composition. */ + copyToComp(intoComp: CompItem): void + + /** Runs Scene Edit Detection on the layer that the method is called on and returns an array containing the times of any detected scenes */ + doSceneEditDetection(applyOptions: SceneEditDetectionMode): number[]; + + /** Reports whether this layer will be active at a specified time. */ + activeAtTime(time: number): boolean + + /** Sets a new parent for this layer. */ + setParentWithJump(newParent?: Layer): void + + /** Applies a named collection of animation settings to the layer. */ + applyPreset(presetName: File): void + + /** Shortcuts */ + readonly marker: MarkerValueProperty + readonly transform: _TransformGroup + + /** Transform shortcuts */ + readonly anchorPoint: TwoDOrThreeDProperty + readonly position: TwoDOrThreeDProperty + readonly xPosition: OneDProperty + readonly yPosition: OneDProperty + readonly zPosition: OneDProperty + readonly scale: TwoDOrThreeDProperty + readonly orientation: ThreeDProperty + readonly rotation: OneDProperty + readonly xRotation: OneDProperty + readonly yRotation: OneDProperty + readonly zRotation: OneDProperty + readonly opacity: OneDProperty + readonly pointOfInterest: ThreeDProperty +} + +/** The LayerCollection object represents a set of layers. The LayerCollection belonging to a CompItem object contains all the layer objects for layers in the composition. The methods of the collection object allow you to manipulate the layer list. */ +declare class LayerCollection extends Collection { + /** Retrieves a Layer object in the collection by its index number. The first object is at index 1. */ + readonly [index: number]: Layer + + /** Creates a new AVLayer and adds it to this collection. */ + add(item: AVItem, duration?: number): AVLayer + + /** Creates a new, null layer and adds it to this collection. */ + addNull(duration?: number): AVLayer + + /** Creates a new layer, a FootageItem with a SolidSource, and adds it to this collection. */ + addSolid( + color: ThreeDColorValue, + name: string, + width: number, + height: number, + pixelAspect: number, + duration?: number, + ): AVLayer + + /** Creates a new paragraph (box) text layer and adds it to this collection. */ + addBoxText(size: [number, number], sourceText?: string | TextDocument): TextLayer + + /** Creates a new point text layer and adds it to this collection. */ + addText(sourceText?: string | TextDocument): TextLayer + + /** Creates a new camera layer and adds it to this collection. */ + addCamera(name: string, centerPoint: [number, number]): CameraLayer + + /** Creates a new light layer and adds it to this collection. */ + addLight(name: string, centerPoint: [number, number]): LightLayer + + /** Creates a new shape layer and adds it to this collection. */ + addShape(): ShapeLayer + + /** Retrieves the layer object with a specified name. */ + byName(name: string): Layer | null + + /** Collects specified layers into a new composition. */ + precompose(layerIndicies: number[], name: string, moveAllAttributes?: boolean): CompItem +} + +/** The LightLayer object represents a light layer within a composition. Create it using the LayerCollection object’s addLight method */ +declare class LightLayer extends Layer { + /** Shortcuts */ + readonly lightOption: _LightOptionsGroup + + /** For light layers, the type of light. */ + lightType: LightType +} + +/** The MarkerValue object represents a layer marker, which associates a comment, and optionally a chapter reference point, Web-page link, or Flash Video cue point with a particular point in a layer. */ +declare class MarkerValue { + constructor( + comment: string, + chapter?: string, + url?: string, + frameTarget?: string, + cuePointName?: string, + params?: string, + ) + + /** A comment on the associated layer. */ + comment: string + + /** A chapter link reference point for the associated layer. */ + chapter: string + + /** The Flash Video cue point name. */ + cuePointName: string + + /** The amount of time represented by the marker. */ + duration: number + + /** Whether the Flash Video cue point is for an event or navigation. */ + eventCuePoint: boolean + + /** A URL for Web page to be associated with the layer. */ + url: string + + /** A specific frame target within the Web page specified by url. */ + frameTarget: string + + /** The label color for a composition or layer marker. */ + label: number + + /** State of the Protected Region option in the Composition Marker dialog box. */ + protectedRegion: boolean + + /** Retrieves the key-value pairs associated with the marker value. */ + getParameters(): object + + /** Sets the key-value pairs associated with the marker value. */ + setParameters(keyValuePairs: object): void +} + +/** The MaskPropertyGroup object encapsulates mask attributes in a layer. */ +declare class MaskPropertyGroup extends PropertyGroup { + /** The mask mode. */ + maskMode: MaskMode + + /** When true, the mask is inverted. */ + inverted: boolean + + /** When true, the shape of the mask is RotoBezier. */ + rotoBezier: boolean + + /** How motion blur is applied to this mask. */ + maskMotionBlur: MaskMotionBlur + + /** When true, the mask is locked. */ + locked: boolean + + /** The color used to draw the mask outline in the user interface. */ + color: ThreeDColorValue + + /** The shape of the mask. */ + maskShape: ShapeProperty + + /** The path of the mask. */ + maskPath: ShapeProperty + + /** The mask feather amount. */ + maskFeather: TwoDProperty + + /** The feather falloff mode for the mask. */ + maskFeatherFalloff: MaskFeatherFalloff + + /** The mask opacity. */ + maskOpacity: OneDProperty + + /** The mask expansion amount. */ + maskExpansion: OneDProperty +} + +/** The OMCollection contains all of the output modules in a render queue. The collection provides access to the OutputModule objects, but does not provide any additional functionality. The first OutputModule object in the collection is at index position 1. */ +declare class OMCollection extends Collection { + /** Retrieves a OutputModule object in the collection by its index number. The first object is at index 1. */ + readonly [index: number]: OutputModule +} + +/** An OutputModule object of a RenderQueueItem generates a single file or sequence via a render operation, and contains attributes and methods relating to the file to be rendered. */ +declare class OutputModule { + /** The user-interface name of the output module. */ + readonly name: string + + /** All templates for the output module */ + readonly templates: string[] + + /** The path and name of the file to be rendered. */ + file: File + + /** An action to be taken after rendering. */ + postRenderAction: PostRenderAction + + /** When true, writes all source footage XMP metadata to the output file. */ + includeSourceXMP: boolean + + /** Removes this output module from the render-queue item’s list. */ + remove(): void + + /** Saves a new output-module template. */ + saveAsTemplate(name: string): void + + /** Applies an output-module template. */ + applyTemplate(templateName: string): void + + getSetting(key: string): string | number + + getSettings(format?: GetSettingsFormat): { + "Audio Bit Depth": string + "Audio Channels": string + "Audio Sample Rate": string + Channels: string + Color: string + Crop: string + "Crop Bottom": string + "Crop Left": string + "Crop Right": string + "Crop Top": string + Depth: string + Format: string + "Include Project Link": string + "Include Source XMP Metadata": string + "Lock Aspect Ratio": string + "Output Audio": string + "Output File Info": string + "Post-Render Action": string + Resize: string + "Resize Quality": string + "Resize to": object + "Starting #": string + "Use Comp Frame Number": string + "Use Region of Interest": string + "Video Output": string + } + + setSetting(key: string, value: string | number): void + + setSettings(settings: object): void +} + +/** The PlaceholderSource object describes the footage source of a placeholder. */ +declare class PlaceholderSource extends FootageSource {} + +/** The project object represents an After Effects project. Attributes provide access to specific objects within the project, such as imported files or footage and compositions, and also to project settings such as the timecode base. Methods can import footage, create solids, compositions and folders, and save changes. */ +declare class Project { + /** The file for the currently open project. */ + readonly file: File | null + + /** The folder containing all the contents of the project; the equivalent of the Project panel */ + readonly rootFolder: FolderItem + + /** All items in the project. */ + readonly items: ItemCollection + + /** The currently active item. */ + readonly activeItem: _ItemClasses | null + + /** The total number of items contained in the project. */ + readonly numItems: number + + /** All items selected in the Project panel. */ + readonly selection: _ItemClasses[] + + /** The project’s render queue. */ + readonly renderQueue: RenderQueue + + /** The color depth of the current project. */ + bitsPerChannel: number + + /** When true, thumbnail views use the transparency checkerboard pattern. */ + transparencyGridThumbnails: boolean + + /** The frame at which to start numbering when displaying the project. */ + displayStartFrame: number + + /** Get or set the current projects GPU Acceleration option. */ + gpuAccelType: GpuAccelType + + /** When true, linear blending is used for the project. */ + linearBlending: boolean + + /** The project’s XMP metadata. */ + xmpPacket: string + + /** The Frame Count menu setting in the Project Settings dialog box. */ + framesCountType: FramesCountType + + /** The Use Feet + Frames menu setting in the Project Settings dialog box. */ + feetFramesFilmType: FeetFramesFilmType + + /** The Use Feet + Frames setting in the Project Settings dialog box. */ + framesUseFeetFrames: boolean + + /** The Footage Start Time setting in the Project Settings dialog box, which is enabled when Timecode is selected as the time display style. */ + footageTimecodeDisplayStartType: FootageTimecodeDisplayStartType + + /** The time display style, corresponding to the Time Display Style section in the Project Settings dialog box. */ + timeDisplayType: TimeDisplayType + + /** The active tool in the Tools panel. */ + toolType: ToolType + + /** The current project’s working gamma value, either 2.2 or 2.4. */ + workingGamma: 2.2 | 2.4 + + /** A string which is the color profile description for the project’s color working space. */ + workingSpace: string + + /** True if Linearize Working Space should be enabled for this project. */ + linearizeWorkingSpace: boolean + + /** True if Compensate for Scene-referred Profiles should be enabled for this project. */ + compensateForSceneReferredProfiles: boolean + + /** The Expressions Engine setting in the Project Settings dialog box. */ + expressionEngine: "extendscript" | "javascript-1.0" + + /** Retrieves an item from the project. */ + item(index: number): _ItemClasses + + /** Retrieves an item by its Item ID */ + itemByID(id: number): _ItemClasses + + /** Consolidates all footage in the project. */ + consolidateFootage(): number + + /** Removes unused footage from the project. */ + removeUnusedFootage(): number + + /** Reduces the project to a specified set of items. */ + reduceProject(array_of_items: _ItemClasses[]): number + + /** Closes the project with normal save options. */ + close(closeOptions: CloseOptions): boolean + + /** Saves the project. */ + save(file?: File): void + + /** Displays a Save dialog box. */ + saveWithDialog(): boolean + + /** Imports a placeholder into the project. */ + importPlaceholder( + name: string, + width: number, + height: number, + frameRate: number, + duration: number, + ): PlaceholderItem + + /** Imports a file into the project. */ + importFile(importOptions: ImportOptions): _ItemClasses + + /** Displays an Import File dialog box. */ + importFileWithDialog(): _ItemClasses[] | null + + /** Shows or hides the Project panel. */ + showWindow(doShow: boolean): void + + /** Automatically replaces text in all expressions. */ + autoFixExpressions(oldText: string, newText: string): void + + /** Creates a new team project. */ + newTeamProject(teamProjectName: string, description: string): boolean + + /** Opens a team project. */ + openTeamProject(teamProjectName: string): boolean + + /** Shares the currently open team project. */ + shareTeamProject(comment: string): boolean + + /** Syncs the currently open team project. */ + syncTeamProject(): boolean + + /** Closes a currently open team project. */ + closeTeamProject(): boolean + + /** Converts a team project to an After Effects project on a local disk. */ + convertTeamProjectToProject(project_file: File): boolean + + /** Returns an array containing the name strings for all team projects available for the current user. Archived Team Projects are not included. */ + listTeamProjects(): string[] + + /** Retrieves a layer by its Layer ID */ + layerByID(id: number): Layer | null + + /** Checks whether specified team project is currently open. */ + isTeamProjectOpen(teamProjectName: string): boolean + + /** Checks whether any team project is currently open. */ + isAnyTeamProjectOpen(): boolean + + /** Checks whether or not team projects is enabled for After Effects. (This will almost always return true.) */ + isTeamProjectEnabled(): boolean + + /** Checks whether or not the client (After Effects) is currently logged into the team project server. */ + isLoggedInToTeamProject(): boolean + + /** Checks whether or not the Sync command is enabled. */ + isSyncCommandEnabled(): boolean + + /** Checks whether or not the Share command is enabled. */ + isShareCommandEnabled(): boolean + + /** Checks whether or not the Resolve command is enabled. */ + isResolveCommandEnabled(): boolean + + /** Resolves a conflict between the open team project and the version on the team projects server, using the specified resolution method. */ + resolveConflict(ResolveType: ResolveType): boolean + + /** Returns an array of color profile descriptions that can be set as the project’s color working space. */ + listColorProfiles(): string[] + + /** Sets the folder that will be shown in the file import dialog. */ + setDefaultImportFolder(folder: Folder): boolean +} + +type PropertyClassMembers = { + [P in keyof Property]: Property[P] +} +declare interface UnknownPropertyType extends PropertyClassMembers { + propertyValueType: PropertyValueType + value: any +} + +declare interface NoValueType extends PropertyClassMembers { + propertyValueType: PropertyValueType.NO_VALUE + value: any +} + +type ColorValue = [number, number, number, number] +type ThreeDColorValue = [number, number, number] + +declare interface ColorType extends PropertyClassMembers { + propertyValueType: PropertyValueType.COLOR + value: ColorValue +} + +declare interface BooleanType extends PropertyClassMembers { + propertyValueType: PropertyValueType.OneD + value: boolean +} +declare interface OneDType extends PropertyClassMembers { + propertyValueType: PropertyValueType.OneD + value: number +} + +declare interface TwoDType extends PropertyClassMembers { + propertyValueType: PropertyValueType.TwoD + value: TwoDPoint +} + +type TwoDPoint = [number, number] +declare interface TwoDSpatialType extends PropertyClassMembers { + propertyValueType: PropertyValueType.TwoD_SPATIAL + value: TwoDPoint +} + +type ThreeDPoint = [number, number, number] + +declare interface ThreeDType extends PropertyClassMembers { + propertyValueType: PropertyValueType.ThreeD + value: ThreeDPoint +} + +declare interface TextDocumentType extends PropertyClassMembers { + propertyValueType: PropertyValueType.TEXT_DOCUMENT + value: TextDocument +} + +declare interface MarkerValueType extends PropertyClassMembers { + propertyValueType: PropertyValueType.MARKER + value: MarkerValue +} + +declare interface ShapePropertyType extends PropertyClassMembers { + propertyValueType: PropertyValueType.SHAPE + value: Shape +} + +type NoValueProperty = Property +type ColorProperty = Property +type OneDProperty = Property +type TwoDProperty = Property +type ThreeDProperty = Property +type TwoDOrThreeDProperty = Property +type ShapeProperty = Property +type MarkerValueProperty = Property +type TextDocumentProperty = Property + +type AnyProperty = + | NoValueProperty + | ColorProperty + | OneDProperty + | TwoDProperty + | ThreeDProperty + | TwoDOrThreeDProperty + | ShapeProperty + | MarkerValueProperty + | TextDocumentProperty + +/** The Property object contains value, keyframe, and expression information about a particular AE property of a layer. */ +declare class Property extends PropertyBase { + /** Type of value stored in this property. */ + readonly propertyValueType: T["propertyValueType"] + + /** Current value of the property. */ + readonly value: T["value"] + + /** When true, there is a minimum permitted value. */ + readonly hasMin: boolean + + /** When true, there is a maximum permitted value. */ + readonly hasMax: boolean + + /** The minimum permitted value. */ + readonly minValue: number + + /** The maximum permitted value. */ + readonly maxValue: number + + /** When true, the property defines a spatial value. */ + readonly isSpatial: boolean + + /** When true, the property can be keyframed. */ + readonly canVaryOverTime: boolean + + /** When true, the expression can be set by a script. */ + readonly canSetExpression: boolean + + /** When true, the property has keyframes or an expression enabled that can vary its values. */ + readonly isTimeVarying: boolean + + /** The number of keyframes on this property. */ + readonly numKeys: number + + /** A text description of the units in which the value is expressed. */ + readonly unitsText: string + + /** The error, if any, that occurred when the last expression was evaluated. */ + readonly expressionError: string + + /** All selected keyframes of the property. */ + readonly selectedKeys: number[] + + /** The position index of this property. */ + readonly propertyIndex: number + + /** When true, the property represents one of the separated dimensions for a multidimensional property. */ + readonly isSeparationFollower: boolean + + /** When true, the property is multidimensional and can be separated. */ + readonly isSeparationLeader: boolean + + /** For a separated follower, the dimension it represents in the multidimensional leader. */ + readonly separationDimension: number + + /** The original multidimensional property for this separated follower. */ + readonly separationLeader: TwoDOrThreeDProperty + + /** When true, the property is the Menu property of a Dropdown Menu Control effect. */ + readonly isDropdownEffect: boolean + + /** The alternate render source for Media Replacement */ + readonly alternateSource: AVItem + + /** True if the property allows Media Replacement */ + readonly canSetAlternateSource: boolean + + /** + * Instance property on an Essential Property object which returns the original source Property which was used to create the Essential Property. + */ + readonly essentialPropertySource: Property | AVLayer | null + + /** The expression string for this property. */ + expression: string + + /** When true, the expression is used to generate values for the property. */ + expressionEnabled: boolean + + /** When true, the property’s dimensions are represented as separate properties. */ + dimensionsSeparated: boolean + + /** Gets the value of the property evaluated at given time. */ + valueAtTime(time: number, preExpression: boolean): T["value"] + + /** Sets the static value of the property. */ + setValue(newValue: T["value"]): void + + /** Creates a keyframe for the property. */ + setValueAtTime(time: number, newValue: T["value"]): void + + /** Creates a set of keyframes for the property. */ + setValuesAtTimes(times: number[], newValues: T["value"][]): void + + /** Finds a keyframe and sets the value of the property at that keyframe. */ + setValueAtKey(keyIndex: number, newValue: T["value"]): void + + /** Gets the keyframe nearest to a specified time. */ + nearestKeyIndex(time: number): number + + /** Gets the time at which a condition occurs. */ + keyTime(keyIndex: number): number + keyTime(markerComment: string): number + + /** Gets the value of a keyframe at the time at which a condition occurs. */ + keyValue(keyIndex: number): T["value"] + keyValue(markerComment: string): MarkerValue + + /** Adds a new keyframe to the property at a given time. */ + addKey(time: number): number + + /** Removes a keyframe from the property. */ + removeKey(keyIndex: number): void + + /** Returns the labelIndex value assigned to the referenced keyframe. (0 for None, or 1 to 16 for one of the preset colors in the Labels preferences). */ + keyLabel(keyIndex: number): number + + /** Sets the labelIndex value for the referenced keyframe. (0 for None, or 1 to 16 for one of the preset colors in the Labels preferences). */ + setLabelAtKey(keyIndex: number, labelIndex: number): void + + /** When true, this property can be interpolated. */ + isInterpolationTypeValid(type: KeyframeInterpolationType): boolean + + /** Sets the interpolation type for a key. */ + setInterpolationTypeAtKey( + keyIndex: number, + inType: KeyframeInterpolationType, + outType?: KeyframeInterpolationType, + ): void + + /** Gets the 'in' interpolation type for a key. */ + keyInInterpolationType(keyIndex: number): KeyframeInterpolationType + + /** Gets the 'out' interpolation type for a key. */ + keyOutInterpolationType(keyIndex: number): KeyframeInterpolationType + + /** Sets the “in” and “out” tangent vectors for a key. */ + setSpatialTangentsAtKey( + keyIndex: number, + inTangent: [number, number], + outTangent: typeof inTangent, + ): void + setSpatialTangentsAtKey( + keyIndex: number, + inTangent: [number, number, number], + outTangent: typeof inTangent, + ): void + + /** Gets the “in” spatial tangent for a key. */ + keyInSpatialTangent(keyIndex: number): [number, number] | [number, number, number] + + /** Gets the “out” spatial tangent for a key. */ + keyOutSpatialTangent(keyIndex: number): [number, number] | [number, number, number] + + /** Sets the “in” and “out” temporal ease for a key. */ + setTemporalEaseAtKey( + keyIndex: number, + inTemporalEase: [KeyframeEase], + outTemporalEase?: typeof inTemporalEase, + ): void + setTemporalEaseAtKey( + keyIndex: number, + inTemporalEase: [KeyframeEase, KeyframeEase], + outTemporalEase?: typeof inTemporalEase, + ): void + setTemporalEaseAtKey( + keyIndex: number, + inTemporalEase: [KeyframeEase, KeyframeEase, KeyframeEase], + outTemporalEase?: typeof inTemporalEase, + ): void + + /** Gets the “in” temporal ease for a key. */ + keyInTemporalEase( + keyIndex: number, + ): [KeyframeEase] | [KeyframeEase, KeyframeEase] | [KeyframeEase, KeyframeEase, KeyframeEase] + + /** Gets the “out” temporal ease for a key. */ + keyOutTemporalEase( + keyIndex: number, + ): [KeyframeEase] | [KeyframeEase, KeyframeEase] | [KeyframeEase, KeyframeEase, KeyframeEase] + + /** Sets whether a keyframe has temporal continuity. */ + setTemporalContinuousAtKey(keyIndex: number, newVal: boolean): void + + /** Reports whether a keyframe has temporal continuity. */ + keyTemporalContinuous(keyIndex: number): boolean + + /** Sets whether a keyframe has temporal auto-Bezier. */ + setTemporalAutoBezierAtKey(keyIndex: number, newVal: boolean): void + + /** Reports whether a keyframe has temporal auto-Bezier. */ + keyTemporalAutoBezier(keyIndex: number): boolean + + /** Sets whether a keyframe has spatial continuity. */ + setSpatialContinuousAtKey(keyIndex: number, newVal: boolean): void + + /** Reports whether a keyframe has spatial continuity. */ + keySpatialContinuous(keyIndex: number): boolean + + /** Sets whether a keyframe has spatial auto-Bezier. */ + setSpatialAutoBezierAtKey(keyIndex: number, newVal: boolean): void + + /** Reports whether a keyframe has spatial auto-Bezier. */ + keySpatialAutoBezier(keyIndex: number): boolean + + /** Sets whether a keyframe is roving. */ + setRovingAtKey(keyIndex: number, newVal: boolean): void + + /** Reports whether a keyframe is roving. */ + keyRoving(keyIndex: number): boolean + + /** Sets whether a keyframe is selected. */ + setSelectedAtKey(keyIndex: number, onOff: boolean): void + + /** Reports whether a keyframe is selected. */ + keySelected(keyIndex: number): boolean + + /** For a separated, multidimensional property, retrieves a specific follower property. */ + getSeparationFollower(dim: number): Property + + /** Adds the property to the Essential Graphics panel for the specified composition. */ + addToMotionGraphicsTemplate(comp: CompItem): boolean + + /** Adds the property to the Essential Graphics panel for the specified composition, providing a name. */ + addToMotionGraphicsTemplateAs(comp: CompItem, name: string): boolean + + /** Test whether or not the property can be added to the Essential Graphics panel for the specified composition. */ + canAddToMotionGraphicsTemplate(comp: CompItem): boolean + + /** Sets parameters for a Dropdown Menu Control’s Menu Property. */ + setPropertyParameters(items: string[]): Property + + /** Set the alternate source for this property. */ + setAlternateSource(newSource: AVItem): void +} + +declare class PropertyBase { + /** A special name for the property used to build unique naming paths. */ + readonly matchName: string + + /** Index of this property within its parent group. */ + readonly propertyIndex: number + + /** The number of levels of parent groups between this property and the containing layer. */ + readonly propertyDepth: number + + /** The property type. */ + readonly propertyType: PropertyType + + /** The immediate parent group of this property. */ + readonly parentProperty: PropertyGroup + + /** When true, the property has been changed since its creation. */ + readonly isModified: boolean + + /** When true, the user interface displays an eyeball icon for this property. */ + readonly canSetEnabled: boolean + + /** When true, this property is active. */ + readonly active: boolean + + /** When true, this property is not displayed in the user interface. */ + readonly elided: boolean + + /** When true, this property is an effect. */ + readonly isEffect: boolean + + /** When true, this property is a mask. */ + readonly isMask: boolean + + /** Name of the property. */ + name: string + + /** When true, this property is enabled. */ + enabled: boolean + + /** When true, this property is selected. */ + selected: boolean + + /** Gets the parent group for this property. */ + propertyGroup(countUp?: number): PropertyGroup + + /** Removes this from the project. */ + remove(): void + + /** Moves this property to a new position in its parent group. */ + moveTo(newIndex: number): void + + /** Duplicates this property object. */ + duplicate(): _PropertyClasses + + /** Gets a member property or group. Strictly, this should be PropertyGroup method. */ + property(index: number): _PropertyClasses + property(name: string): _PropertyClasses +} + +/** Properties are accessed by name through layers, using various kinds of expression syntax, as controlled by application preferences. */ +declare interface PropertyGroup { + (index: number): _PropertyClasses + (name: string): _PropertyClasses +} + +/** The PropertyGroup object represents a group of properties. It can contain Property objects and other PropertyGroup objects. Property groups can be nested to provide a parent-child hierarchy, with a Layer object at the top (root) down to a single Property object, such as the mask feather of the third mask. To traverse the group hierarchy, use PropertyBase methods and attributes. */ +declare class PropertyGroup extends PropertyBase { + /** The number of indexed properties in the group. */ + readonly numProperties: number + + /** Reports whether a property can be added to the group. */ + canAddProperty(name: string): boolean + + /** Adds a property to the group. */ + addProperty(name: string): _PropertyClasses +} + +/** The RenderQueue object represents the render automation process, the data and functionality that is available through the Render Queue panel of a particular After Effects project. Attributes provide access to items in the render queue and their render status. Methods can start, pause, and stop the rendering process. */ +declare class RenderQueue { + /** When true, a render is in progress. */ + readonly rendering: boolean + + /** The total number of items in the render queue. */ + readonly numItems: number + + /** CC 2017(14.0)- */ + readonly canQueueInAME: boolean + + /** The collection of items in the render queue. */ + readonly items: RQItemCollection + + /** Read or write the Notify property for the entire Render Queue */ + queueNotify: boolean; + + /** Show or hides the Render Queue panel. */ + showWindow(doShow: boolean): void + + /** Starts the rendering process; does not return until render is complete. */ + render(): void + + /** Pauses or restarts the rendering process. */ + pauseRendering(pause: boolean): void + + /** Calls the Queue In AME command */ + queueInAME(render_immediately_in_AME: boolean): void + + /** Stops the rendering process. */ + stopRendering(): void + + /** Gets a render-queue item from the collection. */ + item(index: number): RenderQueueItem +} + +/** The RenderQueueItem object represents an individual item in the render queue. It provides access to the specific settings for an item to be rendered. Create the object by adding a composition to the Render Queue with the RQItemCollection object; */ +declare class RenderQueueItem { + /** The total number of Output Modules assigned to the item. */ + readonly numOutputModules: number + + /** The time when rendering began for the item. */ + readonly startTime: Date | null + + /** The time elapsed in the current rendering of this item. */ + readonly elapsedSeconds: number | null + + /** The composition to be rendered by this item. */ + readonly comp: CompItem + + /** The collection of Output Modules for this item. */ + readonly outputModules: OMCollection + + /** A set of Render Settings templates. */ + readonly templates: string[] + + /** The current rendering status of the item. */ + readonly status: RQItemStatus + + /** Sets the Notify checkbox for each individual item in the Render Queue */ + queueItemNotify: boolean; + + /** When true, this item is rendered when the queue is started. */ + render: boolean + + /** The start time in the composition to be rendered. */ + timeSpanStart: number + + /** The duration of the composition to be rendered. */ + timeSpanDuration: number + + /** The number of frames to skip when rendering this item. */ + skipFrames: number + + /** A callback function that is called during the rendering process when the status of the item changes. */ + onStatus: string | null + + /** A log type for this item. */ + logType: LogType + + getSetting(key: string): string | number + + getSettings(format: GetSettingsFormat): object + + setSetting(key: string, value: string | number): void + + setSettings(settings: object): void + + /** Gets an Output Module for the item. */ + outputModule(index: number): OutputModule + + /** Removes the item from the render queue. */ + remove(): void + + /** Saves a new Render Settings template. */ + saveAsTemplate(name: string): void + + /** Applies a Render Settings template. */ + applyTemplate(templateName: string): void + + /** Duplicates this item. */ + duplicate(): RenderQueueItem +} + +/** The RQItemCollection contains all of the render-queue items in a project, as shown in the Render Queue panel of the project. The collection provides access to the RenderQueueItem objects, and allows you to create them from compositions. The first RenderQueueItem object in the collection is at index position 1. */ +declare class RQItemCollection extends Collection { + /** Retrieves an RenderQueueItem in the collection by its index number. The first object is at index 1. */ + [index: number]: RenderQueueItem + + /** Adds a composition to the Render Queue. */ + add(comp: CompItem): RenderQueueItem +} + +/** The Settings object provides an easy way to manage settings for scripts. The settings are saved in the After Effects preferences file and are persistent between application sessions. Settings are identified by section and key within the file, and each key name is associated with a value. In the preferences file, section names are enclosed in brackets and quotation marks, and key names are listing in quotation marks below the section name. All values are strings. */ +declare class Settings { + /** Saves a default value for a setting. */ + saveSetting(sectionName: string, keyName: string, value: string, type?: PREFType): void + + /** Retrieves a setting value. */ + getSetting(sectionName: string, keyName: string, type?: PREFType): string + + /** Reports whether a specified setting is assigned. */ + haveSetting(sectionName: string, keyName: string, type?: PREFType): boolean +} + +/** The Shape object encapsulates information describing a shape in a shape layer, or the outline shape of a Mask. */ +declare class Shape { + /** When true, the shape is a closed curve. */ + closed: boolean + + /** The anchor points of the shape. */ + vertices: [number, number][] + + /** The tangent vectors coming into the shape vertices. */ + inTangents: [number, number][] + + /** The tangent vectors coming out of the shape vertices. */ + outTangents: [number, number][] + + /** The mask path segment (sections of a mask path between vertices) containing each feather point. */ + featherSegLocs: number[] + + /** The relative position of each feather point on its mask path segment. */ + featherRelSegLocs: number[] + + /** The feather amount (radius) for each feather point. */ + featherRadii: number[] + + /** The feather radius interpolation type for each feather point. */ + featherInterps: number[] + + /** The feather tension at each feather point. */ + featherTensions: number[] + + /** The direction (inner or outer) of each feather point. */ + featherTypes: number[] + + /** The relative angle between the two normals on either side of a curved outer feather boundary at a corner on a mask path. */ + featherRelCornerAngles: number[] +} + +/** The ShapeLayer object represents a shape layer within a composition. Create it using the LayerCollection object’s addShape() method. */ +declare class ShapeLayer extends AVLayer {} + +/** The SolidSource object represents a solid-color footage source. */ +declare class SolidSource extends FootageSource { + /** The color of the solid. */ + color: ThreeDColorValue +} + +/** The file specification, an ExtendScript File object. */ +declare interface _Swatch { + /** The ASE version number. */ + majorVersion: number + + /** The ASE version number. */ + minorVersion: number + + /** An array of SwatchValue. */ + values: _SwatchValue[] +} + +/** The file specification, an ExtendScript File object. */ +declare interface _SwatchValue { + /** One of "RGB", "CMYK", "LAB", "Gray" */ + type: "RGB" | "CMYK" | "LAB" | "Gray" + + /** When type = "RGB", the color values in the range [0.0..1.0]. 0, 0, 0 is Black. */ + r: number + g: number + b: number + + /** When type = "CMYK", the color values in the range [0.0..1.0]. 0, 0, 0, 0 is White. */ + c: number + m: number + y: number + k: number + + /** When type = "LAB", the color values. L is in the range [0.0..1.0]. a and b are in the range [-128.0..+128.0] 0, 0, 0 is Black. */ + L: number + a: number + // b: number; + + /** When type = "Gray", the value range is [0.0..1.0]. 0.0 is Black. */ + gray: number + value: number +} + +/** The System object provides access to attributes found on the user’s system, such as the user name and the name and version of the operating system. It is available through the system global variable. */ +declare class System { + /** The current user name. */ + readonly userName: string + + /** The name of the host computer. */ + readonly machineName: string + + /** The name of the operating system. */ + readonly osName: string + + /** The version of the operating system. */ + readonly osVersion: string + + /** Execute’s a command on the system’s command line. */ + callSystem(cmdLineToExecute: string): string +} + +/** The TextDocument object stores a value for a TextLayer's Source Text property. Create it with the constructor, passing the string to be encapsulated. */ +declare class TextDocument { + constructor(docText: string) + + /** When true, the text layer is point (unbounded) text. */ + readonly pointText: boolean + + /** When true, the text layer is paragraph (bounded) text. */ + readonly boxText: boolean + + /** Path of font file, providing its location on disk (not guaranteed to be returned for all font types; return value may be empty string for some kinds of fonts) */ + readonly fontLocation: string + + /** Style information — e.g., “bold”, “italic” */ + readonly fontStyle: string + + /** The name of the font family */ + readonly fontFamily: string + + /** True if a text layer has faux bold enabled */ + readonly fauxBold: boolean + + /** True if a text layer has faux italic enabled */ + readonly fauxItalic: boolean + + /** True if a text layer has allcaps enabled */ + readonly allCaps: boolean + + /** True if a text layer has smallcaps enabled */ + readonly smallCaps: boolean + + /** True if a text layer has superscript enabled- */ + readonly superscript: boolean + + /** True if a text layer has subscript enabled- */ + readonly subscript: boolean + + /** This text layer’s vertical scale in pixels. */ + readonly verticalScale: number + + /** This text layer’s horizontal scale in pixels. */ + readonly horizontalScale: number + + /** This text layer’s baseline shift in pixels. */ + readonly baselineShift: number + + /** This text layer’s tsume value. */ + readonly tsume: number + + /** The layer coordinates from a paragraph (box) text layer’s anchor point as a [width, height] array of pixel dimensions. */ + readonly boxTextPos: [number, number] + + /** The baseline (x,y) locations for a text layer. */ + readonly baselineLocs: number[] + + /** The text layer’s Source Text value. */ + text: string + + /** When true, the text layer shows a fill. */ + applyFill: boolean + + /** When true, the text layer shows a stroke. */ + applyStroke: boolean + + /** The text layer’s fill color. */ + fillColor: ThreeDColorValue + + /** The text layer’s font specified by its PostScript name. */ + font: string + + /** The text layer’s font size in pixels. */ + fontSize: number + + /** The paragraph justification for the text layer. */ + justification: ParagraphJustification + + /** The text layer’s spacing between lines. */ + leading: number + + /** The text layer’s stroke color. */ + strokeColor: ThreeDColorValue + + /** Indicates the rendering order for the fill and stroke of a text layer. */ + strokeOverFill: boolean + + /** The text layer’s stroke thickness. */ + strokeWidth: number + + /** The text layer’s spacing between characters. */ + tracking: number + + /** For box text, the pixel dimensions for the text bounds. */ + boxTextSize: [number, number] + + /** Restores the default character settings in the Character panel. */ + resetCharStyle(): void + + /** Restores the default paragraph settings in the Paragraph panel. */ + resetParagraphStyle(): void +} + +/** The TextLayer object represents a text layer within a composition. Create it using the LayerCollection object’s addText method. */ +declare class TextLayer extends AVLayer { + readonly source: null + + readonly text: _TextProperties + readonly sourceText: TextDocumentProperty +} + +declare class View { + readonly active: boolean + readonly options: ViewOptions + + setActive(): void +} + +/** The Viewer object represents a Composition, Layer, or Footage panel. */ +declare class Viewer { + /** The type of content in the viewer. */ + readonly type: ViewerType + + /** When true, the viewer is focused. */ + readonly active: boolean + + readonly views: View[] + + activeViewIndex: number + + /** When true, the viewer is at its maximized size. */ + maximized: boolean + + /** Moves the viewer to front and places focus on it. */ + setActive(): boolean +} + +declare class ViewOptions { + /** The state of the Channels menu */ + channels: ChannelType + + /** When true, checkerboards are on */ + checkerboards: boolean + + /** Current exposure setting */ + exposure: number + + /** The state of the Fast Previews menu */ + fastPreview: FastPreviewType + + /** When true, indicates guides are locked in the viewer. */ + guidesLocked: boolean + + /** When true, indicates layers snap to guides when dragged in the viewer. */ + guidesSnap: boolean + + /** When true, indicates guides are visible in the viewer. */ + guidesVisibility: boolean + + /** When true, indicates rulers are shown in the viewer. */ + rulers: boolean + + /** The viewer Zoom value */ + zoom: number +} + +/** + * Properties for Shortcuts + */ +declare interface _TransformGroup extends PropertyGroup { + readonly anchorPoint: TwoDOrThreeDProperty + readonly position: TwoDOrThreeDProperty + readonly xPosition: OneDProperty + readonly yPosition: OneDProperty + readonly zPosition: OneDProperty + readonly scale: TwoDOrThreeDProperty + readonly orientation: ThreeDProperty + readonly rotation: OneDProperty + readonly xRotation: OneDProperty + readonly yRotation: OneDProperty + readonly zRotation: OneDProperty + readonly opacity: OneDProperty + readonly pointOfInterest: ThreeDProperty +} + +declare interface _LightOptionsGroup extends PropertyGroup { + readonly intensity: OneDProperty + readonly color: ColorProperty + readonly coneAngle: OneDProperty + readonly coneFeather: OneDProperty + readonly falloff: OneDProperty + readonly radius: OneDProperty + readonly falloffDistance: OneDProperty + readonly castsShadows: OneDProperty + readonly shadowDarkness: OneDProperty + readonly shadowDiffusion: OneDProperty +} + +declare interface _CameraOptionsGroup extends PropertyGroup { + readonly zoom: OneDProperty + readonly depthOfField: OneDProperty + readonly focusDistance: OneDProperty + readonly aperture: OneDProperty + readonly blurLevel: OneDProperty + readonly irisShape: OneDProperty + readonly irisRotation: OneDProperty + readonly irisRoundness: OneDProperty + readonly irisAspectRatio: OneDProperty + readonly irisDiffractionFringe: OneDProperty + readonly highlightGain: OneDProperty + readonly highlightThreshold: OneDProperty + readonly highlightSaturation: OneDProperty +} + +declare interface _LayerStyles extends PropertyGroup { + readonly blendingOption: _BlendOptionsGroup + readonly dropShadow: _DropShadow + readonly innerShadow: _InnerShadow + readonly outerGlow: _OuterGlow + readonly innerGlow: _InnerGlow + readonly bevelAndEmboss: _BevelAndEmboss + readonly satin: _Satin + readonly colorOverlay: _ColorOverlay + readonly gradientOverlay: _GradientOverlay + readonly stroke: _Stroke +} + +declare interface _BlendOptionsGroup extends PropertyGroup { + readonly globalLightAngle: OneDProperty + readonly globalLightAltitude: OneDProperty + readonly advancedBlending: _AdvBlendGroup +} + +declare interface _AdvBlendGroup extends PropertyGroup { + readonly fillOpacity: OneDProperty + readonly red: OneDProperty + readonly green: OneDProperty + readonly blue: OneDProperty + readonly blendInteriorStylesAsGroup: OneDProperty + readonly useBlendRangesFromSource: OneDProperty +} + +declare interface _DropShadow extends PropertyGroup { + readonly blendMode: OneDProperty + readonly color: ColorProperty + readonly opacity: OneDProperty + readonly useGlobalLight: OneDProperty + readonly angle: OneDProperty + readonly distance: OneDProperty + readonly spread: OneDProperty + readonly size: OneDProperty + readonly noise: OneDProperty + readonly layerKnocksOutDropShadow: OneDProperty +} + +declare interface _InnerShadow extends PropertyGroup { + readonly blendMode: OneDProperty + readonly color: ColorProperty + readonly opacity: OneDProperty + readonly useGlobalLight: OneDProperty + readonly angle: OneDProperty + readonly distance: OneDProperty + readonly choke: OneDProperty + readonly size: OneDProperty + readonly noise: OneDProperty +} + +declare interface _OuterGlow extends PropertyGroup { + readonly blendMode: OneDProperty + readonly opacity: OneDProperty + readonly noise: OneDProperty + readonly colorType: OneDProperty + readonly color: ColorProperty + readonly colors: NoValueProperty + readonly gradientSmoothness: OneDProperty + readonly technique: OneDProperty + readonly spread: OneDProperty + readonly size: OneDProperty + readonly range: OneDProperty + readonly jitter: OneDProperty +} + +declare interface _InnerGlow extends PropertyGroup { + readonly blendMode: OneDProperty + readonly opacity: OneDProperty + readonly noise: OneDProperty + readonly colorType: OneDProperty + readonly color: ColorProperty + readonly colors: NoValueProperty + readonly gradientSmoothness: OneDProperty + readonly technique: OneDProperty + readonly source: OneDProperty + readonly choke: OneDProperty + readonly size: OneDProperty + readonly range: OneDProperty + readonly jitter: OneDProperty +} + +declare interface _BevelAndEmboss extends PropertyGroup { + readonly style: OneDProperty + readonly technique: OneDProperty + readonly depth: OneDProperty + readonly direction: OneDProperty + readonly size: OneDProperty + readonly soften: OneDProperty + readonly useGlobalLight: OneDProperty + readonly angle: OneDProperty + readonly altitude: OneDProperty + readonly highlightMode: OneDProperty + readonly highlightColor: ColorProperty + readonly highlightOpacity: OneDProperty + readonly shadowMode: OneDProperty + readonly shadowColor: ColorProperty + readonly shadowOpacity: OneDProperty +} + +declare interface _Satin extends PropertyGroup { + readonly blendMode: OneDProperty + readonly color: ColorProperty + readonly opacity: OneDProperty + readonly angle: OneDProperty + readonly distance: OneDProperty + readonly size: OneDProperty + readonly invert: OneDProperty +} + +declare interface _ColorOverlay extends PropertyGroup { + readonly blendMode: OneDProperty + readonly color: ColorProperty + readonly opacity: OneDProperty +} + +declare interface _GradientOverlay extends PropertyGroup { + readonly blendMode: OneDProperty + readonly opacity: OneDProperty + readonly colors: NoValueProperty + readonly gradientSmoothness: OneDProperty + readonly angle: OneDProperty + readonly style: OneDProperty + readonly reverse: OneDProperty + readonly alignWithLayer: OneDProperty + readonly scale: OneDProperty + readonly offset: TwoDProperty +} + +declare interface _Stroke extends PropertyGroup { + readonly color: ColorProperty + readonly blendMode: OneDProperty + readonly size: OneDProperty + readonly opacity: OneDProperty + readonly position: OneDProperty +} + +declare interface _GeometryOptionsGroup extends PropertyGroup { + readonly curvature: OneDProperty + readonly segments: OneDProperty + + readonly bevelStyle: OneDProperty + readonly bevelDepth: OneDProperty + readonly holeBevelDepth: OneDProperty + readonly extrusionDepth: OneDProperty +} + +declare interface _MaterialOptionsGroup extends PropertyGroup { + readonly castsShadows: OneDProperty + readonly lightTransmission: OneDProperty + readonly acceptsShadows: OneDProperty + readonly acceptsLights: OneDProperty + readonly appearsInReflections: OneDProperty + readonly ambient: OneDProperty + readonly diffuse: OneDProperty + readonly specularIntensity: OneDProperty + readonly specularShininess: OneDProperty + readonly metal: OneDProperty + readonly reflectionIntensity: OneDProperty + readonly reflectionSharpness: OneDProperty + readonly reflectionRolloff: OneDProperty + readonly transparency: OneDProperty + readonly transparencyRolloff: OneDProperty + readonly indexOfRefraction: OneDProperty +} + +declare interface _AudioGroup extends PropertyGroup { + readonly audioLevels: TwoDProperty +} + +declare interface _TextProperties extends PropertyGroup { + readonly sourceText: TextDocumentProperty + readonly pathOption: _TextPathOptions + readonly moreOption: _TextMoreOptions +} + +declare interface _TextPathOptions extends PropertyGroup { + readonly path: OneDProperty +} + +declare interface _TextMoreOptions extends PropertyGroup { + readonly anchorPointGrouping: OneDProperty + readonly groupingAlignment: TwoDProperty + readonly fillANdStroke: OneDProperty + readonly interCharacterBlending: OneDProperty +}