commit 75775e0dffea7681b3ad033d34a1b83a1ccf1097 Author: Micah Dowty Date: Mon Apr 13 07:05:42 2009 +0000 Initial revision diff --git a/README.txt b/README.txt new file mode 100644 index 0000000..c6ddfad --- /dev/null +++ b/README.txt @@ -0,0 +1,145 @@ +-------------------------------- +VMware SVGA Device Developer Kit +-------------------------------- + +The "VMware SVGA II" device is the virtual graphics card implemented +by all VMware virtualization products. It is a virtual PCI device, +which implements a basic 2D framebuffer, as well as 3D acceleration, +video overlay acceleration, and hardware cursor support. + +This is a package of documentation and example code for the VMware +SVGA device's programming model. Currently it consists of some very +basic documentation, and a collection of examples which illustrate the +more advanced features of the device. These examples are written to +run on the "virtual bare metal", without an operating system. + +This package is intended for educational purposes, or for people who +are developing 3D drivers. This code won't help you if you're writing +normal user-level apps that you'd like to run inside a virtual +machine. It's for driver authors, and it assumes a reasonable amount +of prior knowledge about graphics hardware. + +Requirements +------------ + +To compile the example code, you'll need a few basic open source tools: + + - A recent version of GCC. I use 4.2. Older versions may + require tweaking the Makefile.rules file slightly.) + - binutils + - GNU Make + - Python + +To run the examples, you'll need a recent version of VMware +Workstation, Player, or Fusion. Some of the examples will work on +older versions, but Workstation 6.5.x or Fusion 2.0.x is strongly +recommended. + +Contents +-------- + +* bin/ + + Precompiled binaries and .vmx files for all examples. These can be + loaded directly into VMware Workstation, Player, or Fusion. + +* doc/ + + Basic SVGA hardware documentation. This includes a text file with + information about the programming model, plus it includes a copy of + a WIOV paper which describes our 3D acceleration architecture. + +* lib/metalkit/ + + Metalkit is a very simple open source OS, which bootstraps the + examples and provides basic hardware support. + +* lib/refdriver/ + + The SVGA "Reference Driver". This is a sample implementation of a + driver for our device, which is used by the examples. It provides + device initialiation, an implementation of the low-level FIFO + protocol, and wrappers around common FIFO commands. + + If you're writing a driver for the VMware SVGA device, "svga.c" + from this directory is required reading. The FIFO protocol has + many subtle gotchas, and this source file is the only place + where they're publicly documented. + +* lib/vmware/ + + Header files which define VMware's protocols and virtual hardware. + The svga_reg.h and svga3d_reg.h files are (in places, at least) + commented with more information on the programming model. + + If you can't find specific documentation or an example on a feature, + this is the next place to look. This is also where to get a complete + list of the supported registers and commands. + +* lib/util/ + + Higher-level utilities built on top of the refdriver layer. This + directory won't contain any novel information about the virtual + hardware, but it does contain some higher-level abstractions used + by the examples, and these abstractions demonstrate some useful + idioms for programming the SVGA device. + +* examples/ + + Each example has a separate subdirectory. You can run "make" in the + top-level directory to compile all examples, or you can build them + individually. + + Many of the examples are self-explanatory, but some of them are + not. See the comments at the beginning of the 'main.c' file in each + example. + +Development +----------- + +This project isn't intended to be a one-time "code drop" from VMware. +Our intent is for the examples in this package to be maintained out in +the open. If we have a bugfix, or a new example that works on released +VMware products, we'll check it in directly to the public repository. + +For examples of not-yet-released features, we will be developing on an +internal branch. This branch will be merged to the public repository +shortly after the first release which has working versions of these +features. + +License +------- + +Except where noted in individual source files, the whole package is +Copyright (C) 1998-2009 VMware, Inc. It is released under the MIT +license: + + 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. + +Contact +------- + +This project is provided as-is, with no official support from +VMware. However, I will try to answer questions as time permits. +If you have questions or you'd like to submit a patch, feel free +to email me at: micah at vmware.com + +-- diff --git a/bin/2dmark.img b/bin/2dmark.img new file mode 100755 index 0000000..9c568cc Binary files /dev/null and b/bin/2dmark.img differ diff --git a/bin/2dmark.vmx b/bin/2dmark.vmx new file mode 100644 index 0000000..e0ddd3b --- /dev/null +++ b/bin/2dmark.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = 2dmark +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = 2dmark.img diff --git a/bin/blit-cube.img b/bin/blit-cube.img new file mode 100755 index 0000000..6cadfc2 Binary files /dev/null and b/bin/blit-cube.img differ diff --git a/bin/blit-cube.vmx b/bin/blit-cube.vmx new file mode 100644 index 0000000..fe5efb7 --- /dev/null +++ b/bin/blit-cube.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = blit-cube +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = blit-cube.img diff --git a/bin/bunnies.img b/bin/bunnies.img new file mode 100755 index 0000000..8700ca4 Binary files /dev/null and b/bin/bunnies.img differ diff --git a/bin/bunnies.vmx b/bin/bunnies.vmx new file mode 100644 index 0000000..45f9e72 --- /dev/null +++ b/bin/bunnies.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = bunnies +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = bunnies.img diff --git a/bin/cube.img b/bin/cube.img new file mode 100755 index 0000000..889779d Binary files /dev/null and b/bin/cube.img differ diff --git a/bin/cube.vmx b/bin/cube.vmx new file mode 100644 index 0000000..e7ebe6d --- /dev/null +++ b/bin/cube.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = cube +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = cube.img diff --git a/bin/cubemark.img b/bin/cubemark.img new file mode 100755 index 0000000..1f40828 Binary files /dev/null and b/bin/cubemark.img differ diff --git a/bin/cubemark.vmx b/bin/cubemark.vmx new file mode 100644 index 0000000..e1e43ec --- /dev/null +++ b/bin/cubemark.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = cubemark +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = cubemark.img diff --git a/bin/dynamic-vertex-stress.img b/bin/dynamic-vertex-stress.img new file mode 100755 index 0000000..2dab94a Binary files /dev/null and b/bin/dynamic-vertex-stress.img differ diff --git a/bin/dynamic-vertex-stress.vmx b/bin/dynamic-vertex-stress.vmx new file mode 100644 index 0000000..aeabcaa --- /dev/null +++ b/bin/dynamic-vertex-stress.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = dynamic-vertex-stress +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = dynamic-vertex-stress.img diff --git a/bin/dynamic-vertex.img b/bin/dynamic-vertex.img new file mode 100755 index 0000000..90bc432 Binary files /dev/null and b/bin/dynamic-vertex.img differ diff --git a/bin/dynamic-vertex.vmx b/bin/dynamic-vertex.vmx new file mode 100644 index 0000000..565c8f9 --- /dev/null +++ b/bin/dynamic-vertex.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = dynamic-vertex +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = dynamic-vertex.img diff --git a/bin/fence-stress.img b/bin/fence-stress.img new file mode 100755 index 0000000..d40098f Binary files /dev/null and b/bin/fence-stress.img differ diff --git a/bin/fence-stress.vmx b/bin/fence-stress.vmx new file mode 100644 index 0000000..5b6d44f --- /dev/null +++ b/bin/fence-stress.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = fence-stress +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = fence-stress.img diff --git a/bin/gmr-test.img b/bin/gmr-test.img new file mode 100755 index 0000000..feb5cf2 Binary files /dev/null and b/bin/gmr-test.img differ diff --git a/bin/gmr-test.vmx b/bin/gmr-test.vmx new file mode 100644 index 0000000..665426e --- /dev/null +++ b/bin/gmr-test.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 128 +displayname = gmr-test +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = gmr-test.img diff --git a/bin/half-float-test.img b/bin/half-float-test.img new file mode 100755 index 0000000..8c6515b Binary files /dev/null and b/bin/half-float-test.img differ diff --git a/bin/half-float-test.vmx b/bin/half-float-test.vmx new file mode 100644 index 0000000..ed5650f --- /dev/null +++ b/bin/half-float-test.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = half-float-test +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = half-float-test.img diff --git a/bin/pong.img b/bin/pong.img new file mode 100755 index 0000000..9468d67 Binary files /dev/null and b/bin/pong.img differ diff --git a/bin/pong.vmx b/bin/pong.vmx new file mode 100644 index 0000000..21a4753 --- /dev/null +++ b/bin/pong.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = pong +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = pong.img diff --git a/bin/presentReadback.img b/bin/presentReadback.img new file mode 100755 index 0000000..cb2ca7f Binary files /dev/null and b/bin/presentReadback.img differ diff --git a/bin/presentReadback.vmx b/bin/presentReadback.vmx new file mode 100644 index 0000000..25364c2 --- /dev/null +++ b/bin/presentReadback.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = presentReadback +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = presentReadback.img diff --git a/bin/simple-shaders.img b/bin/simple-shaders.img new file mode 100755 index 0000000..7b985b2 Binary files /dev/null and b/bin/simple-shaders.img differ diff --git a/bin/simple-shaders.vmx b/bin/simple-shaders.vmx new file mode 100644 index 0000000..d39a3fb --- /dev/null +++ b/bin/simple-shaders.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = simple-shaders +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = simple-shaders.img diff --git a/bin/simple_blit.img b/bin/simple_blit.img new file mode 100755 index 0000000..465278c Binary files /dev/null and b/bin/simple_blit.img differ diff --git a/bin/simple_blit.vmx b/bin/simple_blit.vmx new file mode 100644 index 0000000..3f9d2d5 --- /dev/null +++ b/bin/simple_blit.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = simple_blit +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = simple_blit.img diff --git a/bin/video-formats.img b/bin/video-formats.img new file mode 100755 index 0000000..23557f1 Binary files /dev/null and b/bin/video-formats.img differ diff --git a/bin/video-formats.vmx b/bin/video-formats.vmx new file mode 100644 index 0000000..088af47 --- /dev/null +++ b/bin/video-formats.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = video-formats +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = video-formats.img diff --git a/bin/video-sync.img b/bin/video-sync.img new file mode 100755 index 0000000..a8b3e66 Binary files /dev/null and b/bin/video-sync.img differ diff --git a/bin/video-sync.vmx b/bin/video-sync.vmx new file mode 100644 index 0000000..4efdcba --- /dev/null +++ b/bin/video-sync.vmx @@ -0,0 +1,9 @@ +config.version = 8 +virtualHW.version = 7 +memsize = 4 +displayname = video-sync +guestOS = other +mks.enable3d = TRUE +floppy0.startConnected = TRUE +floppy0.fileType = file +floppy0.fileName = video-sync.img diff --git a/doc/gpu-wiov.pdf b/doc/gpu-wiov.pdf new file mode 100644 index 0000000..d1a4a01 Binary files /dev/null and b/doc/gpu-wiov.pdf differ diff --git a/doc/svga_interface.txt b/doc/svga_interface.txt new file mode 100755 index 0000000..43fe457 --- /dev/null +++ b/doc/svga_interface.txt @@ -0,0 +1,872 @@ + +Copyright (C) 1999-2009 VMware, Inc. +All Rights Reserved + + + VMware SVGA Device Interface and Programming Model + -------------------------------------------------- + +Revision 3, 2009-04-12 + + +Table of Contents: + + 1. Introduction + 2. Examples and Reference Implementation + 3. Virtual Hardware Overview + 4. 2D Graphics Model + 5. 3D Graphics Model + 6. Overview of SVGA3D features + 7. Programming the VMware SVGA Device + +XXX - Todo +---------- + +This document does not yet describe the 3D hardware in great +detail. It is an architectural overview. See the accompanying sample +and reference code for details. + +Section (7) is biased toward describing much older features of the +virtual hardware. Many new capability flags and FIFO commands have +been added, and these are sparsely documented in svga_reg.h. + + +1. Introduction +---------------- + +This document describes the virtual graphics adapter interface which +is implemented by VMware products. The VMware SVGA Device is a virtual +PCI video card. It does not directly correspond to any real video +card, but it serves as an interface for exposing accelerated graphics +capabilities to virtual machines in a hardware-independent way. + +In its simplest form, the VMware SVGA Device can be used as a basic +memory-mapped framebuffer. In this mode, the main advantage of +VMware's SVGA device over alternatives like VBE is that the virtual +machine can explicitly indicate which ares of the screen have changed +by sending update rectangles through the device's command FIFO. This +allows VMware products to avoid reading areas of the framebuffer which +haven't been modified by the virtualized OS. + +The VMware SVGA device also supports several advanced features: + + - Accelerated video overlays + - 2D acceleration + - Synchronization primitives + - DMA transfers + - Device-independent 3D acceleration, with shaders + - Multiple monitors + - Desktop resizing + + +2. Examples and Reference Implementation +----------------------------------------- + +This document is not yet complete, in that it doesn't describe the +entire SVGA device interface in detail. It is an architectural +overview of the entire device, as well as an introduction to a few +basic areas of programming for the device. + +For deeper details, see the attached example code. The "examples" +directory contains individual example applications which show various +features in action. The "lib" directory contains support code for the +example applications. + +Some of this support code is designed to act as a reference +implementation. For example, the process of writing to the command +FIFO safely and efficiently is very complicated. The attached +reference implementation is a must-read for anyone attempting to write +their own driver for the SVGA device. + +For simplicity and OS-neutrality, all examples compile to floppy disk +images which execute "on the bare metal" in a VMware virtual +machine. There are no run-time dependencies. At compile-time, most of +the examples only require a GNU toolchain (GCC and Binutils). Some of +the examples require Python at compile-time. + +Each example will generate a .vmx virtual machine configuration file +which can be used to boot it in VMware Workstation or Fusion. + +The included example code focuses on advanced features of the SVGA +device, such as 3D and synchronization primitives. There are also a +couple examples that demonstrate 3D graphics and video overlays. + +For more examples of basic 2D usage, the Xorg driver is also a good +reference. + +Header files and reference implementation files in 'lib': + + * svga_reg.h + + SVGA register definitions, SVGA capabilities, and FIFO command + definitions. + + * svga_overlay.h + + Definitions required to use the SVGA device's hardware video overlay + support. + + * svga_escape.h + + A list of definitions for the SVGA Escape commands, a way to send + arbitrary data over the SVGA command FIFO. Escapes are used for video + overlays, for vendor-specific extensions to the SVGA device, and for + various tools internal to VMware. + + * svga3d_reg.h + + Defines the SVGA3D protocol, the set of FIFO commands used for hardware + 3D acceleration. + + * svga3d_shaderdefs.h + + Defines the bytecode format for SVGA3D shaders. This is used for + accelerated 3D with programmable vertex and pixel pipelines. + + * svga.c + + Reference implementation of low-level SVGA device functionality. + This contains sample code for device initialization, safe and + efficient FIFO writes, and various synchronization primitives. + + * svga3d.c + + Reference implementation for the SVGA3D protocol. This file + uses the FIFO primitives in svga.c to speak the SVGA3D protocol. + Includes a lot of in-line documentation. + + * svga3dutil.c + + This is a collection of high-level utilities which provide usage + examples for svga3d.c and svga.c, and which demonstrate common + SVGA3D idioms. + + +3. Virtual Hardware Overview +----------------------------- + +The VMware SVGA Device is a virtual PCI device. It provides the +following low-level hardware features, which are used to implement +various feature-specific protocols for 2D, 3D, and video overlays: + + * I/O space, at PCI Base Address Register 0 (BAR0) + +There are only a few I/O ports. Besides the ports used to access +registers, these are generally either legacy features, or they are for +I/O which is performance critical but may have side-effects. (Such as +clearing IRQs after they occur.) + + * Registers, accessed indirectly via INDEX and VALUE I/O ports. + +The device's register space is the principal method by which +configuration takes place. In general, registers are for actions which +may have side-effects and which take place synchronously with the CPU. + + * Guest Framebuffer (BAR1) + +The SVGA device itself owns a variable amount of "framebuffer" memory, +up to a maximum of 128MB. This memory size is fixed at power-on. The +memory exists outside of the virtual machine's "main memory", and it's +mapped into PCI space via BAR1. The size of this framebuffer may be +determined either by probing BAR1 in typical PCI fashion, or by +reading SVGA_REG_FB_SIZE. + +The beginning of framebuffer memory is reserved for the 2D +framebuffer. The rest of framebuffer memory may be used as buffer +space for DMA operations. + + * Command FIFO (BAR2) + +The SVGA device can be thought of as a co-processor which executes +commands asynchronously with the virtual machine's CPU. To enqueue +commands for this coprocessor, the SVGA device uses another +device-owned memory region which is mapped into PCI space. + +The command FIFO is usually much smaller than the framebuffer. While +the framebuffer usually ranges from 4MB to 128MB, the FIFO ranges in +size from 256KB to 2MB. Like the framebuffer, the FIFO size is fixed +at power-on. The FIFO is mapped via PCI BAR2. + + * FIFO Registers + +The beginning of FIFO memory is reserved for a set of "registers". +Some of these are used to implement the FIFO command queueing +protocol, but many of these are used for other purposes. The main +difference between FIFO registers and non-FIFO registers is that FIFO +registers are backed by normal RAM whereas non-FIFO registers require +I/O operations to access. This means that only non-FIFO registers can +have side-effects, but FIFO registers are much more efficient when +side-effects aren't necessary. + +The FIFO register space is variable-sized. The driver is responsible +for partitioning FIFO memory into register space and command space. + + * Synchronization Primitives + +Conceptually, the part of the SVGA device which processes FIFO +commands can be thought of as a coprocessor or a separate thread of +execution. The virtual machine may need to: + + - Wake up the FIFO processor when it's sleeping, to ensure that + new commands are processed with low-latency. (FIFO doorbell) + + - Check whether a previously enqueued FIFO command has been + processed. (FIFO fence) + + - Wait until the FIFO processor has passed a particular + command. (Sync to fence) + + - Wait until more space is available in the FIFO. (Wait for + FIFO progress) + + * Interrupts (Workstation 6.5 virtual machines and later only) + +On virtual machines which have been upgrade to Workstation 6.5 virtual +hardware, the SVGA device provides an IRQ which can be used to notify +the virtual machine when a synchronization event occurs. This allows +implementing operations like "Sync to fence" without interfering with +a virtual machine's ability to multitask. + +On older virtual hardware versions, the SVGA device only supports a +"legacy sync" mechanism, in which a particular register access has the +side-effect of waiting for host FIFO processing to occur. This older +mechanism completely halts the virtual machine's CPU while the FIFO is +being processed. + + * Physical VRAM + +The VMware SVGA device provides management of physical VRAM resources +via "surface objects", however physical VRAM is never directly visible +to the virtual machine. Physical VRAM can only be accessed via DMA +transfers. + +Note that framebuffer memory is simply a convenient place to put DMA +buffers. Even if a virtual machine only has 16MB of framebuffer memory +allocated to it, it could be using gigabytes of physical VRAM if that +memory is available to the physical GPU. + + * DMA engine + +The VMware SVGA device can asynchronously transfer surface data +between phyiscal VRAM and guest-visible memory. This guest-visible +memory could be part of framebuffer memory, or it could be part of +guest system memory. + +The DMA engine uses a "Guest Pointer" abstraction to refer to any +guest-visible memory. Guest pointer consist of an offset and a Guest +Memory Region (GMR) ID. There is a pre-defined GMR which refers to +framebuffer memory. The virtual machine can create additional GMRs to +refer to regions of system memory which may or may not be physically +contiguous. + + +4. 2D Graphics Model +--------------------- + +Conceptually, the 2D portion of the VMware SVGA device is a compositor +which displays a user-visible image composed of several planes. From +back to front, those planes are: + + - The 2D framebuffer + - 3D regions + - Video overlay regions + - The virtual hardware mouse cursor ("cursor bypass") + - The physical hardware mouse cursor ("host cursor") + +It is important to note that host-executed 2D graphics commands do not +necessarily modify the 2D framebuffer, they may write directly to the +physical display or display window. Like a physical video card, the +VMware SVGA device's framebuffer is never modified by a mouse cursor +or video overlay. Unlike a physical video card, however, 3D display +regions in the VMware SVGA device may or may not modify the 2D +framebuffer. + +The following basic 2D operations are available: + + * Update + +Redraw a portion of the screen, using data from the 2D +framebuffer. Any update rectangles are subtracted from the set of +on-screen 3D regions, so 2D updates always overwrite 3D regions. 2D +updates still appear behind video overlays and mouse cursors. + +An update command must be sent any time the driver wishes to make +changes to the 2D framebuffer available. The user-visible screen is +not guaranteed to update unless an explicit update command is sent. + +Also note that the SVGA device is allowed to read the 2D framebuffer +even if no update command has been sent. For example, if the virtual +machine is running in a partially obscured window, the SVGA device +will read the 2D framebuffer immediately when the window is uncovered +in order to draw the newly visible portion of the VM's window. + +This means that the virtual machine must not treat the 2D framebuffer +as a back-buffer. It must contain a completely rendered image at all +times. + +There is not yet any way to synchronize updates with the vertical +refresh. Current VMware SVGA devices may suffer from tearing +artifacts. + + * 2D acceleration operations + +These include fills, copies, and various kinds of blits. All 2D +acceleration operations happen directly on the user-visible screen, +not in 2D framebuffer memory. + +Use of the 2D acceleration operations is encouraged only in very +limited circumstances. For example, when moving or scrolling +windows. Mixing accelerated and unaccelerated 2D operations is +difficult to implement properly, and incurs a significant +synchronization penalty. + + * Present 3D surface + +"Present" is an SVGA3D command which copies a finished image from an +SVGA3D surface to the user-visible screen. It may or may not update +the 2D framebuffer in the process. + +Present commands effectively create a 3D overlay on top of part of the +2D framebuffer. This overlay can be overwritten by Update commands or +by other Present commands. + +Present is the only way in which the 2D and 3D portions of the VMware +SVGA device interact. + + * Video overlay operations + +The SVGA device defines a group of virtual "video overlay units", each +of which can color-convert, scale, and display a frame of YUV video +overlayed with the 2D framebuffer. Overlay units each have a set of +virtual registers which are configured using the commands in +svga_overlay.h. + + * Virtual mouse cursor operations + +The virtual mouse cursor is an overlay which shows the SVGA device's +current cursor image at a particular location. It may not be +hardware-accelerated by the physical machine, and it does not +necessarily correspond with the position of the user's physical mouse. + +There are three "Cursor Bypass" mechanisms by which the virtual +machine can set the position of the virtual mouse cursor. Cursor +bypass 1 did not follow the overlay model described above, and it has +long been obsolete. Cursor bypass 2 and 3 are functionally equivalent, +except that cursor bypass 2 operates via non-FIFO registers and cursor +bypass 3 operates via FIFO registers. If cursor bypass 3 is supported +(SVGA_FIFO_CAP_CURSOR_BYPASS_3), it should be used instead of cursor +bypass 2. + +For all forms of cursor bypass, the cursor image is defined by +SVGA_CMD_DEFINE_CURSOR. + + * Physical mouse cursor operations + +The virtual machine does not define the location of the physical mouse +cursor, but it can define the cursor image and hide/show it. It does +so using the SVGA_CMD_DEFINE_CURSOR and SVGA_CMD_DISPLAY_CURSOR +commands. + + +5. 3D Graphics Model +--------------------- + +The VMware SVGA device supports hardware-independent accelerated 3D +graphics via the "SVGA3D" protocol. This is a set of extended FIFO +commands. SVGA3D utilizes the same underlying FIFO and synchronization +primitives as the 2D portion of the SVGA device, but the 2D and 3D +portions of the device are largely independent. + +The SVGA3D protocol is relatively high-level. The device is +responsible for tracking render state among multiple contexts, for +managing physical VRAM, and for implementing both fixed-function and +programmable vertex and pixel processing. + +The SVGA3D protocol is designed to be vendor- and API-neutral, but for +convenience it has been designed to be compatible with Direct3D in +most places. The shader bytecode is fully binary-compatible with +Direct3D bytecode, and most render states are identical to those +defined by Direct3D. + +Note that the VMware SVGA device still supports 3D acceleration on all +operating systems that VMware products run on. Internally, hardware +accelerated 3D is implemented on top of the OpenGL graphics API. + +To summarize the SVGA3D device's design: + + * SVGA3D is an extension to the VMware SVGA device's command FIFO + protocol. + + * In some ways it looks like a graphics API: + + o SVGA3D device manages all physical VRAM allocation. + o High-level render states, relatively high-level shader bytecode. + + * In some ways it looks like hardware: + + o All commands are executed asynchronously. + o Driver must track memory ownership, schedule DMA transfers. + o All physical VRAM represented by generic "Surface" objects + + * Supports both fixed-function and programmable vertex and fragment + pipelines. + + +6. Overview of SVGA3D features +------------------------------ + + * Capabilities + + o Extensible key/value pair list describes the SVGA3D device's + capabilities. + + o Number of texture image units, max texture size, number of + lights, texture formats, etc. + + * Surfaces + + o Formats: 8-bit RGB/RGBA, 16-bit RGB/RGBA, depth, packed + depth/stencil, luminance/alpha, DXT compressed, signed, floating + point, etc. + + o Supports 3D (volume) textures, cube maps,. + + o Surfaces are also used as vertex and index buffers. + + o Generic DMA blits between surfaces and system memory or + offscreen "virtual VRAM". + + o Generic surface-to-surface blits, with and without scaling. + + * Contexts + + o Surfaces are global, other objects are per-context, render + states are per-context. + + o Commands to create/delete contexts. + + * Render State (Mostly Direct3D-style) + + o Matrices + + o Texture stage states: Filtering, combiners, LOD, gamma + correction, etc. + + o Stencil, depth, culling, blending, lighting, materials, etc. + + * Render Targets + + o Few restrictions on which surfaces can be used as render + targets (More lenient than OpenGL FBOs) + + o Supports depth, stencil, color buffer(s) + + * Present + + o The "present" operation is a blit from an SVGA3D surface back + to the user-visible screen. + + o May or may not update the guest-visible 2D framebuffer. + + * Occlusion queries + + o Submitted via FIFO commands + + o Results returned asynchronously: a results structure is filled + in via DMA. + + * Shaders + + o We define an "SVGA3D bytecode", which is binary-compatible + with Direct3D's shader bytecode. + + o SVGA3D may define extensions to the bytecode format in the future. + + * Drawing + + o A single generic "draw primitives" command performs a list of + rendering operations from a list of vertex buffers. + + o Index buffer is optional. + + o Similar to drawing with OpenGL vertex arrays and VBOs. + + +7. Programming the VMware SVGA Device +------------------------------------- + +1. Reading/writing a register: + + The SVGA registers are addressed by an index/value pair of 32 bit + registers in the IO address space. + + The 0710 VMware SVGA chipset (PCI device ID PCI_DEVICE_ID_VMWARE_SVGA) has + its index and value ports hardcoded at: + + index: SVGA_LEGACY_BASE_PORT + 4 * SVGA_INDEX_PORT + value: SVGA_LEGACY_BASE_PORT + 4 * SVGA_VALUE_PORT + + The 0405 VMware SVGA chipset (PCI device ID PCI_DEVICE_ID_VMWARE_SVGA2) + determines its index and value ports as a function of the first base + address register in its PCI configuration space as: + + index: + SVGA_INDEX_PORT + value: + SVGA_VALUE_PORT + + To read a register: + Set the index port to the index of the register, using a dword OUT + Do a dword IN from the value port + + To write a register: + Set the index port to the index of the register, using a dword OUT + Do a dword OUT to the value port + + Example, setting the width to 1024: + + mov eax, SVGA_REG_WIDTH + mov edx, + out dx, eax + mov eax, 1024 + mov edx, + out dx, eax + +2. Initialization + + Check the version number + loop: + Write into SVGA_REG_ID the maximum SVGA_ID_* the driver supports. + Read from SVGA_REG_ID. + Check if it is the value you wrote. + If yes, VMware SVGA device supports it + If no, decrement SVGA_ID_* and goto loop + This algorithm converges. + + Map the frame buffer and the command FIFO + Read SVGA_REG_FB_START, SVGA_REG_FB_SIZE, SVGA_REG_MEM_START, + SVGA_REG_MEM_SIZE. + Map the frame buffer (FB) and the FIFO memory (MEM). + + This step must occur after the version negotiation above, since by + default the device is in a legacy-compatibility mode in which there + is no command FIFO. + + Get the device capabilities and frame buffer dimensions + Read SVGA_REG_CAPABILITIES, SVGA_REG_MAX_WIDTH, SVGA_REG_MAX_HEIGHT, + and SVGA_REG_HOST_BITS_PER_PIXEL / SVGA_REG_BITS_PER_PIXEL. + + Note: The capabilities can and do change without the PCI device ID + changing or the SVGA_REG_ID changing. A driver should always check + the capabilities register when loading before expecting any + capabilities-determined feature to be available. See below for a list + of capabilities as of this writing. + + Note: If SVGA_CAP_8BIT_EMULATION is not set, then it is possible that + SVGA_REG_HOST_BITS_PER_PIXEL does not exist and + SVGA_REG_BITS_PER_PIXEL should be read instead. + + Optional: Report the Guest Operating System + Write SVGA_REG_GUEST_ID with the appropriate value from . + While not required in any way, this is useful information for the + virtual machine to have available for reporting and sanity checking + purposes. + + SetMode + Set SVGA_REG_WIDTH, SVGA_REG_HEIGHT, SVGA_REG_BITS_PER_PIXEL + Read SVGA_REG_FB_OFFSET + (SVGA_REG_FB_OFFSET is the offset from SVGA_REG_FB_START of the + visible portion of the frame buffer) + Read SVGA_REG_BYTES_PER_LINE, SVGA_REG_DEPTH, SVGA_REG_PSEUDOCOLOR, + SVGA_REG_RED_MASK, SVGA_REG_GREEN_MASK, SVGA_REG_BLUE_MASK + + Note: SVGA_REG_BITS_PER_PIXEL is readonly if + SVGA_CAP_8BIT_EMULATION is not set in the capabilities register. Even + if it is set, values other than 8 and SVGA_REG_HOST_BITS_PER_PIXEL + will be ignored. + + Enable SVGA + Set SVGA_REG_ENABLE to 1 + (to disable SVGA, set SVGA_REG_ENABLE to 0. Setting SVGA_REG_ENABLE + to 0 also enables VGA.) + + Initialize the command FIFO + The FIFO is exclusively dword (32-bit) aligned. The first four + dwords define the portion of the MEM area that is used for the + command FIFO. These are values are all in byte offsets from the + start of the MEM area. + + A minimum sized FIFO would have these values: + mem[SVGA_FIFO_MIN] = 16; + mem[SVGA_FIFO_MAX] = 16 + (10 * 1024); + mem[SVGA_FIFO_NEXT_CMD] = 16; + mem[SVGA_FIFO_STOP] = 16; + + Various addresses near the beginning of the FIFO are defined as + "FIFO registers" with special meaning. If the driver wishes to + take advantage of the special meaning of these addresses rather + than using them as part of the command FIFO, the driver must + reserve space for these registers when setting up the FIFO. + Typically the driver will set MIN to SVGA_FIFO_NUM_REGS*4. + + Report the guest 3D version + If your driver supports 3D, write the latest supported 3D + version (SVGA3D_HWVERSION_CURRENT) to the + SVGA_FIFO_GUEST_3D_HWVERSION register. + + Enable the command FIFO + Set SVGA_REG_CONFIG_DONE to 1 after these values have been set. + + Note: Setting SVGA_REG_CONFIG_DONE to 0 will stop the device from + reading the FIFO until it is reinitialized and SVGA_REG_CONFIG_DONE is + set to 1 again. + +3. SVGA command FIFO protocol + + The FIFO is empty when SVGA_FIFO_NEXT_CMD == SVGA_FIFO_STOP. The + driver writes commands to the FIFO starting at the offset specified + by SVGA_FIFO_NEXT_CMD, and then increments SVGA_FIFO_NEXT_CMD. + + The FIFO is full when SVGA_FIFO_NEXT_CMD is one word before SVGA_FIFO_STOP. + + When the FIFO becomes full, the driver must wait for space to become + available. It can do this via various methods (busy-wait, legacy sync) + but the preferred method is to use the FIFO_PROGRESS interrupt. + + The SVGA device does not guarantee that all of FIFO memory is valid + at all times. The device is free to discard the contents of any memory + which is not part of the active portion of the FIFO. The active portion + of the FIFO is defined as the region with valid commands (starting + at SVGA_FIFO_STOP and ending at SVGA_FIFO_NEXT_CMD) plus the reserved + portion of the FIFO. + + By default, only one word of memory is 'reserved'. If the FIFO supports + the SVGA_FIFO_CAP_RESERVE capability, the device supports reserving + driver-defined amounts of memory. If both the device and driver support + this operation, it's possible to write multiple words of data between + updates to the FIFO control registers. + + The simplest way to use the FIFO is to write one word at a time, but the + highest-performance way to use the FIFO is to reserve enough space for + an entire command or group of commands, write the commands directly to + FIFO memory, then "commit" the command(s) by updating the FIFO control + registers. + + A reference implementation of this reserve/commit algorithm is provided + in svga.c, in SVGA_FIFOReserve() and SVGA_FIFOCommit(). In the common + case, this algorithm lets drivers assemble commands directly in FIFO + memory without any additional copies or memory allocation. + +4. Synchronization + + The primary synchronization primitive defined by the SVGA device is + "Sync to fence". A "fence" is a numbered marker inserted into the FIFO + command stream. The driver can insert fences at any time, and efficiently + determine the value of the last fence processed by the device. + + "Sync to fence" is the process of waiting for a particular fence to be + processed. This may be important for several reasons: + + - Flow control. For interactivity, it is important to put an upper + limit on the amount by which the device may lag the application. + + - Waiting for DMA completion. If the driver needs to recycle a DMA + buffer or complete a DMA operation synchronously, it must sync + to a fence which occurred after the DMA operation in the command + stream. + + - Waiting for accelerated 2D operations. If a 2D driver needs to + write to a portion of the framebuffer which is affected by + an accelerated blit, it should sync to a fence which occurred + after the blit. + + There are multiple possible implementations of Sync to Fence, depending + on the capabilities of the SVGA device you're driving. Very old versions + of the VMware SVGA device did not support fences at all. For these + devices, you must always perform a "legacy sync". New virtual machines + with Workstation 6.5 virtual hardware or later support an IRQ-driven + sync operation. For all other versions of the SVGA device, the best + approach is a hybrid in which you synchronously use the SYNC/BUSY + registers to process the FIFO until the sync has passed. + + FIFO synchronization is a very complex topic, and it isn't covered fully + by this document. Please see the synchronization-related comments in + svga_reg.h, and the reference implementation of these primitives in + svga.c. + +5. Cursor + + When SVGA_CAP_CURSOR is set, hardware cursor support is available. In + practice, SVGA_CAP_CURSOR will only be set when SVGA_CAP_CURSOR_BYPASS is + also set and drivers supporting a hardware cursor should only worry about + SVGA_CAP_CURSOR_BYPASS and only use the FIFO to define the cursor. See + below for more information. + +6. Pseudocolor + + When the read-only register SVGA_REG_PSEUDOCOLOR is 1, the device is in a + colormapped mode whose index width and color width are both SVGA_REG_DEPTH. + Thus far, 8 is the only depth at which pseudocolor is ever used. + + In pseudocolor, the colormap is programmed by writing to the SVGA palette + registers. These start at SVGA_PALETTE_BASE and are interpreted as + follows: + + SVGA_PALETTE_BASE + 3*n - The nth red component + SVGA_PALETTE_BASE + 3*n + 1 - The nth green component + SVGA_PALETTE_BASE + 3*n + 2 - The nth blue component + + And n ranges from 0 to ((1<text; + + /* Hack to make the string shorter by cutting off "FPS" label. */ + fps[7] = '\0'; + + Console_Format(" %s", fps); + } + + Console_WriteString("\n"); + } + + Console_WriteString("\nBenchmark complete. Results are " + "also available in the VMX log."); +} + + +/* + * main -- + * + * Initialization and results reporting. + */ + +int +main(void) +{ + Intr_Init(); + Intr_SetFaultHandlers(SVGA_DefaultFaultHandler); + ConsoleVGA_Init(); + SVGA_Init(); + + runBenchmark(); + + SVGA_Disable(); + VMBackdoor_VGAScreenshot(); + + return 0; +} diff --git a/examples/Makefile b/examples/Makefile new file mode 100644 index 0000000..d71bb9a --- /dev/null +++ b/examples/Makefile @@ -0,0 +1,11 @@ +SUBDIRS = $(subst /Makefile,,$(wildcard */Makefile)) + +.PHONY: subdirs clean $(SUBDIRS) + +subdirs: $(SUBDIRS) + +$(SUBDIRS): + $(MAKE) -C $@ + +clean: + for dir in $(SUBDIRS); do $(MAKE) -C $$dir clean; done diff --git a/examples/blit-cube/Makefile b/examples/blit-cube/Makefile new file mode 100644 index 0000000..e9a03ab --- /dev/null +++ b/examples/blit-cube/Makefile @@ -0,0 +1,6 @@ +TARGET = blit-cube.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/blit-cube/main.c b/examples/blit-cube/main.c new file mode 100644 index 0000000..552d78c --- /dev/null +++ b/examples/blit-cube/main.c @@ -0,0 +1,349 @@ +/* + * SVGA3D example: Spinning cube, with various blit operations. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" + +typedef struct { + float position[3]; + float texcoord[2]; + float color[3]; +} MyVertex; + +static const MyVertex vertexData[] = { + { {-1, -1, -1}, { 0, 0 }, {0.5, 0.5, 0.5} }, /* -X */ + { {-1, -1, 1}, { 0, 1 }, {1.0, 1.0, 1.0} }, + { {-1, 1, -1}, { 1, 0 }, {0.5, 0.5, 0.5} }, + { {-1, 1, 1}, { 1, 1 }, {1.0, 1.0, 1.0} }, + + { { 1, -1, -1}, { 0, 0 }, {0.5, 0.5, 0.5} }, /* +X */ + { { 1, -1, 1}, { 0, 1 }, {1.0, 1.0, 1.0} }, + { { 1, 1, -1}, { 1, 0 }, {0.5, 0.5, 0.5} }, + { { 1, 1, 1}, { 1, 1 }, {1.0, 1.0, 1.0} }, + + { {-1, -1, -1}, { 0, 0 }, {0.5, 0.5, 0.5} }, /* -Y */ + { {-1, -1, 1}, { 0, 1 }, {1.0, 1.0, 1.0} }, + { { 1, -1, -1}, { 1, 0 }, {0.5, 0.5, 0.5} }, + { { 1, -1, 1}, { 1, 1 }, {1.0, 1.0, 1.0} }, + + { {-1, 1, -1}, { 0, 0 }, {0.5, 0.5, 0.5} }, /* +Y */ + { {-1, 1, 1}, { 0, 1 }, {1.0, 1.0, 1.0} }, + { { 1, 1, -1}, { 1, 0 }, {0.5, 0.5, 0.5} }, + { { 1, 1, 1}, { 1, 1 }, {1.0, 1.0, 1.0} }, + + { {-1, -1, -1}, { 0, 0 }, {0.5, 0.5, 0.5} }, /* -Z */ + { {-1, 1, -1}, { 0, 1 }, {1.0, 1.0, 1.0} }, + { { 1, -1, -1}, { 1, 0 }, {0.5, 0.5, 0.5} }, + { { 1, 1, -1}, { 1, 1 }, {1.0, 1.0, 1.0} }, + + { {-1, -1, 1}, { 0, 0 }, {0.5, 0.5, 0.5} }, /* +Z */ + { {-1, 1, 1}, { 0, 1 }, {1.0, 1.0, 1.0} }, + { { 1, -1, 1}, { 1, 0 }, {0.5, 0.5, 0.5} }, + { { 1, 1, 1}, { 1, 1 }, {1.0, 1.0, 1.0} }, +}; + +#define QUAD(a,b,c,d) a, b, d, d, c, a + +static const uint16 indexData[] = { + QUAD(0, 1, 2, 3), // -X + QUAD(4, 5, 6, 7), // +X + QUAD(8, 9, 10, 11), // -Y + QUAD(12, 13, 14, 15), // +Y + QUAD(16, 17, 18, 19), // -Z + QUAD(20, 21, 22, 23), // +Z +}; + +#undef QUAD + +const uint32 numTriangles = sizeof indexData / sizeof indexData[0] / 3; +uint32 vertexSid, indexSid, textureSid; +Matrix perspectiveMat; +FPSCounterState gFPS; +VMMousePacket lastMouseState; + +/* + * render -- + * + * Set up render state, and draw our cube scene from static index + * and vertex buffers. + * + * This render state only needs to be set each frame because + * SVGA3DText_Draw() changes it. + */ + +void +render(void) +{ + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + static Matrix view; + + Matrix_Copy(view, gIdentityMatrix); + Matrix_Scale(view, 0.5, 0.5, 0.5, 1.0); + + if (lastMouseState.buttons & VMMOUSE_LEFT_BUTTON) { + Matrix_RotateX(view, lastMouseState.y * 0.0001); + Matrix_RotateY(view, lastMouseState.x * -0.0001); + } else { + Matrix_RotateX(view, 30.0 * M_PI / 180.0); + Matrix_RotateY(view, gFPS.frame * 0.01f); + } + + Matrix_Translate(view, 0, 0, 2); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, view); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, gIdentityMatrix); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); + + SVGA3D_BeginSetRenderState(CID, &rs, 4); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 10); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = textureSid; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_MODULATE; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_TEXTURE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_COLORARG2; + ts[3].value = SVGA3D_TA_DIFFUSE; + + ts[4].stage = 0; + ts[4].name = SVGA3D_TS_ALPHAOP; + ts[4].value = SVGA3D_TC_SELECTARG1; + + ts[5].stage = 0; + ts[5].name = SVGA3D_TS_ALPHAARG1; + ts[5].value = SVGA3D_TA_DIFFUSE; + + ts[6].stage = 0; + ts[6].name = SVGA3D_TS_MINFILTER; + ts[6].value = SVGA3D_TEX_FILTER_LINEAR; + + ts[7].stage = 0; + ts[7].name = SVGA3D_TS_MAGFILTER; + ts[7].value = SVGA3D_TEX_FILTER_LINEAR; + + ts[8].stage = 0; + ts[8].name = SVGA3D_TS_ADDRESSU; + ts[8].value = SVGA3D_TEX_ADDRESS_WRAP; + + ts[9].stage = 0; + ts[9].name = SVGA3D_TS_ADDRESSV; + ts[9].value = SVGA3D_TEX_ADDRESS_WRAP; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginDrawPrimitives(CID, &decls, 3, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = sizeof(MyVertex); + decls[0].array.offset = offsetof(MyVertex, position); + + decls[1].identity.type = SVGA3D_DECLTYPE_FLOAT2; + decls[1].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD; + decls[1].array.surfaceId = vertexSid; + decls[1].array.stride = sizeof(MyVertex); + decls[1].array.offset = offsetof(MyVertex, texcoord); + + decls[2].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[2].identity.usage = SVGA3D_DECLUSAGE_COLOR; + decls[2].array.surfaceId = vertexSid; + decls[2].array.stride = sizeof(MyVertex); + decls[2].array.offset = offsetof(MyVertex, color); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = numTriangles; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(uint16); + ranges[0].indexWidth = sizeof(uint16); + } + SVGA_FIFOCommitAll(); +} + + +/* + * defineCheckerboard -- + * + * Create a new checkerboard texture of the specified size. + */ + +uint32 +defineCheckerboard(uint32 width, uint32 height) +{ + uint32 *buffer; + int i, j; + SVGAGuestPtr gPtr; + uint32 size = width * height * sizeof *buffer; + + uint32 sid = SVGA3DUtil_DefineSurface2D(width, height, SVGA3D_A8R8G8B8); + + buffer = SVGA3DUtil_AllocDMABuffer(size, &gPtr); + + for (j = 0; j < height; j++) { + for (i = 0; i < width; i++) { + *buffer = (i + j) & 1 ? 0xFFFFFFFF : 0x00000000; + buffer++; + } + } + + SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, width, height); + + return sid; +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + uint32 texSize = 256; + uint32 checkerSid; + + SVGA3DUtil_InitFullscreen(CID, 1024, 768); + SVGA3DText_Init(); + + vertexSid = SVGA3DUtil_DefineStaticBuffer(vertexData, sizeof vertexData); + indexSid = SVGA3DUtil_DefineStaticBuffer(indexData, sizeof indexData); + + textureSid = SVGA3DUtil_DefineSurface2D(texSize, texSize, SVGA3D_A8R8G8B8); + checkerSid = defineCheckerboard(texSize, texSize); + + Matrix_Perspective(perspectiveMat, 45.0f, + gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); + + while (1) { + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format( + "VMware SVGA3D Example:\n" + "Spinning cube blitter test: \n" + " - SurfaceStretchBlt from back buffer to cube texture\n" + " - SurfaceCopy from cube texture to back buffer\n" + " - Checkerboard pattern in bottom left\n" + "\n" + "Verify performance and correctness with all blitter implementations.\n" + "\n" + "%s", + gFPS.text); + + SVGA3DText_Update(); + VMBackdoor_VGAScreenshot(); + } + + while (VMBackdoor_MouseGetPacket(&lastMouseState)); + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x6666dd, 1.0f, 0); + render(); + SVGA3DText_Draw(); + + /* Surface copy from cube texture to the lower-right corner of the back buffer */ + { + SVGA3dSurfaceImageId src = { textureSid }; + SVGA3dCopyBox *boxes; + + SVGA3D_BeginSurfaceCopy(&src, &gFullscreen.colorImage, &boxes, 1); + boxes[0].w = texSize; + boxes[0].h = texSize; + boxes[0].d = 1; + boxes[0].x = gFullscreen.screen.w - texSize; + boxes[0].y = gFullscreen.screen.h - texSize; + + SVGA_FIFOCommitAll(); + } + + /* + * We're displaying the checkerboard texture in the lower-left + * corner of the back buffer. This tests for subpixel alignment + * errors within the blitter. + * + * Draw the top half with a regular blit, bottom half with a + * stretch blit. You should see a contiguous checkerboard. + */ + { + SVGA3dSurfaceImageId src = { checkerSid }; + SVGA3dCopyBox *boxes; + SVGA3dBox boxSrc = { 0 }; + SVGA3dBox boxDest = { 0 }; + + SVGA3D_BeginSurfaceCopy(&src, &gFullscreen.colorImage, &boxes, 1); + boxes[0].w = texSize; + boxes[0].h = texSize/2; + boxes[0].d = 1; + boxes[0].y = gFullscreen.screen.h - texSize; + SVGA_FIFOCommitAll(); + + boxSrc.w = texSize; + boxSrc.y = texSize/2; + boxSrc.h = texSize/2; + boxSrc.d = 1; + + boxDest.w = texSize; + boxDest.y = gFullscreen.screen.h - texSize/2; + boxDest.h = texSize/2; + boxDest.d = 1; + + SVGA3D_SurfaceStretchBlt(&src, &gFullscreen.colorImage, &boxSrc, &boxDest, + SVGA3D_STRETCH_BLT_LINEAR); + } + + SVGA3DUtil_PresentFullscreen(); + + /* Stretch blit from back buffer to cube */ + { + SVGA3dSurfaceImageId dest = { textureSid }; + SVGA3dBox boxSrc = { 0 }; + SVGA3dBox boxDest = { 0 }; + + boxSrc.w = gFullscreen.screen.w; + boxSrc.h = gFullscreen.screen.h; + boxSrc.d = 1; + + boxDest.w = texSize; + boxDest.h = texSize; + boxDest.d = 1; + + SVGA3D_SurfaceStretchBlt(&gFullscreen.colorImage, &dest, &boxSrc, &boxDest, + SVGA3D_STRETCH_BLT_LINEAR); + } + } + + return 0; +} diff --git a/examples/bunnies/Makefile b/examples/bunnies/Makefile new file mode 100644 index 0000000..a43f6d6 --- /dev/null +++ b/examples/bunnies/Makefile @@ -0,0 +1,6 @@ +TARGET = bunnies.img + +APP_SOURCES = main.c bunny.ib.z.data.o bunny.vb.z.data.o + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/bunnies/bunny.ib b/examples/bunnies/bunny.ib new file mode 100644 index 0000000..b33df3e Binary files /dev/null and b/examples/bunnies/bunny.ib differ diff --git a/examples/bunnies/bunny.vb b/examples/bunnies/bunny.vb new file mode 100644 index 0000000..09cc5cc Binary files /dev/null and b/examples/bunnies/bunny.vb differ diff --git a/examples/bunnies/main.c b/examples/bunnies/main.c new file mode 100644 index 0000000..66693bc --- /dev/null +++ b/examples/bunnies/main.c @@ -0,0 +1,202 @@ +/* + * SVGA3D example: Bunnies. + * + * This example loads the famous Stanford Bunny model, and draws many + * copies of it. This demonstrates large models and fixed-function + * lighting. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" + +DECLARE_DATAFILE(ibFile, bunny_ib_z); +DECLARE_DATAFILE(vbFile, bunny_vb_z); + +uint32 vertexSid, indexSid; +uint32 ibSize, vbSize; +Matrix perspectiveMat; +FPSCounterState gFPS; + + +/* + * setupFrame -- + * + * Set up render state that we load once per frame (because + * SVGA3DText clobbered it) and perform matrix calculations that we + * only need once per frame. + */ + +void +setupFrame(void) +{ + static Matrix world; + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + + static const SVGA3dLightData light = { + .type = SVGA3D_LIGHTTYPE_POINT, + .inWorldSpace = TRUE, + .diffuse = { 10.0f, 10.0f, 10.0f, 1.0f }, + .ambient = { 0.05f, 0.05f, 0.1f, 1.0f }, + .position = { -5.0f, 5.0f, 0.0f, 1.0f }, + .attenuation0 = 1.0f, + .attenuation1 = 0.0f, + .attenuation2 = 0.0f, + }; + + static const SVGA3dMaterial mat = { + .diffuse = { 1.0f, 0.9f, 0.9f, 1.0f }, + .ambient = { 1.0f, 1.0f, 1.0f, 1.0f }, + }; + + Matrix_Copy(world, gIdentityMatrix); + Matrix_Scale(world, 10, 10, 10, 1); + Matrix_RotateY(world, gFPS.frame * 0.001f); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, world); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); + + SVGA3D_SetMaterial(CID, SVGA3D_FACE_FRONT_BACK, &mat); + SVGA3D_SetLightData(CID, 0, &light); + SVGA3D_SetLightEnabled(CID, 0, TRUE); + + SVGA3D_BeginSetRenderState(CID, &rs, 8); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + + rs[4].state = SVGA3D_RS_LIGHTINGENABLE; + rs[4].uintValue = TRUE; + + rs[5].state = SVGA3D_RS_VERTEXMATERIALENABLE; + rs[5].uintValue = FALSE; + + rs[6].state = SVGA3D_RS_CULLMODE; + rs[6].uintValue = SVGA3D_FACE_FRONT; + + rs[7].state = SVGA3D_RS_AMBIENT; + rs[7].uintValue = 0x00000000; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 4); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = SVGA3D_INVALID_ID; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_SELECTARG1; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_DIFFUSE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_ALPHAARG1; + ts[3].value = SVGA3D_TA_DIFFUSE; + } + SVGA_FIFOCommitAll(); +} + + +/* + * drawMesh -- + * + * Draw our bunny mesh at a particular position. + */ + +void +drawMesh(float posX, float posY, float posZ) +{ + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + static Matrix view; + + Matrix_Copy(view, gIdentityMatrix); + Matrix_Translate(view, posX, posY, posZ); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, view); + + SVGA3D_BeginDrawPrimitives(CID, &decls, 2, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = 6 * sizeof(float); + + decls[1].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[1].identity.usage = SVGA3D_DECLUSAGE_NORMAL; + decls[1].array.surfaceId = vertexSid; + decls[1].array.stride = 6 * sizeof(float); + decls[1].array.offset = 3 * sizeof(float); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = ibSize / sizeof(uint32) / 3; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(uint32); + ranges[0].indexWidth = sizeof(uint32); + } + SVGA_FIFOCommitAll(); +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DText_Init(); + + vertexSid = SVGA3DUtil_LoadCompressedBuffer(vbFile, &vbSize); + indexSid = SVGA3DUtil_LoadCompressedBuffer(ibFile, &ibSize); + + Matrix_Perspective(perspectiveMat, 45.0f, + gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); + + while (1) { + int i; + + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "Bunnies: Drawing 4 copies of the Stanford Bunny," + " at 65K triangles each.\n\n%s", + gFPS.text); + SVGA3DText_Update(); + } + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x113366, 1.0f, 0); + + setupFrame(); + + for (i = 0; i < 4; i++) { + drawMesh(0.8 - i * 1.0f, -1, 3 + i * 1.0f); + } + + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + } + + return 0; +} diff --git a/examples/cube/Makefile b/examples/cube/Makefile new file mode 100644 index 0000000..fc1e4b1 --- /dev/null +++ b/examples/cube/Makefile @@ -0,0 +1,6 @@ +TARGET = cube.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/cube/main.c b/examples/cube/main.c new file mode 100644 index 0000000..c77ed97 --- /dev/null +++ b/examples/cube/main.c @@ -0,0 +1,191 @@ +/* + * SVGA3D example: Spinning cube, with static vertex/index buffers. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" +#include "keyboard.h" +#include "apm.h" + +typedef struct { + float position[3]; + uint32 color; +} MyVertex; + +static const MyVertex vertexData[] = { + { {-1, -1, -1}, 0xFFFFFF }, + { {-1, -1, 1}, 0xFFFF00 }, + { {-1, 1, -1}, 0xFF00FF }, + { {-1, 1, 1}, 0xFF0000 }, + { { 1, -1, -1}, 0x00FFFF }, + { { 1, -1, 1}, 0x00FF00 }, + { { 1, 1, -1}, 0x0000FF }, + { { 1, 1, 1}, 0x000000 }, +}; + +#define QUAD(a,b,c,d) a, b, d, d, c, a + +static const uint16 indexData[] = { + QUAD(0,1,2,3), // -X + QUAD(4,5,6,7), // +X + QUAD(0,1,4,5), // -Y + QUAD(2,3,6,7), // +Y + QUAD(0,2,4,6), // -Z + QUAD(1,3,5,7), // +Z +}; + +#undef QUAD + +const uint32 numTriangles = sizeof indexData / sizeof indexData[0] / 3; +uint32 vertexSid, indexSid; +Matrix perspectiveMat; +FPSCounterState gFPS; +VMMousePacket lastMouseState; + +/* + * render -- + * + * Set up render state, and draw our cube scene from static index + * and vertex buffers. + * + * This render state only needs to be set each frame because + * SVGA3DText_Draw() changes it. + */ + +void +render(void) +{ + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + static Matrix view; + + Matrix_Copy(view, gIdentityMatrix); + Matrix_Scale(view, 0.5, 0.5, 0.5, 1.0); + + if (lastMouseState.buttons & VMMOUSE_LEFT_BUTTON) { + Matrix_RotateX(view, lastMouseState.y * 0.0001); + Matrix_RotateY(view, lastMouseState.x * -0.0001); + } else { + Matrix_RotateX(view, 30.0 * M_PI / 180.0); + Matrix_RotateY(view, gFPS.frame * 0.01f); + } + + Matrix_Translate(view, 0, 0, 3); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, view); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, gIdentityMatrix); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); + + SVGA3D_BeginSetRenderState(CID, &rs, 4); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 4); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = SVGA3D_INVALID_ID; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_SELECTARG1; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_DIFFUSE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_ALPHAARG1; + ts[3].value = SVGA3D_TA_DIFFUSE; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginDrawPrimitives(CID, &decls, 2, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = sizeof(MyVertex); + decls[0].array.offset = offsetof(MyVertex, position); + + decls[1].identity.type = SVGA3D_DECLTYPE_D3DCOLOR; + decls[1].identity.usage = SVGA3D_DECLUSAGE_COLOR; + decls[1].array.surfaceId = vertexSid; + decls[1].array.stride = sizeof(MyVertex); + decls[1].array.offset = offsetof(MyVertex, color); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = numTriangles; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(uint16); + ranges[0].indexWidth = sizeof(uint16); + } + SVGA_FIFOCommitAll(); +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DText_Init(); + Keyboard_Init(); + APM_Init(); + + vertexSid = SVGA3DUtil_DefineStaticBuffer(vertexData, sizeof vertexData); + indexSid = SVGA3DUtil_DefineStaticBuffer(indexData, sizeof indexData); + + Matrix_Perspective(perspectiveMat, 45.0f, + gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); + + while (!Keyboard_IsKeyPressed(KEY_ESCAPE)) { + + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "Spinning cube with static vertex and index buffer.\n" + "Drag with left mouse button to rotate.\n" + "Press ESC to exit.\n" + "\n%s", + gFPS.text); + SVGA3DText_Update(); + VMBackdoor_VGAScreenshot(); + } + + while (VMBackdoor_MouseGetPacket(&lastMouseState)); + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x113366, 1.0f, 0); + render(); + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + } + + APM_SetPowerState(POWER_OFF); + return 0; +} diff --git a/examples/cubemark/Makefile b/examples/cubemark/Makefile new file mode 100644 index 0000000..e32d859 --- /dev/null +++ b/examples/cubemark/Makefile @@ -0,0 +1,16 @@ +TARGET = cubemark.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules + +.PHONY: shaders + +shaders: cube_vs.h cube_ps.h + +cube_vs.h: cube.fx + wine fxc.exe /T vs_2_0 /E MyVertexShader /Fh cube_vs.h cube.fx + +cube_ps.h: cube.fx + wine fxc.exe /T ps_2_0 /E MyPixelShader /Fh cube_ps.h cube.fx diff --git a/examples/cubemark/cube.fx b/examples/cubemark/cube.fx new file mode 100644 index 0000000..e6e92ec --- /dev/null +++ b/examples/cubemark/cube.fx @@ -0,0 +1,36 @@ +float4x4 matView, matProj; + +struct VS_Input +{ + float4 Pos : POSITION; + float4 Color : COLOR0; +}; + +struct VS_Output +{ + float4 Pos : POSITION; + float4 Color : COLOR0; +}; + + +VS_Output +MyVertexShader(VS_Input Input) +{ + VS_Output Output; + + Output.Pos = mul(mul(Input.Pos, matView), matProj); + Output.Color = Input.Color; + + return Output; +} + +struct PS_Input +{ + float4 Color : COLOR0; +}; + +float4 +MyPixelShader(PS_Input Input) : COLOR +{ + return Input.Color; +} diff --git a/examples/cubemark/cube_ps.h b/examples/cubemark/cube_ps.h new file mode 100644 index 0000000..124a4e5 --- /dev/null +++ b/examples/cubemark/cube_ps.h @@ -0,0 +1,21 @@ +#if 0 +// +// Generated by Microsoft (R) D3DX9 Shader Compiler +// +// fxc /T ps_2_0 /E MyPixelShader /Fh cube_ps.h cube.fx +// + ps_2_0 + dcl v0 + mov oC0, v0 + +// approximately 1 instruction slot used +#endif + +const DWORD g_ps20_MyPixelShader[] = +{ + 0xffff0200, 0x0013fffe, 0x42415443, 0x0000001c, 0x00000023, 0xffff0200, + 0x00000000, 0x00000000, 0x20000100, 0x0000001c, 0x325f7370, 0x4d00305f, + 0x6f726369, 0x74666f73, 0x29522820, 0x44334420, 0x53203958, 0x65646168, + 0x6f432072, 0x6c69706d, 0x00207265, 0x0200001f, 0x80000000, 0x900f0000, + 0x02000001, 0x800f0800, 0x90e40000, 0x0000ffff +}; diff --git a/examples/cubemark/cube_vs.h b/examples/cubemark/cube_vs.h new file mode 100644 index 0000000..9900b68 --- /dev/null +++ b/examples/cubemark/cube_vs.h @@ -0,0 +1,54 @@ +#if 0 +// +// Generated by Microsoft (R) D3DX9 Shader Compiler +// +// fxc /T vs_2_0 /E MyVertexShader /Fh cube_vs.h cube.fx +// +// +// Parameters: +// +// float4x4 matProj; +// float4x4 matView; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// matView c0 4 +// matProj c4 4 +// + + vs_2_0 + dcl_position v0 + dcl_color v1 + dp4 r0.x, v0, c0 + dp4 r0.y, v0, c1 + dp4 r0.z, v0, c2 + dp4 r0.w, v0, c3 + dp4 oPos.x, r0, c4 + dp4 oPos.y, r0, c5 + dp4 oPos.z, r0, c6 + dp4 oPos.w, r0, c7 + mov oD0, v1 + +// approximately 9 instruction slots used +#endif + +const DWORD g_vs20_MyVertexShader[] = +{ + 0xfffe0200, 0x0025fffe, 0x42415443, 0x0000001c, 0x0000006b, 0xfffe0200, + 0x00000002, 0x0000001c, 0x20000100, 0x00000064, 0x00000044, 0x00040002, + 0x00000004, 0x0000004c, 0x00000000, 0x0000005c, 0x00000002, 0x00000004, + 0x0000004c, 0x00000000, 0x5074616d, 0x006a6f72, 0x00030003, 0x00040004, + 0x00000001, 0x00000000, 0x5674616d, 0x00776569, 0x325f7376, 0x4d00305f, + 0x6f726369, 0x74666f73, 0x29522820, 0x44334420, 0x53203958, 0x65646168, + 0x6f432072, 0x6c69706d, 0x00207265, 0x0200001f, 0x80000000, 0x900f0000, + 0x0200001f, 0x8000000a, 0x900f0001, 0x03000009, 0x80010000, 0x90e40000, + 0xa0e40000, 0x03000009, 0x80020000, 0x90e40000, 0xa0e40001, 0x03000009, + 0x80040000, 0x90e40000, 0xa0e40002, 0x03000009, 0x80080000, 0x90e40000, + 0xa0e40003, 0x03000009, 0xc0010000, 0x80e40000, 0xa0e40004, 0x03000009, + 0xc0020000, 0x80e40000, 0xa0e40005, 0x03000009, 0xc0040000, 0x80e40000, + 0xa0e40006, 0x03000009, 0xc0080000, 0x80e40000, 0xa0e40007, 0x02000001, + 0xd00f0000, 0x90e40001, 0x0000ffff +}; diff --git a/examples/cubemark/main.c b/examples/cubemark/main.c new file mode 100644 index 0000000..de1868e --- /dev/null +++ b/examples/cubemark/main.c @@ -0,0 +1,235 @@ +/* + * Cubemark, a microbenchmark which renders a very large number of + * very simple objects. This stresses the throughput of the SVGA3D + * command pipeline and API layers. + * + * Half of the cubes are rendered using fixed-function, and half of + * them are rendered using shaders. This helps hilight any performance + * differences between per-draw setup for FFP vs. for shaders. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" + +typedef uint32 DWORD; +#include "cube_vs.h" +#include "cube_ps.h" + +#define MY_VSHADER_ID 0 +#define MY_PSHADER_ID 0 + +#define CONST_MAT_VIEW 0 +#define CONST_MAT_PROJ 4 + +typedef struct { + float position[3]; + uint32 color; +} MyVertex; + +/* + * Two colors for the cubes, so we can see them rotate more easily. + */ +#define COLOR1 0x8080FF +#define COLOR2 0x000080 + +/* + * This defines the grid spacing, as well as the total number of cubes we draw. + */ +#define GRID_X_MIN (-35) +#define GRID_X_MAX 35 +#define GRID_Y_MIN (-20) +#define GRID_Y_MAX 20 +#define GRID_STEP 2 + +static const MyVertex vertexData[] = { + { {-1, -1, -1}, COLOR1 }, + { {-1, -1, 1}, COLOR1 }, + { {-1, 1, -1}, COLOR1 }, + { {-1, 1, 1}, COLOR1 }, + { { 1, -1, -1}, COLOR2 }, + { { 1, -1, 1}, COLOR2 }, + { { 1, 1, -1}, COLOR2 }, + { { 1, 1, 1}, COLOR2 }, +}; + +#define QUAD(a,b,c,d) a, b, d, d, c, a + +static const uint16 indexData[] = { + QUAD(0,1,2,3), // -X + QUAD(4,5,6,7), // +X + QUAD(0,1,4,5), // -Y + QUAD(2,3,6,7), // +Y + QUAD(0,2,4,6), // -Z + QUAD(1,3,5,7), // +Z +}; + +#undef QUAD + +const uint32 numTriangles = sizeof indexData / sizeof indexData[0] / 3; +uint32 vertexSid, indexSid; +Matrix perspectiveMat; +FPSCounterState gFPS; +VMMousePacket lastMouseState; + +/* + * render -- + * + * Set up common render state and matrices, then enter a loop + * drawing many cubes with individual draw commands. + * + * This render state only needs to be set each frame because + * SVGA3DText_Draw() changes it. + */ + +void +render(void) +{ + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + static Matrix view, instance; + float x, y; + Bool useShaders = FALSE; + + Matrix_Copy(view, gIdentityMatrix); + Matrix_Scale(view, 0.5, 0.5, 0.5, 1.0); + Matrix_RotateX(view, 30.0 * M_PI / 180.0); + Matrix_RotateY(view, gFPS.frame * 0.1f); + Matrix_Translate(view, 0, 0, 75); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, gIdentityMatrix); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); + + SVGA3DUtil_SetShaderConstMatrix(CID, CONST_MAT_PROJ, + SVGA3D_SHADERTYPE_VS, perspectiveMat); + + SVGA3D_BeginSetRenderState(CID, &rs, 4); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 4); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = SVGA3D_INVALID_ID; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_SELECTARG1; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_DIFFUSE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_ALPHAARG1; + ts[3].value = SVGA3D_TA_DIFFUSE; + } + SVGA_FIFOCommitAll(); + + for (x = GRID_X_MIN; x <= GRID_X_MAX; x += GRID_STEP) { + for (y = GRID_Y_MIN; y <= GRID_Y_MAX; y += GRID_STEP) { + + Matrix_Copy(instance, view); + Matrix_Translate(instance, x, y, 0); + + if (useShaders) { + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, MY_VSHADER_ID); + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, MY_PSHADER_ID); + SVGA3DUtil_SetShaderConstMatrix(CID, CONST_MAT_VIEW, + SVGA3D_SHADERTYPE_VS, instance); + } else { + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, SVGA3D_INVALID_ID); + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, SVGA3D_INVALID_ID); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, instance); + } + + SVGA3D_BeginDrawPrimitives(CID, &decls, 2, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = sizeof(MyVertex); + decls[0].array.offset = offsetof(MyVertex, position); + + decls[1].identity.type = SVGA3D_DECLTYPE_D3DCOLOR; + decls[1].identity.usage = SVGA3D_DECLUSAGE_COLOR; + decls[1].array.surfaceId = vertexSid; + decls[1].array.stride = sizeof(MyVertex); + decls[1].array.offset = offsetof(MyVertex, color); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = numTriangles; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(uint16); + ranges[0].indexWidth = sizeof(uint16); + } + SVGA_FIFOCommitAll(); + } + + useShaders = !useShaders; + } + + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, SVGA3D_INVALID_ID); + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, SVGA3D_INVALID_ID); +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DText_Init(); + + vertexSid = SVGA3DUtil_DefineStaticBuffer(vertexData, sizeof vertexData); + indexSid = SVGA3DUtil_DefineStaticBuffer(indexData, sizeof indexData); + + SVGA3D_DefineShader(CID, MY_VSHADER_ID, SVGA3D_SHADERTYPE_VS, + g_vs20_MyVertexShader, sizeof g_vs20_MyVertexShader); + SVGA3D_DefineShader(CID, MY_PSHADER_ID, SVGA3D_SHADERTYPE_PS, + g_ps20_MyPixelShader, sizeof g_ps20_MyPixelShader); + + Matrix_Perspective(perspectiveMat, 45.0f, + gSVGA.width / (float)gSVGA.height, 10.0f, 100.0f); + + while (1) { + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("Cubemark microbenchmark\n\n%s", gFPS.text); + SVGA3DText_Update(); + VMBackdoor_VGAScreenshot(); + } + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x000000, 1.0f, 0); + render(); + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + } + + return 0; +} diff --git a/examples/dynamic-vertex-stress/Makefile b/examples/dynamic-vertex-stress/Makefile new file mode 100644 index 0000000..5efd262 --- /dev/null +++ b/examples/dynamic-vertex-stress/Makefile @@ -0,0 +1,6 @@ +TARGET = dynamic-vertex-stress.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/dynamic-vertex-stress/main.c b/examples/dynamic-vertex-stress/main.c new file mode 100644 index 0000000..4690a2f --- /dev/null +++ b/examples/dynamic-vertex-stress/main.c @@ -0,0 +1,353 @@ +/* + * SVGA3D example: Dynamic vertex buffer stress-test. + * + * This example is a performance stress-test for dynamic vertex + * buffers, and specifically for performing DMA on buffers which may + * still be in use by the GPU. + * + * Like the original dynamic-vertex test, we compute an animated + * function on the guest CPU and upload it via a vertex buffer before + * each draw. To simulate the stresses involved in dealing with apps + * that render in immediate-mode, however, this test breaks the vertex + * buffer up into very small pieces which are all DMA'ed and rendered + * individually. + * + * If the SVGA3D implementation has any bottlenecks related to reusing + * vertex buffers that are still in use by the physical GPU, this test + * will expose them. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" + +#define MESH_WIDTH 256 /* 64 kilovertices, 1.5MB */ +#define MESH_HEIGHT 256 + +#define MESH_NUM_VERTICES (MESH_WIDTH * MESH_HEIGHT) +#define MESH_NUM_QUADS ((MESH_WIDTH-1) * (MESH_HEIGHT-1)) +#define MESH_NUM_TRIANGLES (MESH_NUM_QUADS * 2) +#define MESH_NUM_INDICES (MESH_NUM_TRIANGLES * 3) +#define MESH_NUM_BYTES (MESH_NUM_VERTICES * sizeof(MyVertex)) +#define TRIANGLES_PER_ROW ((MESH_WIDTH-1) * 2) +#define INDICES_PER_ROW (TRIANGLES_PER_ROW * 3) + +#define MESH_ELEMENT(x, y) (MESH_WIDTH * (y) + (x)) + +typedef struct { + float position[3]; + float color[3]; +} MyVertex; + +typedef uint16 IndexType; +DMAPool vertexDMA; +uint32 vertexSid, indexSid; +Matrix perspectiveMat; +FPSCounterState gFPS; + + +/* + * setupFrame -- + * + * Set up render state that we load once per frame (because + * SVGA3DText clobbered it) and perform matrix calculations that we + * only need once per frame. + */ + +void +setupFrame(void) +{ + static Matrix world; + static Matrix view; + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + + Matrix_Copy(view, gIdentityMatrix); + Matrix_Translate(view, 0, 0, 3); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, view); + + Matrix_Copy(world, gIdentityMatrix); + Matrix_RotateX(world, -60.0 * PI_OVER_180); + Matrix_RotateY(world, gFPS.frame * 0.01f); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, world); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); + + SVGA3D_BeginSetRenderState(CID, &rs, 4); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 4); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = SVGA3D_INVALID_ID; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_SELECTARG1; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_DIFFUSE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_ALPHAARG1; + ts[3].value = SVGA3D_TA_DIFFUSE; + } + SVGA_FIFOCommitAll(); +} + + +/* + * updateVertices -- + * + * Calculate new vertices, writing them directly into an available + * DMA buffer. Returns a DMAPoolBuffer which contains the vertex + * data for an entire frame. + */ + +DMAPoolBuffer * +updateVertices(float red, float green, float blue, float phase, float offset) +{ + DMAPoolBuffer *dma; + MyVertex *vert; + int x, y; + float t = gFPS.frame * 0.1f + phase; + + dma = SVGA3DUtil_DMAPoolGetBuffer(&vertexDMA); + vert = (MyVertex*) dma->buffer; + + for (y = 0; y < MESH_HEIGHT; y++) { + for (x = 0; x < MESH_WIDTH; x++) { + + float fx = x * (2.0 / MESH_WIDTH) - 1.0; + float fy = y * (2.0 / MESH_HEIGHT) - 1.0; + float fxo = fx + offset; + float dist = fxo * fxo + fy * fy; + float z = sinf(dist * 8.0 + t) / (1 + dist * 10.0); + + vert->position[0] = fx; + vert->position[1] = fy; + vert->position[2] = z; + + vert->color[0] = red - z; + vert->color[1] = green - z; + vert->color[2] = blue - z; + + vert++; + } + } + + return dma; +} + + +/* + * createIndexBuffer -- + * + * Create a static index buffer that renders our vertices as a 2D + * mesh. For simplicity, we use a triangle list rather than a + * triangle strip. + */ +uint32 +createIndexBuffer(void) +{ + IndexType *indexBuffer; + const uint32 bufferSize = MESH_NUM_INDICES * sizeof *indexBuffer; + SVGAGuestPtr gPtr; + uint32 sid; + int x, y; + + sid = SVGA3DUtil_DefineSurface2D(bufferSize, 1, SVGA3D_BUFFER); + indexBuffer = SVGA3DUtil_AllocDMABuffer(bufferSize, &gPtr); + + for (y = 0; y < (MESH_HEIGHT - 1); y++) { + for (x = 0; x < (MESH_WIDTH - 1); x++) { + + indexBuffer[0] = MESH_ELEMENT(x, y ); + indexBuffer[1] = MESH_ELEMENT(x+1, y ); + indexBuffer[2] = MESH_ELEMENT(x+1, y+1); + + indexBuffer[3] = MESH_ELEMENT(x+1, y+1); + indexBuffer[4] = MESH_ELEMENT(x, y+1); + indexBuffer[5] = MESH_ELEMENT(x, y ); + + indexBuffer += 6; + } + } + + SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, bufferSize, 1); + + return sid; +} + + + +/* + * trashBuffer -- + * + * Upload zeroes to the vertex buffer, to make any future DMA errors obvious. + */ + +void trashBuffer(void) +{ + DMAPoolBuffer *dma = SVGA3DUtil_DMAPoolGetBuffer(&vertexDMA); + + memset(dma->buffer, 0, MESH_NUM_BYTES); + + SVGA3DUtil_SurfaceDMA2D(vertexSid, &dma->ptr, + SVGA3D_WRITE_HOST_VRAM, MESH_NUM_BYTES, 1); + + SVGA3DUtil_AsyncCall((AsyncCallFn) SVGA3DUtil_DMAPoolFreeBuffer, dma); +} + + +/* + * uploadRow -- + * + * Upload the vertex data for one row of the mesh. + */ + +void uploadRow(int row, DMAPoolBuffer *dma) +{ + SVGA3dCopyBox *boxes; + SVGA3dGuestImage guestImage; + SVGA3dSurfaceImageId hostImage = { vertexSid }; + + guestImage.ptr = dma->ptr; + guestImage.pitch = 0; + + SVGA3D_BeginSurfaceDMA(&guestImage, &hostImage, SVGA3D_WRITE_HOST_VRAM, &boxes, 1); + { + boxes[0].x = MESH_HEIGHT * sizeof(MyVertex) * row; + boxes[0].w = MESH_WIDTH * sizeof(MyVertex); + boxes[0].srcx = boxes[0].x; + boxes[0].h = 1; + boxes[0].d = 1; + } + SVGA_FIFOCommitAll(); +} + + +/* + * drawStrip -- + * + * Draw all triangles between 'row' and 'row+1'. + */ + +void +drawStrip(int row) +{ + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + + SVGA3D_BeginDrawPrimitives(CID, &decls, 2, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = sizeof(MyVertex); + decls[0].array.offset = offsetof(MyVertex, position); + + decls[1].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[1].identity.usage = SVGA3D_DECLUSAGE_COLOR; + decls[1].array.surfaceId = vertexSid; + decls[1].array.stride = sizeof(MyVertex); + decls[1].array.offset = offsetof(MyVertex, color); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = TRIANGLES_PER_ROW; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(IndexType); + ranges[0].indexArray.offset = sizeof(IndexType) * INDICES_PER_ROW * row; + ranges[0].indexWidth = sizeof(IndexType); + } + SVGA_FIFOCommitAll(); +} + + +/* + * render -- + * + * Calculate, upload, and draw the entire mesh. + */ + +void +render(void) +{ + DMAPoolBuffer *dma = updateVertices(0.2, 0.8, 0.2, 0, 0); + int row; + + trashBuffer(); + + uploadRow(0, dma); + + for (row = 1; row < MESH_HEIGHT; row++) { + uploadRow(row, dma); + drawStrip(row - 1); + } + + SVGA3DUtil_AsyncCall((AsyncCallFn) SVGA3DUtil_DMAPoolFreeBuffer, dma); +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DText_Init(); + + vertexSid = SVGA3DUtil_DefineSurface2D(MESH_NUM_BYTES, 1, SVGA3D_BUFFER); + indexSid = createIndexBuffer(); + + SVGA3DUtil_AllocDMAPool(&vertexDMA, MESH_NUM_BYTES, 16); + + Matrix_Perspective(perspectiveMat, 45.0f, + gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); + + while (1) { + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "Dynamic vertex buffer stress-test.\n" + "This example performs a separate DMA and " + "Draw for each row of the mesh.\n\n%s", + gFPS.text); + SVGA3DText_Update(); + } + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x113366, 1.0f, 0); + + setupFrame(); + render(); + + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + } + + return 0; +} diff --git a/examples/dynamic-vertex/Makefile b/examples/dynamic-vertex/Makefile new file mode 100644 index 0000000..cb8436d --- /dev/null +++ b/examples/dynamic-vertex/Makefile @@ -0,0 +1,6 @@ +TARGET = dynamic-vertex.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/dynamic-vertex/main.c b/examples/dynamic-vertex/main.c new file mode 100644 index 0000000..eb22803 --- /dev/null +++ b/examples/dynamic-vertex/main.c @@ -0,0 +1,279 @@ +/* + * SVGA3D example: Dynamic vertex buffers. + * + * This example shows how to efficiently stream vertex data to the + * GPU, using multiple DMA buffers but a single vertex buffer. We + * allocate DMA buffers from a pool every time we want to draw a new + * dynamic mesh, then we asynchronously recycle those buffers after + * the DMA transfer has completed. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" + +#define MESH_WIDTH 128 +#define MESH_HEIGHT 128 + +#define MESH_NUM_VERTICES (MESH_WIDTH * MESH_HEIGHT) +#define MESH_NUM_QUADS ((MESH_WIDTH-1) * (MESH_HEIGHT-1)) +#define MESH_NUM_TRIANGLES (MESH_NUM_QUADS * 2) +#define MESH_NUM_INDICES (MESH_NUM_TRIANGLES * 3) + +#define MESH_ELEMENT(x, y) (MESH_WIDTH * (y) + (x)) + +typedef struct { + float position[3]; + float color[3]; +} MyVertex; + +typedef uint16 IndexType; +DMAPool vertexDMA; +uint32 vertexSid, indexSid; +Matrix perspectiveMat; +FPSCounterState gFPS; + + +/* + * setupFrame -- + * + * Set up render state that we load once per frame (because + * SVGA3DText clobbered it) and perform matrix calculations that we + * only need once per frame. + */ + +void +setupFrame(void) +{ + static Matrix world; + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + + Matrix_Copy(world, gIdentityMatrix); + Matrix_RotateX(world, -60.0 * PI_OVER_180); + Matrix_RotateY(world, gFPS.frame * 0.001f); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, world); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); + + SVGA3D_BeginSetRenderState(CID, &rs, 4); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 4); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = SVGA3D_INVALID_ID; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_SELECTARG1; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_DIFFUSE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_ALPHAARG1; + ts[3].value = SVGA3D_TA_DIFFUSE; + } + SVGA_FIFOCommitAll(); +} + + +/* + * updateVertices -- + * + * Calculate new vertices, writing them directly into an available + * DMA buffer. Asynchronously begin DMA and recycle the buffer. + */ + +void +updateVertices(float red, float green, float blue, float phase, float offset) +{ + DMAPoolBuffer *dma; + MyVertex *vert; + int x, y; + float t = gFPS.frame * 0.01f + phase; + + dma = SVGA3DUtil_DMAPoolGetBuffer(&vertexDMA); + vert = (MyVertex*) dma->buffer; + + for (y = 0; y < MESH_HEIGHT; y++) { + for (x = 0; x < MESH_WIDTH; x++) { + + float fx = x * (2.0 / MESH_WIDTH) - 1.0; + float fy = y * (2.0 / MESH_HEIGHT) - 1.0; + float fxo = fx + offset; + float dist = fxo * fxo + fy * fy; + float z = sinf(dist * 8.0 + t) / (1 + dist * 10.0); + + vert->position[0] = fx; + vert->position[1] = fy; + vert->position[2] = z; + + vert->color[0] = red - z; + vert->color[1] = green - z; + vert->color[2] = blue - z; + + vert++; + } + } + + SVGA3DUtil_SurfaceDMA2D(vertexSid, &dma->ptr, SVGA3D_WRITE_HOST_VRAM, + MESH_NUM_VERTICES * sizeof(MyVertex), 1); + + SVGA3DUtil_AsyncCall((AsyncCallFn) SVGA3DUtil_DMAPoolFreeBuffer, dma); +} + + +/* + * drawMesh -- + * + * Draw our mesh at a particular position. This uses the index and + * vertex data which is resident in the host VRAM buffers at the + * time the drawing command is executed asynchronously. + */ + +void +drawMesh(float posX, float posY, float posZ) +{ + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + static Matrix view; + + Matrix_Copy(view, gIdentityMatrix); + Matrix_Translate(view, posX, posY, posZ); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, view); + + SVGA3D_BeginDrawPrimitives(CID, &decls, 2, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = sizeof(MyVertex); + decls[0].array.offset = offsetof(MyVertex, position); + + decls[1].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[1].identity.usage = SVGA3D_DECLUSAGE_COLOR; + decls[1].array.surfaceId = vertexSid; + decls[1].array.stride = sizeof(MyVertex); + decls[1].array.offset = offsetof(MyVertex, color); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = MESH_NUM_TRIANGLES; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(IndexType); + ranges[0].indexWidth = sizeof(IndexType); + } + SVGA_FIFOCommitAll(); +} + + +/* + * createIndexBuffer -- + * + * Create a static index buffer that renders our vertices as a 2D + * mesh. For simplicity, we use a triangle list rather than a + * triangle strip. + */ +uint32 +createIndexBuffer(void) +{ + IndexType *indexBuffer; + const uint32 bufferSize = MESH_NUM_INDICES * sizeof *indexBuffer; + SVGAGuestPtr gPtr; + uint32 sid; + int x, y; + + sid = SVGA3DUtil_DefineSurface2D(bufferSize, 1, SVGA3D_BUFFER); + indexBuffer = SVGA3DUtil_AllocDMABuffer(bufferSize, &gPtr); + + for (y = 0; y < (MESH_HEIGHT - 1); y++) { + for (x = 0; x < (MESH_WIDTH - 1); x++) { + + indexBuffer[0] = MESH_ELEMENT(x, y ); + indexBuffer[1] = MESH_ELEMENT(x+1, y ); + indexBuffer[2] = MESH_ELEMENT(x+1, y+1); + + indexBuffer[3] = MESH_ELEMENT(x+1, y+1); + indexBuffer[4] = MESH_ELEMENT(x, y+1); + indexBuffer[5] = MESH_ELEMENT(x, y ); + + indexBuffer += 6; + } + } + + SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, bufferSize, 1); + + return sid; +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DText_Init(); + + vertexSid = SVGA3DUtil_DefineSurface2D(MESH_NUM_VERTICES * sizeof(MyVertex), + 1, SVGA3D_BUFFER); + indexSid = createIndexBuffer(); + + SVGA3DUtil_AllocDMAPool(&vertexDMA, MESH_NUM_VERTICES * sizeof(MyVertex), 16); + + Matrix_Perspective(perspectiveMat, 45.0f, + gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); + + while (1) { + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "Dynamic vertex buffers.\n\n%s", + gFPS.text); + SVGA3DText_Update(); + } + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x113366, 1.0f, 0); + + setupFrame(); + + updateVertices(1, 0.5, 0.5, M_PI, 0); + drawMesh(-1.5, -1, 6); + + updateVertices(0.5, 1.0, 0.5, 0, 0); + drawMesh(0, 1, 6); + + updateVertices(0.5, 0.5, 1.0, 0, 1.5); + drawMesh(1.5, -1, 6); + + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + } + + return 0; +} diff --git a/examples/fence-stress/Makefile b/examples/fence-stress/Makefile new file mode 100644 index 0000000..fc83a9f --- /dev/null +++ b/examples/fence-stress/Makefile @@ -0,0 +1,6 @@ +TARGET = fence-stress.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/fence-stress/main.c b/examples/fence-stress/main.c new file mode 100644 index 0000000..e80cd8e --- /dev/null +++ b/examples/fence-stress/main.c @@ -0,0 +1,58 @@ +/* + * SVGA3D example: Stress-test for our FIFO Fence synchronization. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" + +#define SYNCS_PER_FRAME 1024 + +int +main(void) +{ + int i, j; + uint32 fence = 0; + static FPSCounterState gFPS; + + SVGA3DUtil_InitFullscreen(CID, 640, 480); + SVGA3DText_Init(); + + while (1) { + SVGA3DUtil_UpdateFPSCounter(&gFPS); + + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "FIFO Fence stress-test.\n" + "%d syncs per frame.\n" + "\n" + "%s\n" + "\n" + "Latest fence: 0x%08x\n" + " IRQ count: %d\n", + SYNCS_PER_FRAME, gFPS.text, fence, gSVGA.irq.count); + SVGA3DText_Update(); + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR, 0, 1.0f, 0); + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + + for (j = 0; j < SYNCS_PER_FRAME; j++) { + for (i=0; i<100; i++) { + SVGA_InsertFence(); + } + + fence = SVGA_InsertFence(); + + for (i=0; i<50; i++) { + SVGA_InsertFence(); + } + + SVGA_SyncToFence(fence); + } + } + + return 0; +} diff --git a/examples/gmr-test/Makefile b/examples/gmr-test/Makefile new file mode 100644 index 0000000..633a872 --- /dev/null +++ b/examples/gmr-test/Makefile @@ -0,0 +1,7 @@ +TARGET = gmr-test.img +VMX_MEMSIZE = 128 + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/gmr-test/main.c b/examples/gmr-test/main.c new file mode 100644 index 0000000..6e0567c --- /dev/null +++ b/examples/gmr-test/main.c @@ -0,0 +1,578 @@ +/* + * SVGA3D example: Test harness and low-level example program for + * Guest Memory Regions. + * + * With Guest Memory regions, the SVGA device can perform DMA + * operations directly between guest system memory and host + * VRAM. Guest drivers use the device's GMR registers to set up + * regions of guest memory which can be accessed by the device, then + * the driver refers to these regions by ID when sending pointers over + * the command FIFO. + * + * GMRs support physically contiguous or discontiguous memory. This + * example is a bit contrived because we're testing GMRs without an + * operating system or a virtual memory subsystem- in a real OS, + * support for physically discontiguous addresses would often be + * required in order to ensure that the GMR's address space matches + * that of a particular virtual address space in the OS. In this + * example, we just test physically discontiguous regions for the sake + * of testing them. + * + * This test harness is focused on system memory GMRs, however it also + * ends up testing much of the GLSurface and GLFBO code, since it + * performs GMR-to-GMR copies by way of surface DMA operations. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga.h" +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "console_vga.h" +#include "gmr.h" +#include "math.h" +#include "mt19937ar.h" + +/* Maximum number of copy boxes we'll test with. The host has no limit. */ +#define MAX_COPY_BOXES 128 + +/* + * Global data + */ + +static uint32 tempSurfaceId; +static uint32 randSeed; +static uint32 testIters; +static uint32 testRegionSize; +static const char *testPass; + + +/* + * TestPattern_Write -- + * TestPattern_Check -- + * + * Write/check an arbitrary deterministic test pattern in the + * provided buffer. The buffer must be a multiple of 4 bytes long. + * + * Instead of generating a unique random number for every word, + * which would be pretty slow, this generates a prime number of + * random words, which then repeat across the entire check range. + */ + +#define PATTERN_BUFFER_LEN 41 // Must be prime + +void +TestPattern_Write(uint32 *buffer, + uint32 size) +{ +#ifndef DISABLE_CHECKING + uint32 pattern[PATTERN_BUFFER_LEN]; + int i; + + init_genrand(randSeed); + for (i = 0; i < PATTERN_BUFFER_LEN; i++) { + pattern[i] = genrand_int32(); + } + i = 0; + + size /= sizeof *buffer; + while (size--) { + *(buffer++) = pattern[i]; + if (++i == PATTERN_BUFFER_LEN) { + i = 0; + } + } +#endif +} + +void +TestPattern_Check(uint32 *buffer, + uint32 size, + uint32 offset, + uint32 line, + uint32 index) +{ +#ifndef DISABLE_CHECKING + uint32 pattern[PATTERN_BUFFER_LEN]; + int i; + + init_genrand(randSeed); + for (i = 0; i < PATTERN_BUFFER_LEN; i++) { + pattern[i] = genrand_int32(); + } + + offset /= sizeof *buffer; + size /= sizeof *buffer; + + i = offset % PATTERN_BUFFER_LEN; + + while (size) { + uint32 v = pattern[i]; + if (++i == PATTERN_BUFFER_LEN) { + i = 0; + } + + if (*buffer != v) { + SVGA_Disable(); + ConsoleVGA_Init(); + Console_Format("Test pattern mismatch on %4x.%4x\n" + "Test pass: %s\n" + "Mismatch at %08x, with %08x bytes left in block.\n\n", + line, index, testPass, buffer, size * sizeof *buffer); + + size = MIN(size, 16); + while (size) { + Console_Format("Actual: %08x Expected: %08x\n", + *buffer, v); + buffer++; + size--; + + v = pattern[i]; + if (++i == PATTERN_BUFFER_LEN) { + i = 0; + } + } + + Intr_Disable(); + Intr_Halt(); + } + + buffer++; + size--; + } +#endif +} + + +/* + * GMR_GenericCopy -- + * + * Copy between two GMRs, using an arbitrarily shaped buffer + * surface and an arbitrary list of copy boxes. + * + * In the copy boxes, the 'source' represents locations + * on both guest surfaces and the 'destination' represents + * a locations in host VRAM. + */ + +void +GMR_GenericCopy(SVGAGuestPtr *dest, + SVGAGuestPtr *src, + SVGA3dSize *surfSize, + SVGA3dSurfaceFormat format, + SVGA3dCopyBox *boxes, + uint32 numBoxes) +{ + SVGA3dSize *mipSizes; + SVGA3dSurfaceFace *faces; + SVGA3dCopyBox *dmaBoxes; + SVGA3dGuestImage srcImage = { *src }; + SVGA3dGuestImage destImage = { *dest }; + SVGA3dSurfaceImageId hostImage = { tempSurfaceId }; + + SVGA3D_BeginDefineSurface(tempSurfaceId, 0, format, &faces, &mipSizes, 1); + faces[0].numMipLevels = 1; + mipSizes[0] = *surfSize; + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSurfaceDMA(&srcImage, &hostImage, SVGA3D_WRITE_HOST_VRAM, + &dmaBoxes, numBoxes); + memcpy(dmaBoxes, boxes, numBoxes * sizeof boxes[0]); + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSurfaceDMA(&destImage, &hostImage, SVGA3D_READ_HOST_VRAM, + &dmaBoxes, numBoxes); + memcpy(dmaBoxes, boxes, numBoxes * sizeof boxes[0]); + SVGA_FIFOCommitAll(); + + SVGA3D_DestroySurface(tempSurfaceId); + + /* Wait for both DMA operations to finish. */ + SVGA_SyncToFence(SVGA_InsertFence()); +} + + +/* + * Display_BeginPass -- + * + * Begin a new test pass, and update the on-screen display. + */ + +void +Display_BeginPass(const char *pass) +{ + testPass = pass; + + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "Guest Memory Region stress-test.\n" + "\n" + "Host capabilities\n" + "-----------------\n" + "\n" + " Max IDs: %d\n" + " Max Descriptor Len: %d\n" + "\n" + "Test status\n" + "-----------\n" + "\n" + " Iterations: %d\n" + " Seed: %08x\n" + " Running: %s\n" + "\n" +#ifdef DISABLE_CHECKING + "CHECKING DISABLED. This test can't fail.\n", +#else + "Test is running successfully so far. Will Panic on failure.\n", +#endif + gGMR.maxIds, gGMR.maxDescriptorLen, testIters, + randSeed, testPass); + + VMBackdoor_VGAScreenshot(); + SVGA3DText_Update(); + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR, 0x000080, 1.0f, 0); + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); +} + + +/* + * runTestPass -- + * + * Run one test pass- create two large GMRs, one contiguous and one + * discontiguous. Copy a test pattern back and forth between the + * two buffers, using the provided surface size and type. + */ + +void +runTestPass(uint32 testRegionSize, + SVGA3dSize *surfSize, + SVGA3dSurfaceFormat format, + SVGA3dCopyBox *boxes, + uint32 numBoxes) +{ + SVGAGuestPtr contig = { 0, 0 }; + SVGAGuestPtr evenPages = { gGMR.maxIds - 1, 0 }; + int i; + + uint32 contigPages = GMR_DefineContiguous(contig.gmrId, gGMR.maxDescriptorLen * 2); + uint32 discontigPages = GMR_DefineEvenPages(evenPages.gmrId, gGMR.maxDescriptorLen); + + /* + * Write a test pattern into the contiguous GMR. + */ + + TestPattern_Write(PPN_POINTER(contigPages), testRegionSize); + TestPattern_Check(PPN_POINTER(contigPages), testRegionSize, 0, __LINE__, 0); + + /* + * Copy from contiguous to discontiguous. + */ + + GMR_GenericCopy(&evenPages, &contig, surfSize, format, boxes, numBoxes); + + /* + * Check the discontiguous GMR, page-by-page. + */ + + for (i = 0; i < testRegionSize / PAGE_SIZE; i++) { + TestPattern_Check(PPN_POINTER(discontigPages + 2*i), + PAGE_SIZE, PAGE_SIZE * i, __LINE__, i); + } + + /* + * Clear the contiguous GMR, then copy data back into it from the discontiguous GMR. + */ + + memset(PPN_POINTER(contigPages), 0x42, testRegionSize); + GMR_GenericCopy(&contig, &evenPages, surfSize, format, boxes, numBoxes); + + /* + * Check the contiguous GMR again. + */ + + TestPattern_Check(PPN_POINTER(contigPages), testRegionSize, 0, __LINE__, i); + + GMR_FreeAll(); + Heap_Reset(); +} + + +/* + * createBoxes -- + * + * Create an array of N copyboxes which cover an entire surface. + * This begins with a single large copybox, and iteratively splits + * small boxes off from a random face on the original box. + * + * This function can and will generate degenerate copy boxes + * (zero-size). The SVGA3D device must ignore those boxes. + */ + +void +createBoxes(SVGA3dSize *size, + SVGA3dCopyBox *boxes, + uint32 numBoxes) +{ + uint32 i; + SVGA3dCopyBox space = { + .w = size->width, + .h = size->height, + .d = size->depth, + }; + + init_genrand(randSeed); + + for (i = 0; i < numBoxes - 1; i++) { + uint32 rand = genrand_int32(); + uint32 a; + memcpy(&boxes[i], &space, sizeof space); + switch (rand % 6) { + + case 0: /* X- */ + a = rand % space.w; + boxes[i].w = a; + space.x += a; + space.w -= a; + break; + + case 1: /* Y- */ + a = rand % space.h; + boxes[i].h = a; + space.y += a; + space.h -= a; + break; + + case 2: /* Z- */ + a = rand % space.d; + boxes[i].d = a; + space.z += a; + space.d -= a; + break; + + case 3: /* X+ */ + a = rand % space.w; + boxes[i].w = a; + space.w -= a; + boxes[i].x += space.w; + break; + + case 4: /* Y+ */ + a = rand % space.h; + boxes[i].h = a; + space.h -= a; + boxes[i].y += space.h; + break; + + case 5: /* Z+ */ + a = rand % space.d; + boxes[i].d = a; + space.d -= a; + boxes[i].z += space.d; + break; + } + } + + boxes[i] = space; + + for (i = 0; i < numBoxes; i++) { + boxes[i].srcx = boxes[i].x; + boxes[i].srcy = boxes[i].y; + boxes[i].srcz = boxes[i].z; + } +} + + +/* + * createMisaligned1dBoxes -- + * + * Create an array of N 1-dimensional copyboxes, most of which + * have a width of PAGE_SIZE-1 bytes. + * + * The boxes may extend past the end of 'size'. This is okay, + * the SVGA3D device is responsible for clipping them. + */ + +void +createMisaligned1dBoxes(uint32 size, + SVGA3dCopyBox *boxes, + uint32 numBoxes) +{ + uint32 offset = 0; + uint32 i; + + memset(boxes, 0, sizeof *boxes * numBoxes); + + for (i = 0; i < numBoxes - 1; i++) { + boxes[i].x = boxes[i].srcx = offset; + boxes[i].w = PAGE_SIZE-1; + boxes[i].h = 1; + boxes[i].d = 1; + offset += boxes[i].w; + } + + boxes[i].x = boxes[i].srcx = offset; + boxes[i].w = size - offset; + boxes[i].h = 1; + boxes[i].d = 1; +} + + +/* + * runTests -- + * + * Main function to run one iteration of all tests. + */ + +void +runTests(void) +{ + /* Maximum size of worst-case-discontiguous region we can represent */ + uint32 largeRegionSize = gGMR.maxDescriptorLen * PAGE_SIZE; + + /* Smaller region, to speed up other testing. */ + uint32 regionSize = 0x20 * PAGE_SIZE; + + /* Smallest region, suitable for 1D textures. */ + uint32 tinyRegionSize = 1024; + + SVGA3dSize size1dLarge = { + .width = largeRegionSize, + .height = 1, + .depth = 1, + }; + + SVGA3dSize size1d = { + .width = tinyRegionSize, + .height = 1, + .depth = 1, + }; + + SVGA3dSize size2d = { + .width = 0x100, + .height = regionSize / 0x100, + .depth = 1, + }; + + SVGA3dSize size3d = { + .width = 0x40, + .height = 0x40, + .depth = regionSize / 0x1000, + }; + + /* A single maximally-sized 1D copybox. The host will clip it. */ + SVGA3dCopyBox maxBox1d = { + .w = 0xFFFFFFFFUL, + .h = 1, + .d = 1, + }; + + SVGA3dCopyBox boxes[MAX_COPY_BOXES]; + + /* + * Basic per-surface-format tests. + * + * Note that 3D compressed textures are not expected to work yet, + * so we skip those tests. + */ + +#define TEST_FORMAT_2D(f, b) \ + { \ + Display_BeginPass("Single copy via 1D " #f " surface."); \ + runTestPass(tinyRegionSize*b, &size1d, SVGA3D_ ## f, &maxBox1d, 1); \ + \ + Display_BeginPass("Single copy via 2D " #f " surface."); \ + createBoxes(&size2d, boxes, 1); \ + runTestPass(regionSize*b, &size2d, SVGA3D_ ## f, boxes, 1); \ + } + +#define TEST_FORMAT(f, b) \ + { \ + TEST_FORMAT_2D(f, b) \ + \ + Display_BeginPass("Single copy via 3D " #f " surface."); \ + createBoxes(&size3d, boxes, 1); \ + runTestPass(regionSize*b, &size3d, SVGA3D_ ## f, boxes, 1); \ + } + + TEST_FORMAT(BUFFER, 1) // Buffers use their own host VRAM type + TEST_FORMAT(LUMINANCE8, 1) // Test a simple 8bpp format + TEST_FORMAT(ALPHA8, 1) // To isolate alpha channel bugs + TEST_FORMAT(A8R8G8B8, 4) // ARGB surfaces have more readback paths than others + TEST_FORMAT_2D(DXT2, 1) // Test 4x4 block size, and compressed texture upload/download + +#undef TEST_FORMAT +#undef TEST_FORMAT_2D + + /* + * Test large buffers (Limited by max size of worst-case fragmented GMR) + */ + + Display_BeginPass("Single copy via 1D BUFFER surface. (Large region)"); + runTestPass(largeRegionSize, &size1dLarge, SVGA3D_BUFFER, &maxBox1d, 1); + + /* + * Test with randomly subdivided copyboxes. + */ + +#define TEST_FORMAT_2D(f, b) \ + { \ + Display_BeginPass("Subdivided copy via 2D " #f " surface."); \ + createBoxes(&size2d, boxes, MAX_COPY_BOXES); \ + runTestPass(regionSize*b, &size2d, SVGA3D_ ## f, boxes, MAX_COPY_BOXES); \ + } + +#define TEST_FORMAT(f, b) \ + { \ + TEST_FORMAT_2D(f, b) \ + \ + Display_BeginPass("Subdivided copy via 3D " #f " surface."); \ + createBoxes(&size3d, boxes, MAX_COPY_BOXES); \ + runTestPass(regionSize*b, &size3d, SVGA3D_ ## f, boxes, MAX_COPY_BOXES); \ + } + + TEST_FORMAT(BUFFER, 1) + TEST_FORMAT(ALPHA8, 1) + TEST_FORMAT(A8R8G8B8, 4) + TEST_FORMAT_2D(DXT2, 1) // Test compressed texture rectangle clipping + +#undef TEST_FORMAT +#undef TEST_FORMAT_2D + + /* + * Test another large 1D copy, split into slightly misaligned chunks. + */ + + Display_BeginPass("Misaligned copies via 1D BUFFER surface. (Large region)"); + createMisaligned1dBoxes(largeRegionSize, boxes, MAX_COPY_BOXES); + runTestPass(largeRegionSize, &size1dLarge, SVGA3D_BUFFER, boxes, MAX_COPY_BOXES); +} + + +/* + * main -- + * + * Entry point and main loop for the example. + */ + +int +main(void) +{ + SVGA3DUtil_InitFullscreen(CID, 640, 480); + SVGA3DText_Init(); + GMR_Init(); + Heap_Reset(); + + tempSurfaceId = SVGA3DUtil_AllocSurfaceID(); + testRegionSize = gGMR.maxDescriptorLen * PAGE_SIZE; + + while (1) { + runTests(); + + randSeed = genrand_int32(); + testIters++; + } + + return 0; +} diff --git a/examples/half-float-test/Makefile b/examples/half-float-test/Makefile new file mode 100644 index 0000000..6af8192 --- /dev/null +++ b/examples/half-float-test/Makefile @@ -0,0 +1,16 @@ +TARGET = half-float-test.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules + +.PHONY: shaders + +shaders: cube_vs.h cube_ps.h + +cube_vs.h: cube.fx + wine fxc.exe /T vs_2_0 /E MyVertexShader /Fh cube_vs.h cube.fx + +cube_ps.h: cube.fx + wine fxc.exe /T ps_2_0 /E MyPixelShader /Fh cube_ps.h cube.fx diff --git a/examples/half-float-test/cube.fx b/examples/half-float-test/cube.fx new file mode 100644 index 0000000..e6e92ec --- /dev/null +++ b/examples/half-float-test/cube.fx @@ -0,0 +1,36 @@ +float4x4 matView, matProj; + +struct VS_Input +{ + float4 Pos : POSITION; + float4 Color : COLOR0; +}; + +struct VS_Output +{ + float4 Pos : POSITION; + float4 Color : COLOR0; +}; + + +VS_Output +MyVertexShader(VS_Input Input) +{ + VS_Output Output; + + Output.Pos = mul(mul(Input.Pos, matView), matProj); + Output.Color = Input.Color; + + return Output; +} + +struct PS_Input +{ + float4 Color : COLOR0; +}; + +float4 +MyPixelShader(PS_Input Input) : COLOR +{ + return Input.Color; +} diff --git a/examples/half-float-test/cube_ps.h b/examples/half-float-test/cube_ps.h new file mode 100644 index 0000000..124a4e5 --- /dev/null +++ b/examples/half-float-test/cube_ps.h @@ -0,0 +1,21 @@ +#if 0 +// +// Generated by Microsoft (R) D3DX9 Shader Compiler +// +// fxc /T ps_2_0 /E MyPixelShader /Fh cube_ps.h cube.fx +// + ps_2_0 + dcl v0 + mov oC0, v0 + +// approximately 1 instruction slot used +#endif + +const DWORD g_ps20_MyPixelShader[] = +{ + 0xffff0200, 0x0013fffe, 0x42415443, 0x0000001c, 0x00000023, 0xffff0200, + 0x00000000, 0x00000000, 0x20000100, 0x0000001c, 0x325f7370, 0x4d00305f, + 0x6f726369, 0x74666f73, 0x29522820, 0x44334420, 0x53203958, 0x65646168, + 0x6f432072, 0x6c69706d, 0x00207265, 0x0200001f, 0x80000000, 0x900f0000, + 0x02000001, 0x800f0800, 0x90e40000, 0x0000ffff +}; diff --git a/examples/half-float-test/cube_vs.h b/examples/half-float-test/cube_vs.h new file mode 100644 index 0000000..9900b68 --- /dev/null +++ b/examples/half-float-test/cube_vs.h @@ -0,0 +1,54 @@ +#if 0 +// +// Generated by Microsoft (R) D3DX9 Shader Compiler +// +// fxc /T vs_2_0 /E MyVertexShader /Fh cube_vs.h cube.fx +// +// +// Parameters: +// +// float4x4 matProj; +// float4x4 matView; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// matView c0 4 +// matProj c4 4 +// + + vs_2_0 + dcl_position v0 + dcl_color v1 + dp4 r0.x, v0, c0 + dp4 r0.y, v0, c1 + dp4 r0.z, v0, c2 + dp4 r0.w, v0, c3 + dp4 oPos.x, r0, c4 + dp4 oPos.y, r0, c5 + dp4 oPos.z, r0, c6 + dp4 oPos.w, r0, c7 + mov oD0, v1 + +// approximately 9 instruction slots used +#endif + +const DWORD g_vs20_MyVertexShader[] = +{ + 0xfffe0200, 0x0025fffe, 0x42415443, 0x0000001c, 0x0000006b, 0xfffe0200, + 0x00000002, 0x0000001c, 0x20000100, 0x00000064, 0x00000044, 0x00040002, + 0x00000004, 0x0000004c, 0x00000000, 0x0000005c, 0x00000002, 0x00000004, + 0x0000004c, 0x00000000, 0x5074616d, 0x006a6f72, 0x00030003, 0x00040004, + 0x00000001, 0x00000000, 0x5674616d, 0x00776569, 0x325f7376, 0x4d00305f, + 0x6f726369, 0x74666f73, 0x29522820, 0x44334420, 0x53203958, 0x65646168, + 0x6f432072, 0x6c69706d, 0x00207265, 0x0200001f, 0x80000000, 0x900f0000, + 0x0200001f, 0x8000000a, 0x900f0001, 0x03000009, 0x80010000, 0x90e40000, + 0xa0e40000, 0x03000009, 0x80020000, 0x90e40000, 0xa0e40001, 0x03000009, + 0x80040000, 0x90e40000, 0xa0e40002, 0x03000009, 0x80080000, 0x90e40000, + 0xa0e40003, 0x03000009, 0xc0010000, 0x80e40000, 0xa0e40004, 0x03000009, + 0xc0020000, 0x80e40000, 0xa0e40005, 0x03000009, 0xc0040000, 0x80e40000, + 0xa0e40006, 0x03000009, 0xc0080000, 0x80e40000, 0xa0e40007, 0x02000001, + 0xd00f0000, 0x90e40001, 0x0000ffff +}; diff --git a/examples/half-float-test/main.c b/examples/half-float-test/main.c new file mode 100644 index 0000000..af3ac6e --- /dev/null +++ b/examples/half-float-test/main.c @@ -0,0 +1,227 @@ +/* + * Test support for half-precision (16-bit) floating point. + * + * This test draws four cubes, to test fixed-function and programmable + * pipelines, and to test 16-bit and 32-bit float vertices. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" + +typedef uint32 DWORD; +#include "cube_vs.h" +#include "cube_ps.h" + +/* 16-bit floating point constants */ +#define HALF_0 0x0000 +#define HALF_POS_1 0x3c00 +#define HALF_NEG_1 0xbc00 + +#define MY_VSHADER_ID 0 +#define MY_PSHADER_ID 0 + +#define CONST_MAT_VIEW 0 +#define CONST_MAT_PROJ 4 + +typedef struct { + float position32[3]; + uint16 position16[4]; + uint32 color; +} MyVertex; + +static const MyVertex vertexData[] = { + { {-1, -1, -1}, {HALF_NEG_1, HALF_NEG_1, HALF_NEG_1, HALF_POS_1}, 0xFFFFFF }, + { {-1, -1, 1}, {HALF_NEG_1, HALF_NEG_1, HALF_POS_1, HALF_POS_1}, 0xFFFF00 }, + { {-1, 1, -1}, {HALF_NEG_1, HALF_POS_1, HALF_NEG_1, HALF_POS_1}, 0xFF00FF }, + { {-1, 1, 1}, {HALF_NEG_1, HALF_POS_1, HALF_POS_1, HALF_POS_1}, 0xFF0000 }, + { { 1, -1, -1}, {HALF_POS_1, HALF_NEG_1, HALF_NEG_1, HALF_POS_1}, 0x00FFFF }, + { { 1, -1, 1}, {HALF_POS_1, HALF_NEG_1, HALF_POS_1, HALF_POS_1}, 0x00FF00 }, + { { 1, 1, -1}, {HALF_POS_1, HALF_POS_1, HALF_NEG_1, HALF_POS_1}, 0x0000FF }, + { { 1, 1, 1}, {HALF_POS_1, HALF_POS_1, HALF_POS_1, HALF_POS_1}, 0x000000 }, +}; + +#define QUAD(a,b,c,d) a, b, d, d, c, a + +static const uint16 indexData[] = { + QUAD(0,1,2,3), // -X + QUAD(4,5,6,7), // +X + QUAD(0,1,4,5), // -Y + QUAD(2,3,6,7), // +Y + QUAD(0,2,4,6), // -Z + QUAD(1,3,5,7), // +Z +}; + +#undef QUAD + +const uint32 numTriangles = sizeof indexData / sizeof indexData[0] / 3; +uint32 vertexSid, indexSid; +Matrix perspectiveMat; +FPSCounterState gFPS; + + +/* + * renderCube -- + * + * Render one cube at the supplied X/Y coordinate, using either + * shaders or fixed-function, and using either 16-bit or 32-bit + * vertex data. + */ + +void +renderCube(float x, + float y, + Bool useShaders, + Bool useHalf) +{ + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + static Matrix view; + + Matrix_Copy(view, gIdentityMatrix); + Matrix_RotateX(view, 30.0 * M_PI / 180.0); + Matrix_RotateY(view, gFPS.frame * 0.01f); + Matrix_Translate(view, x, y, 15); + + if (useShaders) { + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, MY_VSHADER_ID); + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, MY_PSHADER_ID); + + SVGA3DUtil_SetShaderConstMatrix(CID, CONST_MAT_PROJ, + SVGA3D_SHADERTYPE_VS, perspectiveMat); + SVGA3DUtil_SetShaderConstMatrix(CID, CONST_MAT_VIEW, + SVGA3D_SHADERTYPE_VS, view); + } else { + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, SVGA3D_INVALID_ID); + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, SVGA3D_INVALID_ID); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, view); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, gIdentityMatrix); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); + } + + SVGA3D_BeginSetRenderState(CID, &rs, 4); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 4); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = SVGA3D_INVALID_ID; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_SELECTARG1; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_DIFFUSE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_ALPHAARG1; + ts[3].value = SVGA3D_TA_DIFFUSE; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginDrawPrimitives(CID, &decls, 2, &ranges, 1); + { + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = sizeof(MyVertex); + if (useHalf) { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT16_4; + decls[0].array.offset = offsetof(MyVertex, position16); + } else { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].array.offset = offsetof(MyVertex, position32); + } + + decls[1].identity.type = SVGA3D_DECLTYPE_D3DCOLOR; + decls[1].identity.usage = SVGA3D_DECLUSAGE_COLOR; + decls[1].array.surfaceId = vertexSid; + decls[1].array.stride = sizeof(MyVertex); + decls[1].array.offset = offsetof(MyVertex, color); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = numTriangles; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(uint16); + ranges[0].indexWidth = sizeof(uint16); + } + SVGA_FIFOCommitAll(); + + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, SVGA3D_INVALID_ID); + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, SVGA3D_INVALID_ID); +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DText_Init(); + + vertexSid = SVGA3DUtil_DefineStaticBuffer(vertexData, sizeof vertexData); + indexSid = SVGA3DUtil_DefineStaticBuffer(indexData, sizeof indexData); + + SVGA3D_DefineShader(CID, MY_VSHADER_ID, SVGA3D_SHADERTYPE_VS, + g_vs20_MyVertexShader, sizeof g_vs20_MyVertexShader); + SVGA3D_DefineShader(CID, MY_PSHADER_ID, SVGA3D_SHADERTYPE_PS, + g_ps20_MyPixelShader, sizeof g_ps20_MyPixelShader); + + Matrix_Perspective(perspectiveMat, 45.0f, + gSVGA.width / (float)gSVGA.height, 10.0f, 100.0f); + + while (1) { + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("Half-precision floating point test.\n" + "You should see four identical cubes.\n" + "\n" + "Top row: Fixed function, Bottom row: Shaders.\n" + "Left column: 32-bit float, Right column: 16-bit float.\n" + "\n%s", + gFPS.text); + SVGA3DText_Update(); + VMBackdoor_VGAScreenshot(); + } + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x113366, 1.0f, 0); + + renderCube(-2, 2, FALSE, FALSE); /* Top-left */ + renderCube(2, 2, FALSE, TRUE); /* Top-right */ + renderCube(-2, -2, TRUE, FALSE); /* Bottom-left */ + renderCube(2, -2, TRUE, TRUE); /* Bottom-right */ + + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + } + + return 0; +} diff --git a/examples/pong/Makefile b/examples/pong/Makefile new file mode 100644 index 0000000..3892bc1 --- /dev/null +++ b/examples/pong/Makefile @@ -0,0 +1,8 @@ +TARGET = pong.img + +APP_SOURCES = main.c + +DEFS = -DREALLY_TINY + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/pong/main.c b/examples/pong/main.c new file mode 100644 index 0000000..9504707 --- /dev/null +++ b/examples/pong/main.c @@ -0,0 +1,710 @@ +/* + * PongOS v2.0 + * + * Micah Dowty + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga.h" +#include "intr.h" +#include "io.h" +#include "timer.h" +#include "keyboard.h" +#include "vmbackdoor.h" + +#define PONG_DOT_SIZE 8 +#define PONG_DIGIT_PIXEL_SIZE 10 +#define PONG_BG_COLOR 0x000000 +#define PONG_SPRITE_COLOR 0xFFFFFF +#define PONG_PLAYFIELD_COLOR 0xAAAAAA +#define PONG_FRAME_RATE 60 + +#define MAX_DIRTY_RECTS 128 +#define MAX_SPRITES 8 + +typedef struct { + float x, y; +} Vector2; + +typedef struct { + int x, y, w, h; +} Rect; + +typedef struct { + Rect r; + uint32 color; +} FillRect; + +static struct { + uint32 *buffer; + Rect dirtyRects[MAX_DIRTY_RECTS]; + uint32 numDirtyRects; +} back; + +static struct { + FillRect paddles[2]; + FillRect ball; + uint8 scores[2]; + + float ballSpeed; + float paddleVelocities[2]; + float paddlePos[2]; + Vector2 ballVelocity; + Vector2 ballPos; + + Bool playfieldDirty; +} pong; + + +/* + *----------------------------------------------------------------------------- + * + * Random32 -- + * + * "Random" number generator. To save code space, we actually just use + * the low bits of the TSC. This of course isn't actually random, but + * it's good enough for Pong. + * + *----------------------------------------------------------------------------- + */ + +static uint32 +Random32(void) +{ + uint64 t; + + __asm__ __volatile__("rdtsc" : "=A" (t)); + + return (uint32)t; +} + + +/* + *----------------------------------------------------------------------------- + * + * RectTestIntersection -- + * + * Returns TRUE iff two Rects intersect with each other. + * + *----------------------------------------------------------------------------- + */ + +static Bool +RectTestIntersection(Rect *a, // IN + Rect *b) // IN +{ + return !(a->x + a->w < b->x || + a->x > b->x + b->w || + a->y + a->h < b->y || + a->y > b->y + b->h); +} + + +/* + *----------------------------------------------------------------------------- + * + * BackFill -- + * + * Perform a color fill on the backbuffer. + * + *----------------------------------------------------------------------------- + */ + +static void +BackFill(FillRect fr) // IN +{ + int i, j; + + for (i = 0; i < fr.r.h; i++) { + uint32 *line = &back.buffer[(fr.r.y + i) * gSVGA.width + fr.r.x]; + + for (j = 0; j < fr.r.w; j++) { + line[j] = fr.color; + } + } +} + + +/* + *----------------------------------------------------------------------------- + * + * BackMarkDirty -- + * + * Mark a region of the backbuffer as dirty. We'll copy it to the + * front buffer and ask the host to update it on the next + * BackUpdate(). + * + *----------------------------------------------------------------------------- + */ + +static void +BackMarkDirty(Rect rect) // IN +{ + back.dirtyRects[back.numDirtyRects++] = rect; +} + + +/* + *----------------------------------------------------------------------------- + * + * BackUpdate -- + * + * Copy all dirty regions of the backbuffer to the frontbuffer, and + * send updates to the SVGA device. Clears the dirtyRects list. + * + * For flow control, this also waits for the host to process the + * batch of updates we just queued into the FIFO. + * + *----------------------------------------------------------------------------- + */ + +static void +BackUpdate() // IN +{ + int rectNum; + + for (rectNum = 0; rectNum < back.numDirtyRects; rectNum++) { + Rect rect = back.dirtyRects[rectNum]; + uint32 i, j; + + for (i = 0; i < rect.h; i++) { + uint32 offset = (rect.y + i) * gSVGA.width + rect.x; + uint32 *src = &back.buffer[offset]; + uint32 *dest = &((uint32*) gSVGA.fbMem)[offset]; + + for (j = 0; j < rect.w; j++) { + dest[j] = src[j]; + } + } + + SVGA_Update(rect.x, rect.y, rect.w, rect.h); + } + + back.numDirtyRects = 0; + SVGA_SyncToFence(SVGA_InsertFence()); +} + + +/* + *----------------------------------------------------------------------------- + * + * PongDrawString -- + * + * Draw a string of digits, using our silly blocky font. The + * string's origin is the top-middle. + * + *----------------------------------------------------------------------------- + */ + +static void +PongDrawString(uint32 x, // IN + uint32 y, // IN + const char *str, // IN + uint32 strLen) // IN +{ + const int charW = 4; + const int charH = 5; + static const uint8 font[] = { + + 0xF1, // **** ...* + 0x91, // *..* ...* + 0x91, // *..* ...* + 0x91, // *..* ...* + 0xF1, // **** ...* + + 0xFF, // **** **** + 0x11, // ...* ...* + 0xFF, // **** **** + 0x81, // *... ...* + 0xFF, // **** **** + + 0x9F, // *..* **** + 0x98, // *..* *... + 0xFF, // **** **** + 0x11, // ...* ...* + 0x1F, // ...* **** + + 0xFF, // **** **** + 0x81, // *... ...* + 0xF1, // **** ...* + 0x91, // *..* ...* + 0xF1, // **** ...* + + 0xFF, // **** **** + 0x99, // *..* *..* + 0xFF, // **** **** + 0x91, // *..* ...* + 0xF1, // **** ...* + }; + + x -= (PONG_DIGIT_PIXEL_SIZE * (strLen * (charW + 1) - 1)) / 2; + + while (*str) { + int digit = *str - '0'; + if (digit >= 0 && digit <= 9) { + int i, j; + + for (j = 0; j < charH; j++) { + for (i = 0; i < charW; i++) { + if ((font[digit / 2 * 5 + j] << i) & (digit & 1 ? 0x08 : 0x80)) { + FillRect pixel = { + {x + i * PONG_DIGIT_PIXEL_SIZE, + y + j * PONG_DIGIT_PIXEL_SIZE, + PONG_DIGIT_PIXEL_SIZE, + PONG_DIGIT_PIXEL_SIZE}, + PONG_PLAYFIELD_COLOR, + }; + BackFill(pixel); + } + } + } + } + x += PONG_DIGIT_PIXEL_SIZE * (charW + 1); + str++; + } +} + + +/* + *----------------------------------------------------------------------------- + * + * DecDigit -- + * + * Utility for extracting a decimal digit. + * + *----------------------------------------------------------------------------- + */ + +static char +DecDigit(int i, int div, Bool blank) +{ + if (blank && i < div) { + return ' '; + } + return (i / div) % 10 + '0'; +} + + +/* + *----------------------------------------------------------------------------- + * + * PongDrawPlayfield -- + * + * Redraw the playfield for Pong. + * + *----------------------------------------------------------------------------- + */ + +static void +PongDrawPlayfield() +{ + int i; + + /* + * Clear the screen + */ + FillRect background = { + {0, 0, gSVGA.width, gSVGA.height}, + PONG_BG_COLOR, + }; + BackFill(background); + + /* + * Draw the dotted dividing line + */ + for (i = PONG_DOT_SIZE; + i <= gSVGA.height - PONG_DOT_SIZE * 2; + i += PONG_DOT_SIZE * 2) { + FillRect dot = { + {(gSVGA.width - PONG_DOT_SIZE) / 2, i, + PONG_DOT_SIZE, PONG_DOT_SIZE}, + PONG_PLAYFIELD_COLOR, + }; + BackFill(dot); + } + + /* + * Draw the score counters. + * + * sprintf() is big, so we'll format this the old-fashioned way. + * Right-justify the left score, and left-justify the right score. + */ + { + char scoreStr[7] = " "; + char *p = scoreStr; + + *(p++) = DecDigit(pong.scores[0], 100, TRUE); + *(p++) = DecDigit(pong.scores[0], 10, TRUE); + *(p++) = DecDigit(pong.scores[0], 1, FALSE); + p++; + if (pong.scores[1] >= 100) { + *(p++) = DecDigit(pong.scores[1], 100, TRUE); + } + if (pong.scores[1] >= 10) { + *(p++) = DecDigit(pong.scores[1], 10, TRUE); + } + *(p++) = DecDigit(pong.scores[1], 1, FALSE); + + PongDrawString(gSVGA.width/2, PONG_DIGIT_PIXEL_SIZE, + scoreStr, sizeof scoreStr); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * PongDrawScreen -- + * + * Top-level redraw function for Pong. This does a lot of unnecessary + * drawing to the backbuffer, but we're careful to only send update + * rectangles for a few things: + * + * - When the playfield changes, we update the entire screen. + * - Each sprite (the paddles and ball) gets two rectangles: + * - One for its new position + * - One for its old position + * + * None of these rectangles are ever merged. + * + *----------------------------------------------------------------------------- + */ + +static void +PongDrawScreen() +{ + PongDrawPlayfield(); + + if (pong.playfieldDirty) { + Rect r = {0, 0, gSVGA.width, gSVGA.height}; + BackMarkDirty(r); + pong.playfieldDirty = FALSE; + } + + /* Draw all sprites at the current positions */ + BackFill(pong.paddles[0]); + BackMarkDirty(pong.paddles[0].r); + BackFill(pong.paddles[1]); + BackMarkDirty(pong.paddles[1].r); + BackFill(pong.ball); + BackMarkDirty(pong.ball.r); + + /* Commit this to the front buffer and the host's screen */ + BackUpdate(); + + /* Make sure we erase all sprites at the current positions on the next frame */ + BackMarkDirty(pong.paddles[0].r); + BackMarkDirty(pong.paddles[1].r); + BackMarkDirty(pong.ball.r); +} + + +/* + *----------------------------------------------------------------------------- + * + * PongLaunchBall -- + * + * Reset the ball position, and give it a random angle. + * + *----------------------------------------------------------------------------- + */ + +static void +PongLaunchBall() +{ + /* sin() from 0 to PI/2 */ + static const float sineTable[64] = { + 0.000000, 0.024931, 0.049846, 0.074730, 0.099568, 0.124344, 0.149042, 0.173648, + 0.198146, 0.222521, 0.246757, 0.270840, 0.294755, 0.318487, 0.342020, 0.365341, + 0.388435, 0.411287, 0.433884, 0.456211, 0.478254, 0.500000, 0.521435, 0.542546, + 0.563320, 0.583744, 0.603804, 0.623490, 0.642788, 0.661686, 0.680173, 0.698237, + 0.715867, 0.733052, 0.749781, 0.766044, 0.781831, 0.797133, 0.811938, 0.826239, + 0.840026, 0.853291, 0.866025, 0.878222, 0.889872, 0.900969, 0.911506, 0.921476, + 0.930874, 0.939693, 0.947927, 0.955573, 0.962624, 0.969077, 0.974928, 0.980172, + 0.984808, 0.988831, 0.992239, 0.995031, 0.997204, 0.998757, 0.999689, 1.000000, + }; + int t; + float sinT, cosT; + + pong.ballPos.x = gSVGA.width / 2; + pong.ballPos.y = gSVGA.height / 2; + + /* Limit the random angle to avoid those within 45 degrees of vertical */ + t = 32 + (Random32() & 31); + + sinT = sineTable[t]; + cosT = -sineTable[(t + 32) & 63]; + + sinT *= pong.ballSpeed; + cosT *= pong.ballSpeed; + + switch (Random32() & 3) { + case 0: + pong.ballVelocity.x = sinT; + pong.ballVelocity.y = cosT; + break; + case 1: + pong.ballVelocity.x = -sinT; + pong.ballVelocity.y = cosT; + break; + case 2: + pong.ballVelocity.x = -sinT; + pong.ballVelocity.y = -cosT; + break; + case 3: + pong.ballVelocity.x = sinT; + pong.ballVelocity.y = -cosT; + break; + } +} + + +/* + *----------------------------------------------------------------------------- + * + * PongInit -- + * + * Initialize all game variables, including sprite location/size/color. + * Requires that SVGA has already been initialized. + * + *----------------------------------------------------------------------------- + */ + +static void +PongInit() +{ + pong.scores[0] = 0; + pong.scores[1] = 0; + pong.playfieldDirty = TRUE; + + pong.paddlePos[0] = pong.paddlePos[1] = gSVGA.height / 2; + + pong.paddles[0].r.x = 10; + pong.paddles[0].r.w = 16; + pong.paddles[0].r.h = 64; + pong.paddles[0].color = PONG_SPRITE_COLOR; + + pong.paddles[1].r.x = gSVGA.width - 16 - 10; + pong.paddles[1].r.w = 16; + pong.paddles[1].r.h = 64; + pong.paddles[1].color = PONG_SPRITE_COLOR; + + pong.ball.r.w = 16; + pong.ball.r.h = 16; + pong.ball.color = PONG_SPRITE_COLOR; + + pong.ballSpeed = 400; + PongLaunchBall(); +} + + +/* + *----------------------------------------------------------------------------- + * + * PongUpdateMotion -- + * + * Perform motion updates for the ball and paddles. This includes + * bounce/goal detection. + * + *----------------------------------------------------------------------------- + */ + +static void +PongUpdateMotion(float dt) // IN +{ + int playableWidth = gSVGA.width - pong.ball.r.w; + int playableHeight = gSVGA.height - pong.ball.r.h; + int i; + + pong.ballPos.x += pong.ballVelocity.x * dt; + pong.ballPos.y += pong.ballVelocity.y * dt; + + for (i = 0; i < 2; i++) { + int pos = pong.paddlePos[i] + pong.paddleVelocities[i] * dt; + pong.paddlePos[i] = MIN(gSVGA.height - pong.paddles[i].r.h, MAX(0, pos)); + pong.paddles[i].r.y = (int)pong.paddlePos[i]; + } + + if (pong.ballPos.x >= playableWidth) { + /* Goal off the right edge */ + pong.scores[0]++; + pong.playfieldDirty = TRUE; + PongLaunchBall(); + } + + if (pong.ballPos.x <= 0) { + /* Goal off the left edge */ + pong.scores[1]++; + pong.playfieldDirty = TRUE; + PongLaunchBall(); + } + + if (pong.ballPos.y >= playableHeight) { + /* Bounce off the bottom edge */ + pong.ballVelocity.y = -pong.ballVelocity.y; + pong.ballPos.y = playableHeight - (pong.ballPos.y - playableHeight); + } + + if (pong.ballPos.y <= 0) { + /* Bounce off the top edge */ + pong.ballVelocity.y = -pong.ballVelocity.y; + pong.ballPos.y = -pong.ballPos.y; + } + + pong.ballPos.y = MIN(playableHeight, pong.ballPos.y); + pong.ballPos.y = MAX(0, pong.ballPos.y); + + pong.ball.r.x = (int)pong.ballPos.x; + pong.ball.r.y = (int)pong.ballPos.y; + + /* + * Lame collision detection between ball and paddles. Really we + * should be testing the ball's entire path over this time step, + * not just the ball's new position. Using the current + * implementation, it's possible for the ball to move through a + * paddle if it's going fast enough or our frame rate is slow + * enough. + */ + for (i = 0; i < 2; i++) { + /* + * Only bounce off the paddle when we're moving toward it, to + * prevent the ball from getting stuck inside the paddle + */ + if ((pong.paddles[i].r.x > gSVGA.width / 2) == (pong.ballVelocity.x > 0) && + RectTestIntersection(&pong.ball.r, &pong.paddles[i].r)) { + /* + * Boing! The ball bounces back, plus it gets a little spin + * if the paddle itself was moving at the time. + */ + pong.ballVelocity.x = -pong.ballVelocity.x; + pong.ballVelocity.y += pong.paddleVelocities[i]; + pong.ballVelocity.y = MIN(pong.ballVelocity.y, pong.ballSpeed * 2); + pong.ballVelocity.y = MAX(pong.ballVelocity.y, -pong.ballSpeed * 2); + } + } +} + + +/* + *----------------------------------------------------------------------------- + * + * PongKeyboardPlayer -- + * + * A human player, using the up and down arrows on a keyboard. + * + *----------------------------------------------------------------------------- + */ + +static void +PongKeyboardPlayer(int playerNum, // IN + float maxSpeed, // IN + float accel) // IN +{ + float v = pong.paddleVelocities[playerNum]; + Bool up = Keyboard_IsKeyPressed(KEY_UP); + Bool down = Keyboard_IsKeyPressed(KEY_DOWN); + + if (up && !down) { + v -= accel; + } else if (down && !up) { + v += accel; + } else { + v = 0; + } + + v = MIN(maxSpeed, MAX(-maxSpeed, v)); + pong.paddleVelocities[playerNum] = v; +} + + +/* + *----------------------------------------------------------------------------- + * + * PongAbsMousePlayer -- + * + * A human player, controlled with the Y axis of the absolute mouse. + * + *----------------------------------------------------------------------------- + */ + +static void +PongAbsMousePlayer(int playerNum) // IN +{ + int currentY = pong.paddles[playerNum].r.y; + int newY = currentY; + VMMousePacket p; + Bool mouseMoved = FALSE; + + while (VMBackdoor_MouseGetPacket(&p)) { + newY = (p.y * gSVGA.height / 0xFFFF) - pong.paddles[playerNum].r.h / 2; + newY = MAX(0, newY); + newY = MIN(gSVGA.height - pong.paddles[playerNum].r.h, newY); + mouseMoved = TRUE; + } + + if (newY != currentY && mouseMoved) { + pong.paddleVelocities[playerNum] = (newY - currentY) * (float)PONG_FRAME_RATE; + } +} + + +/* + *----------------------------------------------------------------------------- + * + * PongComputerPlayer -- + * + * Simple computer player. Always moves its paddle toward the ball. + * + *----------------------------------------------------------------------------- + */ + +static void +PongComputerPlayer(int playerNum, // IN + float maxSpeed) // IN +{ + int paddleCenter = pong.paddles[playerNum].r.y + pong.paddles[playerNum].r.h / 2; + int ballCenter = pong.ball.r.y + pong.ball.r.h / 2; + int distance = ballCenter - paddleCenter; + + pong.paddleVelocities[playerNum] = distance / (float)gSVGA.height * maxSpeed; +} + + +/* + *----------------------------------------------------------------------------- + * + * main -- + * + * Initialization and main loop. + * + *----------------------------------------------------------------------------- + */ + +void +main(void) +{ + Intr_Init(); + SVGA_Init(); + SVGA_SetMode(800, 600, 32); + back.buffer = (uint32*) (gSVGA.fbMem + gSVGA.width * gSVGA.height * sizeof(uint32)); + + Keyboard_Init(); + VMBackdoor_MouseInit(TRUE); + PongInit(); + + Timer_InitPIT(PIT_HZ / PONG_FRAME_RATE); + Intr_SetMask(0, TRUE); + + while (1) { + PongKeyboardPlayer(0, 1000, 50); + PongAbsMousePlayer(0); + PongComputerPlayer(1, 2000); + + PongUpdateMotion(1.0 / PONG_FRAME_RATE); + PongDrawScreen(); + + Intr_Halt(); + } +} diff --git a/examples/present-readback/Makefile b/examples/present-readback/Makefile new file mode 100644 index 0000000..a1be250 --- /dev/null +++ b/examples/present-readback/Makefile @@ -0,0 +1,6 @@ +TARGET = presentReadback.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/present-readback/main.c b/examples/present-readback/main.c new file mode 100644 index 0000000..6847e69 --- /dev/null +++ b/examples/present-readback/main.c @@ -0,0 +1,233 @@ +/* + * SVGA3D example: Present Reaback example. This example tests the 3d + * and 2d syncronization presentReadback command. This example draws + * a spinning cube using 3d. After every frame parts of the 2d + * framebuffer are updated with present readback with a 2d update + * following. Parts of the 3d region are cleared before the present + * readback command testing that the last presented 3d data is what is + * copied to the 2d framebuffer. This cube should spin with no + * flicker. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" + +typedef struct { + float position[3]; + uint32 color; +} MyVertex; + +static const MyVertex vertexData[] = { + { {-1, -1, -1}, 0xFFFFFF }, + { {-1, -1, 1}, 0xFFFF00 }, + { {-1, 1, -1}, 0xFF00FF }, + { {-1, 1, 1}, 0xFF0000 }, + { { 1, -1, -1}, 0x00FFFF }, + { { 1, -1, 1}, 0x00FF00 }, + { { 1, 1, -1}, 0x0000FF }, + { { 1, 1, 1}, 0x000000 }, +}; + +#define QUAD(a,b,c,d) a, b, d, d, c, a + +static const uint16 indexData[] = { + QUAD(0,1,2,3), // -X + QUAD(4,5,6,7), // +X + QUAD(0,1,4,5), // -Y + QUAD(2,3,6,7), // +Y + QUAD(0,2,4,6), // -Z + QUAD(1,3,5,7), // +Z +}; + +#undef QUAD + +const uint32 numTriangles = sizeof indexData / sizeof indexData[0] / 3; +uint32 vertexSid, indexSid; +Matrix perspectiveMat; +FPSCounterState gFPS; +VMMousePacket lastMouseState; + + +/* + * render -- + * + * Set up render state, and draw our cube scene from static index + * and vertex buffers. + * + * This render state only needs to be set each frame because + * SVGA3DText_Draw() changes it. + */ + +void +render(void) +{ + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + static Matrix view; + + Matrix_Copy(view, gIdentityMatrix); + Matrix_Scale(view, 0.5, 0.5, 0.5, 1.0); + + if (lastMouseState.buttons & VMMOUSE_LEFT_BUTTON) { + Matrix_RotateX(view, lastMouseState.y * 0.0001); + Matrix_RotateY(view, lastMouseState.x * -0.0001); + } else { + Matrix_RotateX(view, 30.0 * M_PI / 180.0); + Matrix_RotateY(view, gFPS.frame * 0.01f); + } + + Matrix_Translate(view, 0, 0, 3); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, view); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, gIdentityMatrix); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); + + SVGA3D_BeginSetRenderState(CID, &rs, 4); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 4); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = SVGA3D_INVALID_ID; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_SELECTARG1; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_DIFFUSE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_ALPHAARG1; + ts[3].value = SVGA3D_TA_DIFFUSE; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginDrawPrimitives(CID, &decls, 2, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = sizeof(MyVertex); + decls[0].array.offset = offsetof(MyVertex, position); + + decls[1].identity.type = SVGA3D_DECLTYPE_D3DCOLOR; + decls[1].identity.usage = SVGA3D_DECLUSAGE_COLOR; + decls[1].array.surfaceId = vertexSid; + decls[1].array.stride = sizeof(MyVertex); + decls[1].array.offset = offsetof(MyVertex, color); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = numTriangles; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(uint16); + ranges[0].indexWidth = sizeof(uint16); + } + SVGA_FIFOCommitAll(); +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + SVGAGuestPtr ptr; + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DUtil_AllocDMABuffer(gSVGA.width * gSVGA.height * 4, &ptr); + SVGA3DText_Init(); + + vertexSid = SVGA3DUtil_DefineStaticBuffer(vertexData, sizeof vertexData); + indexSid = SVGA3DUtil_DefineStaticBuffer(indexData, sizeof indexData); + + Matrix_Perspective(perspectiveMat, 45.0f, + gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); + + while (1) { + SVGA3dRect *rects; + int halfWidth = gSVGA.width / 2; + int halfHeight = gSVGA.height / 2; + + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "Present Readback:\n" + " - upper left quadrant:\n" + " present\n" + " - lower right quadrant:\n" + " present -> presentReadback -> update\n" + " - upper right and lower left quadrants:\n" + " present -> clear -> presentReadback -> update\n" + "\n" + "The cube should appear to be smothly spinning \n" + "with all quadrants of the screen in sync.\n\n%s", + gFPS.text); + SVGA3DText_Update(); + VMBackdoor_VGAScreenshot(); + } + + while (VMBackdoor_MouseGetPacket(&lastMouseState)); + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x113366, 1.0f, 0); + render(); + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + + SVGA3D_BeginPresentReadback(&rects, 1); + rects[0].x = halfWidth; + rects[0].y = halfHeight; + rects[0].w = halfWidth; + rects[0].h = halfHeight; + SVGA_FIFOCommitAll(); + SVGA_SyncToFence(SVGA_InsertFence()); + + SVGA_Update(halfWidth,halfHeight,halfWidth,halfHeight); + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0xff00ff, 1.0f, 0); + + SVGA3D_BeginPresentReadback(&rects, 2); + rects[0].x = halfWidth; + rects[0].y = 0; + rects[0].w = halfWidth; + rects[0].h = halfHeight; + rects[1].x = 0; + rects[1].y = halfHeight; + rects[1].w = halfWidth; + rects[1].h = halfHeight; + SVGA_FIFOCommitAll(); + SVGA_SyncToFence(SVGA_InsertFence()); + + SVGA_Update(halfWidth, 0, halfWidth, halfHeight); + SVGA_Update(0, halfHeight, halfWidth, halfHeight); + } + + return 0; +} diff --git a/examples/simple-blit/Makefile b/examples/simple-blit/Makefile new file mode 100644 index 0000000..beca387 --- /dev/null +++ b/examples/simple-blit/Makefile @@ -0,0 +1,6 @@ +TARGET = simple_blit.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/simple-blit/main.c b/examples/simple-blit/main.c new file mode 100644 index 0000000..3005d98 --- /dev/null +++ b/examples/simple-blit/main.c @@ -0,0 +1,104 @@ +/* + * SVGA3D example: Simple BLIT (Block Image Transfer) which updates + * the render target surface ID. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "types.h" +#include "svga3dutil.h" +#include "svga3dtext.h" + +FPSCounterState gFPS; + +/* + * Alpha, red, green, blue components of color. + */ +static uint32 a = 255, r = 0, g = 0, b = 0; + + +/* + * DMA pools allow for the allocation of GMR memory. + * The re-use policy is handled by the allocation routines. + */ +static uint32 blitSize = 0; +DMAPool blitDMA; + + +/* + * render -- + * + * Set up render state, and use surface DMA to update the + * render target with a solid color that goes from black + * to white. + * + */ + +void +render(void) +{ + DMAPoolBuffer *dma = NULL; + uint32 *buffer = NULL; + uint32 color; + + dma = SVGA3DUtil_DMAPoolGetBuffer(&blitDMA); + buffer = (uint32 *)dma->buffer; + + /* uint32 memset. */ + color = ((a&255) << 24) | ((r&255) << 16) | ((b&255) << 8) | (g&255); + memset32(buffer, color, blitSize / sizeof *buffer); + r++; g++; b++; + + /* + * Copy pixel data from our temporary memory in the GMR into + * the render target. This is a BLIT operation from memory + * in the guest to the host render target. + */ + SVGA3DUtil_SurfaceDMA2D(gFullscreen.colorImage.sid, &dma->ptr, + SVGA3D_WRITE_HOST_VRAM, + gSVGA.width, gSVGA.height); + SVGA3DUtil_AsyncCall((AsyncCallFn) SVGA3DUtil_DMAPoolFreeBuffer, dma); +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DText_Init(); + + /* + * Allocate 2 buffers for DMA. Each buffer is the size of the display + * so that we can fill the buffers with color data and DMA that buffer + * to the render target. + */ + blitSize = gSVGA.width * gSVGA.height * sizeof(uint32); + SVGA3DUtil_AllocDMAPool(&blitDMA, blitSize, 4); + + while (1) { + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "Simple BLIT of image into render target.\n%s", + gFPS.text); + SVGA3DText_Update(); + VMBackdoor_VGAScreenshot(); + } + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR, 0x113366, 1.0f, 0); + + render(); + + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + } + + return 0; +} diff --git a/examples/simple-shaders/Makefile b/examples/simple-shaders/Makefile new file mode 100644 index 0000000..488db46 --- /dev/null +++ b/examples/simple-shaders/Makefile @@ -0,0 +1,16 @@ +TARGET = simple-shaders.img + +APP_SOURCES = main.c + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules + +.PHONY: shaders + +shaders: simple_vs.h simple_ps.h + +simple_vs.h: simple.fx + wine fxc.exe /T vs_2_0 /E MyVertexShader /Fh simple_vs.h simple.fx + +simple_ps.h: simple.fx + wine fxc.exe /T ps_2_0 /E MyPixelShader /Fh simple_ps.h simple.fx diff --git a/examples/simple-shaders/main.c b/examples/simple-shaders/main.c new file mode 100644 index 0000000..aed3fbd --- /dev/null +++ b/examples/simple-shaders/main.c @@ -0,0 +1,249 @@ +/* + * SVGA3D example: Simple Shaders. + * + * This is a simple example to demonstrate the programmable pixel + * and vertex pipelines. A vertex shader animates a rippling surface, + * and a pixel shader generates a procedural checkerboard pattern. + * + * For simplicity, this example generates shader bytecode at + * compile-time using the Microsoft HLSL compiler. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "math.h" + +typedef uint32 DWORD; +#include "simple_vs.h" +#include "simple_ps.h" + +/* + * Small integers to identify our shaders. + */ +#define MY_VSHADER_ID 0 +#define MY_PSHADER_ID 0 + +/* + * Shader constants. These must match the constant registers in the + * bytecode we send the device, so in this example the constants are + * actually assigned by the Microsoft HLSL compiler. + */ +#define CONST_MAT_WORLDVIEWPROJ 0 +#define CONST_TIMESTEP 4 + +/* + * Macros for the simple mesh we generate as input for the vertex + * shader. It's a static grid in the XY plane. + */ +#define MESH_WIDTH 256 +#define MESH_HEIGHT 256 +#define MESH_NUM_VERTICES (MESH_WIDTH * MESH_HEIGHT) +#define MESH_NUM_QUADS ((MESH_WIDTH-1) * (MESH_HEIGHT-1)) +#define MESH_NUM_TRIANGLES (MESH_NUM_QUADS * 2) +#define MESH_NUM_INDICES (MESH_NUM_TRIANGLES * 3) +#define MESH_ELEMENT(x, y) (MESH_WIDTH * (y) + (x)) + +typedef struct { + float position[3]; +} MyVertex; + +typedef uint16 IndexType; +uint32 vertexSid, indexSid; +FPSCounterState gFPS; + + +/* + * render -- + * + * Set up render state that we load once per frame (because + * SVGA3DText clobbered it) and render the scene. + */ + +void +render(void) +{ + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + SVGA3dRenderState *rs; + + float shaderTimestep[4] = { gFPS.frame * 0.01 }; + + SVGA3D_SetShaderConst(CID, CONST_TIMESTEP, SVGA3D_SHADERTYPE_VS, + SVGA3D_CONST_TYPE_FLOAT, shaderTimestep); + + SVGA3D_BeginSetRenderState(CID, &rs, 4); + { + rs[0].state = SVGA3D_RS_BLENDENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZENABLE; + rs[1].uintValue = TRUE; + + rs[2].state = SVGA3D_RS_ZWRITEENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_ZFUNC; + rs[3].uintValue = SVGA3D_CMP_LESS; + } + SVGA_FIFOCommitAll(); + + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, MY_VSHADER_ID); + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, MY_PSHADER_ID); + + SVGA3D_BeginDrawPrimitives(CID, &decls, 1, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = vertexSid; + decls[0].array.stride = sizeof(MyVertex); + decls[0].array.offset = offsetof(MyVertex, position); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = MESH_NUM_TRIANGLES; + ranges[0].indexArray.surfaceId = indexSid; + ranges[0].indexArray.stride = sizeof(IndexType); + ranges[0].indexWidth = sizeof(IndexType); + } + SVGA_FIFOCommitAll(); + + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, SVGA3D_INVALID_ID); + SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, SVGA3D_INVALID_ID); +} + + +/* + * createIndexBuffer -- + * + * Create a static index buffer that renders our vertices as a 2D + * mesh. For simplicity, we use a triangle list rather than a + * triangle strip. + */ + +uint32 +createIndexBuffer(void) +{ + IndexType *indexBuffer; + const uint32 bufferSize = MESH_NUM_INDICES * sizeof *indexBuffer; + SVGAGuestPtr gPtr; + uint32 sid; + int x, y; + + sid = SVGA3DUtil_DefineSurface2D(bufferSize, 1, SVGA3D_BUFFER); + indexBuffer = SVGA3DUtil_AllocDMABuffer(bufferSize, &gPtr); + + for (y = 0; y < (MESH_HEIGHT - 1); y++) { + for (x = 0; x < (MESH_WIDTH - 1); x++) { + + indexBuffer[0] = MESH_ELEMENT(x, y ); + indexBuffer[1] = MESH_ELEMENT(x+1, y ); + indexBuffer[2] = MESH_ELEMENT(x+1, y+1); + + indexBuffer[3] = MESH_ELEMENT(x+1, y+1); + indexBuffer[4] = MESH_ELEMENT(x, y+1); + indexBuffer[5] = MESH_ELEMENT(x, y ); + + indexBuffer += 6; + } + } + + SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, bufferSize, 1); + + return sid; +} + + +/* + * createVertexBuffer -- + * + * Create a static vertex buffer that renders a mesh on thee XY + * plane. For simplicity, we use a triangle list rather than a + * triangle strip. + */ + +uint32 +createVertexBuffer(void) +{ + MyVertex *vert; + const uint32 bufferSize = MESH_NUM_VERTICES * sizeof(MyVertex); + SVGAGuestPtr gPtr; + uint32 sid; + int x, y; + + sid = SVGA3DUtil_DefineSurface2D(bufferSize, 1, SVGA3D_BUFFER); + vert = SVGA3DUtil_AllocDMABuffer(bufferSize, &gPtr); + + for (y = 0; y < MESH_HEIGHT; y++) { + for (x = 0; x < MESH_WIDTH; x++) { + + vert->position[0] = x * (2.0 / MESH_WIDTH) - 1.0; + vert->position[1] = y * (2.0 / MESH_HEIGHT) - 1.0; + vert->position[2] = 0.0f; + + vert++; + } + } + + SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, bufferSize, 1); + + return sid; +} + + +/* + * main -- + * + * Our example's entry point, invoked directly by the bootloader. + */ + +int +main(void) +{ + Matrix worldViewProj, proj; + + SVGA3DUtil_InitFullscreen(CID, 800, 600); + SVGA3DText_Init(); + + vertexSid = createVertexBuffer(); + indexSid = createIndexBuffer(); + + SVGA3D_DefineShader(CID, MY_VSHADER_ID, SVGA3D_SHADERTYPE_VS, + g_vs20_MyVertexShader, sizeof g_vs20_MyVertexShader); + SVGA3D_DefineShader(CID, MY_PSHADER_ID, SVGA3D_SHADERTYPE_PS, + g_ps20_MyPixelShader, sizeof g_ps20_MyPixelShader); + + /* + * Compute a single matrix for the world, view, and projection + * transforms, then upload that to the shader. + */ + + Matrix_Copy(worldViewProj, gIdentityMatrix); + Matrix_RotateX(worldViewProj, 60.0 * PI_OVER_180); + Matrix_Translate(worldViewProj, 0, 0, 3); + Matrix_Perspective(proj, 45.0f, gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); + Matrix_Multiply(worldViewProj, proj); + + SVGA3DUtil_SetShaderConstMatrix(CID, CONST_MAT_WORLDVIEWPROJ, + SVGA3D_SHADERTYPE_VS, worldViewProj); + + while (1) { + if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { + Console_Clear(); + Console_Format("VMware SVGA3D Example:\n" + "Simple Shaders.\n\n%s", + gFPS.text); + SVGA3DText_Update(); + } + + SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, + 0x113366, 1.0f, 0); + render(); + SVGA3DText_Draw(); + SVGA3DUtil_PresentFullscreen(); + } + + return 0; +} diff --git a/examples/simple-shaders/simple.fx b/examples/simple-shaders/simple.fx new file mode 100644 index 0000000..82c9224 --- /dev/null +++ b/examples/simple-shaders/simple.fx @@ -0,0 +1,60 @@ +float4x4 matWorldViewProj; +float timestep; + +struct VS_Output +{ + float4 Pos : POSITION; + float4 Coord : TEXCOORD0; +}; + +VS_Output +MyVertexShader(float4 inputPos : POSITION) +{ + VS_Output Output; + float4 objectCoord = inputPos; + + float dist = pow(objectCoord.x, 2) + pow(objectCoord.y, 2); + objectCoord.z = sin(dist * 8.0 + timestep) / (1 + dist * 10.0); + + Output.Pos = mul(objectCoord, matWorldViewProj); + Output.Coord = objectCoord; + + return Output; +} + +struct PS_Input +{ + float4 Coord : TEXCOORD0; +}; + +float4 +MyPixelShader(PS_Input Input) : COLOR +{ + /* + * Simple 2D procedural checkerboard. + */ + + const float4 color1 = { 0.25, 0.25, 0.25, 1.0 }; + const float4 color2 = { 1.0, 1.0, 1.0, 1.0 }; + const float checkerSize = 0.2; + + float2 s = fmod(Input.Coord.xy / checkerSize, 1); + + float check = ( (float)(s.x > 0.5 || (s.x < 0 && s.x > -0.5)) + + (float)(s.y > 0.5 || (s.y < 0 && s.y > -0.5)) ); + + float4 color = lerp(color1, color2, fmod(check, 2)); + + /* + * Do a little fake shading + */ + + const float4 shadeTop = { 1.0, 1.0, 0.5, 1.0 }; + const float4 shadeBottom = { 0.5, 0.5, 1.0, 1.0 }; + float z = Input.Coord.z * 2; + + color = lerp(color, shadeBottom, clamp(z, 0, 0.25)); + color = lerp(color, shadeTop, clamp(-z, 0, 0.25)); + + return color; +} diff --git a/examples/simple-shaders/simple_ps.h b/examples/simple-shaders/simple_ps.h new file mode 100644 index 0000000..15eafca --- /dev/null +++ b/examples/simple-shaders/simple_ps.h @@ -0,0 +1,89 @@ +#if 0 +// +// Generated by Microsoft (R) D3DX9 Shader Compiler +// +// fxc /T ps_2_0 /E MyPixelShader /Fh simple_ps.h simple.fx +// + ps_2_0 + def c0, 5, 0.5, 0, 1 + def c1, -0.5, 0.25, 0, 0 + def c2, 0.25, 0.25, 1, 0 + def c3, 1.5, 1.5, 0, 0 + def c4, 0.5, 1, 1, 0 + def c5, 1, 0.5, 1, 0 + dcl t0.xyz + mul r0.xy, t0, c0.x + abs r0.xy, r0 + frc r0.xy, r0 + cmp r0.xy, t0, r0, -r0 + add r0.w, -r0.x, c0.y + cmp r0.w, r0.w, c0.z, c0.w + add r1.w, -r0.x, c1.x + cmp r1.w, r1.w, c0.z, c0.w + cmp r2.w, r0.x, c0.z, c0.w + mad r0.w, r2.w, r1.w, r0.w + cmp r0.w, -r0.w, c0.z, c0.w + add r1.w, -r0.y, c0.y + cmp r1.w, r1.w, c0.z, c0.w + add r2.w, -r0.y, c1.x + cmp r3.w, r0.y, c0.z, c0.w + cmp r2.w, r2.w, c0.z, c0.w + mad r1.w, r3.w, r2.w, r1.w + cmp r1.w, -r1.w, c0.z, c0.w + add r0.w, r0.w, r1.w + mul r0.w, r0.w, c0.y + frc r0.w, r0.w + mov r0.xyz, c3 + mad r0.xyz, r0.w, r0, c2 + add r0.w, t0.z, t0.z + max r1.w, r0.w, c0.z + max r2.w, -r0.w, c0.z + min r0.w, r1.w, c1.y + lrp r1.xyz, r0.w, c4, r0 + min r0.w, r2.w, c1.y + lrp r2.xyz, r0.w, c5, r1 + mov r0.xy, r2.x + mov r0.w, r2.z + mov r0.z, r2.y + mov oC0, r0 + +// approximately 34 instruction slots used +#endif + +const DWORD g_ps20_MyPixelShader[] = +{ + 0xffff0200, 0x0013fffe, 0x42415443, 0x0000001c, 0x00000023, 0xffff0200, + 0x00000000, 0x00000000, 0x20000100, 0x0000001c, 0x325f7370, 0x4d00305f, + 0x6f726369, 0x74666f73, 0x29522820, 0x44334420, 0x53203958, 0x65646168, + 0x6f432072, 0x6c69706d, 0x00207265, 0x05000051, 0xa00f0000, 0x40a00000, + 0x3f000000, 0x00000000, 0x3f800000, 0x05000051, 0xa00f0001, 0xbf000000, + 0x3e800000, 0x00000000, 0x00000000, 0x05000051, 0xa00f0002, 0x3e800000, + 0x3e800000, 0x3f800000, 0x00000000, 0x05000051, 0xa00f0003, 0x3fc00000, + 0x3fc00000, 0x00000000, 0x00000000, 0x05000051, 0xa00f0004, 0x3f000000, + 0x3f800000, 0x3f800000, 0x00000000, 0x05000051, 0xa00f0005, 0x3f800000, + 0x3f000000, 0x3f800000, 0x00000000, 0x0200001f, 0x80000000, 0xb0070000, + 0x03000005, 0x80030000, 0xb0e40000, 0xa0000000, 0x02000023, 0x80030000, + 0x80e40000, 0x02000013, 0x80030000, 0x80e40000, 0x04000058, 0x80030000, + 0xb0e40000, 0x80e40000, 0x81e40000, 0x03000002, 0x80080000, 0x81000000, + 0xa0550000, 0x04000058, 0x80080000, 0x80ff0000, 0xa0aa0000, 0xa0ff0000, + 0x03000002, 0x80080001, 0x81000000, 0xa0000001, 0x04000058, 0x80080001, + 0x80ff0001, 0xa0aa0000, 0xa0ff0000, 0x04000058, 0x80080002, 0x80000000, + 0xa0aa0000, 0xa0ff0000, 0x04000004, 0x80080000, 0x80ff0002, 0x80ff0001, + 0x80ff0000, 0x04000058, 0x80080000, 0x81ff0000, 0xa0aa0000, 0xa0ff0000, + 0x03000002, 0x80080001, 0x81550000, 0xa0550000, 0x04000058, 0x80080001, + 0x80ff0001, 0xa0aa0000, 0xa0ff0000, 0x03000002, 0x80080002, 0x81550000, + 0xa0000001, 0x04000058, 0x80080003, 0x80550000, 0xa0aa0000, 0xa0ff0000, + 0x04000058, 0x80080002, 0x80ff0002, 0xa0aa0000, 0xa0ff0000, 0x04000004, + 0x80080001, 0x80ff0003, 0x80ff0002, 0x80ff0001, 0x04000058, 0x80080001, + 0x81ff0001, 0xa0aa0000, 0xa0ff0000, 0x03000002, 0x80080000, 0x80ff0000, + 0x80ff0001, 0x03000005, 0x80080000, 0x80ff0000, 0xa0550000, 0x02000013, + 0x80080000, 0x80ff0000, 0x02000001, 0x80070000, 0xa0e40003, 0x04000004, + 0x80070000, 0x80ff0000, 0x80e40000, 0xa0e40002, 0x03000002, 0x80080000, + 0xb0aa0000, 0xb0aa0000, 0x0300000b, 0x80080001, 0x80ff0000, 0xa0aa0000, + 0x0300000b, 0x80080002, 0x81ff0000, 0xa0aa0000, 0x0300000a, 0x80080000, + 0x80ff0001, 0xa0550001, 0x04000012, 0x80070001, 0x80ff0000, 0xa0e40004, + 0x80e40000, 0x0300000a, 0x80080000, 0x80ff0002, 0xa0550001, 0x04000012, + 0x80070002, 0x80ff0000, 0xa0e40005, 0x80e40001, 0x02000001, 0x80030000, + 0x80000002, 0x02000001, 0x80080000, 0x80aa0002, 0x02000001, 0x80040000, + 0x80550002, 0x02000001, 0x800f0800, 0x80e40000, 0x0000ffff +}; diff --git a/examples/simple-shaders/simple_vs.h b/examples/simple-shaders/simple_vs.h new file mode 100644 index 0000000..2e4ba48 --- /dev/null +++ b/examples/simple-shaders/simple_vs.h @@ -0,0 +1,75 @@ +#if 0 +// +// Generated by Microsoft (R) D3DX9 Shader Compiler +// +// fxc /T vs_2_0 /E MyVertexShader /Fh simple_vs.h simple.fx +// +// +// Parameters: +// +// float4x4 matWorldViewProj; +// float timestep; +// +// +// Registers: +// +// Name Reg Size +// ---------------- ----- ---- +// matWorldViewProj c0 4 +// timestep c4 1 +// + + vs_2_0 + def c5, 8, 0.159154937, 0.5, 0 + def c6, 6.28318548, -3.14159274, 10, 1 + def c7, -1.55009923e-06, -2.17013894e-05, 0.00260416674, 0.00026041668 + def c8, -0.020833334, -0.125, 1, 0.5 + dcl_position v0 + mul r0.xy, v0, v0 + add r0.x, r0.y, r0.x + mov r1.x, c5.x + mad r0.y, r0.x, r1.x, c4.x + mad r0.x, r0.x, c6.z, c6.w + mad r0.y, r0.y, c5.y, c5.z + frc r0.y, r0.y + mad r0.y, r0.y, c6.x, c6.y + sincos r1.y, r0.y, c7, c8 + rcp r0.x, r0.x + mul r0.z, r1.y, r0.x + mov r0.xyw, v0 + dp4 oPos.x, r0, c0 + dp4 oPos.y, r0, c1 + dp4 oPos.z, r0, c2 + dp4 oPos.w, r0, c3 + mov oT0, r0 + +// approximately 24 instruction slots used +#endif + +const DWORD g_vs20_MyVertexShader[] = +{ + 0xfffe0200, 0x002dfffe, 0x42415443, 0x0000001c, 0x0000008b, 0xfffe0200, + 0x00000002, 0x0000001c, 0x20000100, 0x00000084, 0x00000044, 0x00000002, + 0x00000004, 0x00000058, 0x00000000, 0x00000068, 0x00040002, 0x00000001, + 0x00000074, 0x00000000, 0x5774616d, 0x646c726f, 0x77656956, 0x6a6f7250, + 0xababab00, 0x00030003, 0x00040004, 0x00000001, 0x00000000, 0x656d6974, + 0x70657473, 0xababab00, 0x00030000, 0x00010001, 0x00000001, 0x00000000, + 0x325f7376, 0x4d00305f, 0x6f726369, 0x74666f73, 0x29522820, 0x44334420, + 0x53203958, 0x65646168, 0x6f432072, 0x6c69706d, 0x00207265, 0x05000051, + 0xa00f0005, 0x41000000, 0x3e22f983, 0x3f000000, 0x00000000, 0x05000051, + 0xa00f0006, 0x40c90fdb, 0xc0490fdb, 0x41200000, 0x3f800000, 0x05000051, + 0xa00f0007, 0xb5d00d01, 0xb7b60b61, 0x3b2aaaab, 0x39888889, 0x05000051, + 0xa00f0008, 0xbcaaaaab, 0xbe000000, 0x3f800000, 0x3f000000, 0x0200001f, + 0x80000000, 0x900f0000, 0x03000005, 0x80030000, 0x90e40000, 0x90e40000, + 0x03000002, 0x80010000, 0x80550000, 0x80000000, 0x02000001, 0x80010001, + 0xa0000005, 0x04000004, 0x80020000, 0x80000000, 0x80000001, 0xa0000004, + 0x04000004, 0x80010000, 0x80000000, 0xa0aa0006, 0xa0ff0006, 0x04000004, + 0x80020000, 0x80550000, 0xa0550005, 0xa0aa0005, 0x02000013, 0x80020000, + 0x80550000, 0x04000004, 0x80020000, 0x80550000, 0xa0000006, 0xa0550006, + 0x04000025, 0x80020001, 0x80550000, 0xa0e40007, 0xa0e40008, 0x02000006, + 0x80010000, 0x80000000, 0x03000005, 0x80040000, 0x80550001, 0x80000000, + 0x02000001, 0x800b0000, 0x90e40000, 0x03000009, 0xc0010000, 0x80e40000, + 0xa0e40000, 0x03000009, 0xc0020000, 0x80e40000, 0xa0e40001, 0x03000009, + 0xc0040000, 0x80e40000, 0xa0e40002, 0x03000009, 0xc0080000, 0x80e40000, + 0xa0e40003, 0x02000001, 0xe00f0000, 0x80e40000, 0x0000ffff +}; diff --git a/examples/video-formats/Makefile b/examples/video-formats/Makefile new file mode 100644 index 0000000..b23eda0 --- /dev/null +++ b/examples/video-formats/Makefile @@ -0,0 +1,6 @@ +TARGET = video-formats.img + +APP_SOURCES = main.c screen.png.data.o wols4x3.yuv.z.data.o + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/video-formats/main.c b/examples/video-formats/main.c new file mode 100644 index 0000000..c6ecb59 --- /dev/null +++ b/examples/video-formats/main.c @@ -0,0 +1,297 @@ +/* + * video-formats -- Demonstrate all supported video overlay formats. + * + * XXX: There are some known bugs in the currently released VMware + * products, which are exposed by this test: + * + * 1. The very first VideoFlush may not appear. In this test, + * the bug manifests as "No Overlay" for test #1. + * + * 2. Software emulated scaling is very low quality. + * + * 3. If the host is using hardware video overlay rather than + * its software fallback, it assumes that colorkey is always + * enabled. This means our video will only draw in the black + * portions of the background image (inside the "X", and + * the box around the "No overlay" text.) + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + + +#include "svga.h" +#include "png.h" +#include "intr.h" +#include "datafile.h" + + +/* + * This is our video test card, in UYVY format. + * + * It's a 720x576 pixel 4:3 aspect test card designed by Barney + * Wol. (http://www.barney-wol.net/testpatterns) + */ + +DECLARE_DATAFILE(testCardFile, wols4x3_yuv_z); + +#define TESTCARD_WIDTH 720 +#define TESTCARD_HEIGHT 576 + + +/* + * Our background image, in PNG format. + * + * This has 'cutouts' where we're supposed to display the test + * pattern. Each of these are described by the table of overlay + * settings below. + */ + +DECLARE_DATAFILE(screenPNGFile, screen_png); + +#define OFFSET_YUY2 0x400000 +#define OFFSET_UYVY 0x500000 +#define OFFSET_YV12 0x600000 + +static SVGAOverlayUnit overlays[] = { + // #0 - YUY2 Large + { + .enabled = TRUE, + .format = VMWARE_FOURCC_YUY2, + .width = TESTCARD_WIDTH, + .height = TESTCARD_HEIGHT, + .srcWidth = TESTCARD_WIDTH, + .srcHeight = TESTCARD_HEIGHT, + .dstX = 109, + .dstY = 407, + .dstWidth = 320, + .dstHeight = 240, + .pitches[0] = TESTCARD_WIDTH * 2, + .dataOffset = OFFSET_YUY2, + }, + + // #1 - YV12 Large + { + .enabled = TRUE, + .format = VMWARE_FOURCC_YV12, + .width = TESTCARD_WIDTH, + .height = TESTCARD_HEIGHT, + .srcWidth = TESTCARD_WIDTH, + .srcHeight = TESTCARD_HEIGHT, + .dstX = 564, + .dstY = 58, + .dstWidth = 320, + .dstHeight = 240, + .pitches[0] = TESTCARD_WIDTH, + .pitches[1] = TESTCARD_WIDTH / 2, + .pitches[2] = TESTCARD_WIDTH / 2, + .dataOffset = OFFSET_YV12, + }, + + // #2 - UYVY Large + { + .enabled = TRUE, + .format = VMWARE_FOURCC_UYVY, + .width = TESTCARD_WIDTH, + .height = TESTCARD_HEIGHT, + .srcWidth = TESTCARD_WIDTH, + .srcHeight = TESTCARD_HEIGHT, + .dstX = 564, + .dstY = 407, + .dstWidth = 320, + .dstHeight = 240, + .pitches[0] = TESTCARD_WIDTH * 2, + .dataOffset = OFFSET_UYVY, + }, + + // #3 - YUY2 Small + { + .enabled = TRUE, + .format = VMWARE_FOURCC_YUY2, + .width = TESTCARD_WIDTH, + .height = TESTCARD_HEIGHT, + .srcX = 34, + .srcY = 31, + .srcWidth = 76, + .srcHeight = 79, + .dstX = 109, + .dstY = 652, + .dstWidth = 64, + .dstHeight = 64, + .pitches[0] = TESTCARD_WIDTH * 2, + .dataOffset = OFFSET_YUY2, + }, + + // #4 - YV12 Small + { + .enabled = TRUE, + .format = VMWARE_FOURCC_YV12, + .width = TESTCARD_WIDTH, + .height = TESTCARD_HEIGHT, + .srcX = 34, + .srcY = 31, + .srcWidth = 76, + .srcHeight = 79, + .dstX = 564, + .dstY = 303, + .dstWidth = 64, + .dstHeight = 64, + .pitches[0] = TESTCARD_WIDTH, + .pitches[1] = TESTCARD_WIDTH / 2, + .pitches[2] = TESTCARD_WIDTH / 2, + .dataOffset = OFFSET_YV12, + }, + + // #5 - UYVY Small + { + .enabled = TRUE, + .format = VMWARE_FOURCC_UYVY, + .width = TESTCARD_WIDTH, + .height = TESTCARD_HEIGHT, + .srcX = 34, + .srcY = 31, + .srcWidth = 76, + .srcHeight = 79, + .dstX = 564, + .dstY = 652, + .dstWidth = 64, + .dstHeight = 64, + .pitches[0] = TESTCARD_WIDTH * 2, + .dataOffset = OFFSET_UYVY, + }, +}; + + +/* + * convertUYVYtoYUY2 -- + * + * Convert the test card image from UYVY format to YUY2. + * Both of these are packed-pixel formats, they just use + * different byte orders. + */ + +static void +convertUYVYtoYUY2(uint8 *src, // IN + uint8 *dest) // OUT +{ + uint32 numWords = TESTCARD_WIDTH / 2 * TESTCARD_HEIGHT; + + while (numWords--) { + uint8 u = *(src++); + uint8 y1 = *(src++); + uint8 v = *(src++); + uint8 y2 = *(src++); + + *(dest++) = y1; + *(dest++) = u; + *(dest++) = y2; + *(dest++) = v; + } +} + + +/* + * convertUYVYtoYV12 -- + * + * Convert the test card image from UYVY format (packed pixel) to + * YV12 (planar). This vertically decimates the chroma planes by + * 1/2. + */ + +static void +convertUYVYtoYV12(uint8 *src, // IN + uint8 *dest) // OUT +{ + /* + * Y plane, full resolution. + */ + + uint8 *s = src; + uint32 numWords = TESTCARD_WIDTH / 2 * TESTCARD_HEIGHT; + while (numWords--) { + s++; // U + *(dest++) = *(s++); // Y1 + s++; // V + *(dest++) = *(s++); // Y2 + } + + /* + * U and V planes, at 1/2 height. + */ + + uint32 x, y; + const uint32 pitch = TESTCARD_WIDTH * 2; + uint8 *line1 = src; + uint8 *v = dest; + uint8 *u = v + (TESTCARD_WIDTH * TESTCARD_HEIGHT) / 4; + + for (y = TESTCARD_HEIGHT/2; y; y--) { + uint8 *line2 = line1 + pitch; + + for (x = TESTCARD_WIDTH/2; x; x--) { + + uint8 u1 = *(line1)++; // U + line1++; // Y1 + uint8 v1 = *(line1)++; // V + line1++; // Y2 + + uint8 u2 = *(line2)++; // U + line2++; // Y1 + uint8 v2 = *(line2)++; // V + line2++; // Y2 + + *(u++) = ((int)u1 + (int)u2) >> 1; + *(v++) = ((int)v1 + (int)v2) >> 1; + } + + line1 = line2; + } +} + + +/* + * main -- + * + * Set up the virtual hardware, decompress the YUV images, and + * program the overlay units. + */ + +int +main(void) +{ + PNGChunkIHDR *screenPNG = PNG_Header(screenPNGFile->ptr); + uint32 width = bswap32(screenPNG->width); + uint32 height = bswap32(screenPNG->height); + uint32 streamId; + + Intr_Init(); + Intr_SetFaultHandlers(SVGA_DefaultFaultHandler); + SVGA_Init(); + SVGA_SetMode(width, height, 32); + + /* + * Draw the background image + */ + + PNG_DecompressBGRX(screenPNG, (uint32*) gSVGA.fbMem, gSVGA.pitch); + SVGA_Update(0, 0, width, height); + + /* + * Decompress the YUY2 image, and use it to generate UYVY and YV12 versions. + */ + + DataFile_Decompress(testCardFile, gSVGA.fbMem + OFFSET_UYVY, 0x100000); + convertUYVYtoYUY2(gSVGA.fbMem + OFFSET_UYVY, gSVGA.fbMem + OFFSET_YUY2); + convertUYVYtoYV12(gSVGA.fbMem + OFFSET_UYVY, gSVGA.fbMem + OFFSET_YV12); + + /* + * Program the overlay units + */ + + for (streamId = 0; streamId < arraysize(overlays); streamId++) { + SVGA_VideoSetAllRegs(streamId, &overlays[streamId], SVGA_VIDEO_PITCH_3); + SVGA_VideoFlush(streamId); + } + + return 0; +} diff --git a/examples/video-formats/screen.png b/examples/video-formats/screen.png new file mode 100644 index 0000000..e24d7f1 Binary files /dev/null and b/examples/video-formats/screen.png differ diff --git a/examples/video-formats/wols4x3.yuv b/examples/video-formats/wols4x3.yuv new file mode 100644 index 0000000..c56de22 --- /dev/null +++ b/examples/video-formats/wols4x3.yuv @@ -0,0 +1 @@ +€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€‰€·€è€Ü€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¿€ë€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ë€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ü€è€·€‰€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¨€Ç€è€á€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Í€ê€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€ê€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€á€è€Ç€¨€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ç€Þ€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€ß€è€ë€ä€Ü€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Þ€ç€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Ì€é€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€Í€•€z€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€|€ž€×€ê€½€Š€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€z€•€Í€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€é€Ì€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¾€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¿€m€G€H€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€G€I€z€Î€é€§€]€F€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€H€G€m€¿€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€¾€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€…€‰€Œ€€€‹€ˆ€„€€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€€„€ˆ€‹€€€Œ€‰€…€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€ƒ€€Ÿ€¯€½€É€Ð€Ö€Ù€Û€Û€Ø€Õ€Î€Å€¸€ª€š€Œ€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€Œ€š€ª€¸€Å€Î€Õ€Ø€Û€Û€Ù€Ö€Ð€É€½€¯€Ÿ€€ƒ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€‡€š€²€É€Ú€å€ë€ë€é€è€è€è€è€è€è€è€é€ê€ë€é€â€Ö€Ã€«€”€ƒ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€ƒ€”€«€Ã€Ö€â€é€ë€ê€é€è€è€è€è€è€è€è€é€ë€ë€å€Ú€É€²€š€‡€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€“€°€Ì€á€ë€é€è€è€é€ë€ë€é€è€ç€æ€æ€ç€è€ê€ë€ê€è€è€è€ë€é€Ü€Å€§€Œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€Œ€§€Å€Ü€é€ë€è€è€è€ê€ë€ê€è€ç€æ€æ€ç€è€é€ë€ë€é€è€è€é€ë€á€Ì€°€“€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€˜€»€Ù€é€ê€è€é€ë€è€Ý€Ï€À€³€§€Ÿ€™€—€—€š€¡€«€·€Å€Ô€á€é€ë€é€è€ë€ç€Ñ€°€€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€€°€Ñ€ç€ë€è€é€ë€é€á€Ô€Å€·€«€¡€š€—€—€™€Ÿ€§€³€À€Ï€Ý€è€ë€é€è€ê€é€Ù€»€˜€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€”€º€Ü€ê€è€é€ë€ä€Ò€¹€Ÿ€…€m€Z€J€?€8€3€1€1€4€:€C€O€`€t€Œ€¥€À€Ø€è€ë€è€é€è€Ó€®€Œ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€Œ€®€Ó€è€é€è€ë€è€Ø€À€¥€Œ€t€`€O€C€:€4€1€1€3€8€?€J€Z€m€…€Ÿ€¹€Ò€ä€ë€é€è€ê€Ü€º€”€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‰€®€Ö€é€è€é€é€Ú€»€˜€t€T€:€&€€€€€€€€€€€€€€€+€@€\€}€¡€Ä€à€ë€è€é€æ€Ì€£€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€£€Ì€æ€é€è€ë€à€Ä€¡€}€\€@€+€€€€€€€€€€€€€€€&€:€T€t€˜€»€Ú€é€é€è€é€Ö€®€‰€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€›€Æ€ä€é€é€ê€Ö€¯€‚€X€6€€€€€€,€9€D€M€S€V€V€Q€J€A€5€(€€€€€$€>€c€€¼€Þ€ë€é€é€ß€º€‘€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€‘€º€ß€é€é€ë€Þ€¼€€c€>€$€€€€€(€5€A€J€Q€V€V€S€M€D€9€,€€€€€€6€X€‚€¯€Ö€ê€é€é€ä€Æ€›€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€†€«€×€ê€è€ë€Ü€±€~€N€)€€€€,€E€`€y€Ž€Ÿ€­€¶€»€½€½€º€³€©€š€‡€q€X€>€&€€€€1€\€€¿€ã€ë€è€é€Í€Ÿ€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€Ÿ€Í€é€è€ë€ã€¿€€\€1€€€€&€>€X€q€‡€š€©€³€º€½€½€»€¶€­€Ÿ€Ž€y€`€E€,€€€€)€N€~€±€Ü€ë€è€ê€×€«€†€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€¹€á€é€ë€æ€Â€Š€R€'€€€%€D€h€€«€Ä€Ö€â€ç€ê€ë€ë€ë€ë€ë€ë€é€æ€Þ€Ñ€½€¤€ƒ€^€;€€€€2€b€›€Ï€é€é€é€Ù€«€…€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€…€«€Ù€é€é€é€Ï€›€b€2€€€€;€^€ƒ€¤€½€Ñ€Þ€æ€é€ë€ë€ë€ë€ë€ë€ê€ç€â€Ö€Ä€«€€h€D€%€€€'€R€Š€Â€æ€ë€é€á€¹€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€“€Â€æ€é€ë€Ú€¦€g€1€€€)€P€~€¨€Ê€ß€ê€ë€å€Û€Ð€Ä€¼€·€´€´€·€¾€È€Ó€Þ€è€ë€è€Ú€Â€€q€D€€€€?€y€·€â€ë€é€à€³€ˆ€{€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€{€ˆ€³€à€é€ë€â€·€y€?€€€€D€q€€Â€Ú€è€ë€è€Þ€Ó€È€¾€·€´€´€·€¼€Ä€Ð€Û€å€ë€ê€ß€Ê€¨€~€P€)€€€1€g€¦€Ú€ë€é€æ€Â€“€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€|€•€È€é€ê€ê€Ê€€L€€€"€L€€±€Ö€è€ë€ß€Ê€±€˜€€n€_€T€N€J€J€O€W€c€t€ˆ€ €¹€Ñ€ã€ë€å€Í€¥€q€>€€€'€]€Ÿ€×€ê€ë€ä€¸€‰€{€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€{€‰€¸€ä€ë€ê€×€Ÿ€]€'€€€>€q€¥€Í€å€ë€ã€Ñ€¹€ €ˆ€t€c€W€O€J€J€N€T€_€n€€˜€±€Ê€ß€ë€è€Ö€±€€L€"€€€L€€Ê€ê€ê€é€È€•€|€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€|€|€•€Ê€è€ê€ç€½€y€8€€€:€r€«€Ö€ê€è€Ó€²€€j€L€4€%€€€€€€€€€€€)€;€T€t€—€¼€Ú€ê€ç€Ë€š€a€,€€€H€€Í€ê€ê€â€º€Š€{€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€}€{€Š€º€â€ê€ê€Í€€H€€€,€a€š€Ë€ç€ê€Ú€¼€—€t€T€;€)€€€€€€€€€€€%€4€L€j€€²€Ó€è€ê€Ö€«€r€:€€€8€y€½€ç€ê€è€Ê€•€|€|€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€|€{€’€È€ç€ë€å€µ€k€+€€€R€“€Ê€è€è€Ð€¦€x€O€.€€€€€ €*€2€8€:€:€7€0€&€€€€€€5€Y€„€²€Ù€ë€â€¼€€€A€€€:€€€È€ë€ê€â€·€‡€{€}€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€}€{€‡€·€â€ê€ë€È€€€:€€€A€€€¼€â€ë€Ù€²€„€Y€5€€€€€€&€0€7€:€:€8€2€*€ €€€€€.€O€x€¦€Ð€è€è€Ê€“€R€€€+€k€µ€å€ë€ç€È€’€{€|€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€{€€Â€æ€ë€å€±€c€$€€+€h€«€Ý€ë€Ø€¬€v€E€#€€€€3€M€e€z€‹€˜€Ÿ€¢€¢€€”€†€t€]€D€,€€€€*€Q€‡€»€â€ë€Ñ€™€U€€€2€z€Æ€ë€ê€ß€±€„€|€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€|€„€±€ß€ê€ë€Æ€z€2€€€U€™€Ñ€ë€â€»€‡€Q€*€€€€,€D€]€t€†€”€€¢€¢€Ÿ€˜€‹€z€e€M€3€€€€#€E€v€¬€Ø€ë€Ý€«€h€+€€$€c€±€å€ë€æ€Â€€{€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€{€‡€¸€â€ë€æ€³€b€!€€3€w€½€ç€è€Â€ˆ€M€$€€€,€N€t€–€´€Ê€×€à€å€è€è€è€ç€ä€Ý€Ó€Ã€«€€i€D€%€€€-€]€›€Ð€ë€Þ€«€c€%€€/€z€É€ë€ê€Ú€¨€€|€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€|€€¨€Ú€ê€ë€É€z€/€€%€c€«€Þ€ë€Ð€›€]€-€€€%€D€i€€«€Ã€Ó€Ý€ä€ç€è€è€è€å€à€×€Ê€´€–€t€N€,€€€$€M€ˆ€Â€è€ç€½€w€3€€!€b€³€æ€ë€â€¸€‡€{€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€{€€«€Þ€ë€é€»€f€"€€8€€Ç€ë€ß€¬€j€1€€€.€Y€‡€±€Ð€ä€ë€ê€ã€Ü€Ô€Ï€Ì€Ì€Ð€Ö€Þ€æ€ë€ê€ß€É€§€{€L€%€€€@€~€½€ç€å€·€l€'€€1€€€Ð€ë€ë€Ò€œ€}€}€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€}€}€œ€Ò€ë€ë€Ð€€€1€€'€l€·€å€ç€½€~€@€€€%€L€{€§€É€ß€ê€ë€æ€Þ€Ö€Ð€Ì€Ì€Ï€Ô€Ü€ã€ê€ë€ä€Ð€±€‡€Y€.€€€1€j€¬€ß€ë€Ç€€8€€"€f€»€é€ë€Þ€«€€{€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€|€}€€Õ€ë€ë€Ç€q€&€€8€„€Ì€ë€×€œ€U€€€#€P€‡€¹€Ü€ê€è€Ú€Ã€«€•€‚€t€l€h€h€n€y€ˆ€œ€´€Ë€ß€ë€è€Ô€­€y€A€€€-€i€°€â€è€»€m€&€€8€Œ€Ù€ë€ê€Æ€€|€}€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€}€|€€Æ€ê€ë€Ù€Œ€8€€&€m€»€è€â€°€i€-€€€A€y€­€Ô€è€ë€ß€Ë€´€œ€ˆ€y€n€h€h€l€t€‚€•€«€Ã€Ú€è€ê€Ü€¹€‡€P€#€€€U€œ€×€ë€Ì€„€8€€&€q€Ç€ë€ë€Õ€€}€|€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€|€Ž€Å€è€ë€Õ€„€0€€1€€Ì€ë€Ó€‘€G€€€7€r€®€Ù€ë€ä€Ë€¨€‚€_€D€1€%€€€€€€€(€7€M€j€€²€Ó€è€é€Ð€ž€_€(€€!€[€¥€ß€é€º€h€ €€E€Ÿ€â€ë€ä€´€…€|€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€|€…€´€ä€ë€â€Ÿ€E€€ €h€º€é€ß€¥€[€!€€(€_€ž€Ð€é€è€Ó€²€€j€M€7€(€€€€€€€%€1€D€_€‚€¨€Ë€ä€ë€Ù€®€r€7€€€G€‘€Ó€ë€Ì€€1€€0€„€Õ€ë€è€Å€Ž€|€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€|€‚€±€à€ë€â€œ€@€€'€u€Ç€ë€Ó€€@€€€H€€É€è€è€Ê€Ÿ€n€E€'€€€€€€"€%€%€!€€€€€€.€O€z€«€Õ€ë€ã€¹€w€7€€€S€¢€à€è€²€\€€€Y€µ€é€é€×€ €~€}€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€}€~€ €×€é€é€µ€Y€€€\€²€è€à€¢€S€€€7€w€¹€ã€ë€Õ€«€z€O€.€€€€€€!€%€%€"€€€€€€'€E€n€Ÿ€Ê€è€è€É€€H€€€@€€Ó€ë€Ç€u€'€€@€œ€â€ë€à€±€‚€|€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€š€Ó€ë€ê€·€W€€€d€¼€ë€×€€?€€€U€Ÿ€Ø€ë€Ù€ª€q€?€€€€%€;€R€f€u€€…€ƒ€|€q€`€J€3€€€€%€K€€¸€â€ë€Ê€ˆ€A€€€T€¦€ã€å€¥€J€€#€s€Ì€ë€ê€Ã€€{€}€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€}€{€€Ã€ê€ë€Ì€s€#€€J€¥€å€ã€¦€T€€€A€ˆ€Ê€ë€â€¸€€K€%€€€€3€J€`€q€|€ƒ€…€€u€f€R€;€%€€€€?€q€ª€Ù€ë€Ø€Ÿ€U€€€?€€×€ë€¼€d€€€W€·€ê€ë€Ó€š€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€|€‡€½€è€ë€Ò€x€$€€M€©€ç€Þ€™€D€€€Z€©€á€ê€È€Œ€M€!€€€3€X€€ €¸€Ê€Õ€Û€Ü€Ü€Ú€Ò€Å€±€–€t€M€+€€€+€]€Ÿ€Ö€ë€Ó€“€E€€€[€±€è€Ü€€5€€8€”€à€ë€â€«€€|€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€|€€«€â€ë€à€”€8€€5€€Ü€è€±€[€€€E€“€Ó€ë€Ö€Ÿ€]€+€€€+€M€t€–€±€Å€Ò€Ú€Ü€Ü€Û€Õ€Ê€¸€ €€X€3€€€!€M€Œ€È€ê€á€©€Z€€€D€™€Þ€ç€©€M€€$€x€Ò€ë€è€½€‡€|€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€¡€Ù€ê€å€Ÿ€>€€3€€Ü€ç€ª€Q€€€X€«€ã€è€»€t€6€€€2€a€“€¼€Ø€ç€ë€é€ä€á€Þ€Þ€â€æ€ê€ê€ã€Ð€±€…€T€'€€€F€Š€Ì€ë€×€“€C€€ €i€Á€ë€Ë€r€!€€W€¸€ë€è€Ì€’€z€}€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€}€z€’€Ì€è€ë€¸€W€€!€r€Ë€ë€Á€i€ €€C€“€×€ë€Ì€Š€F€€€'€T€…€±€Ð€ã€ê€ê€æ€â€Þ€Þ€á€ä€é€ë€ç€Ø€¼€“€a€2€€€6€t€»€è€ã€«€X€€€Q€ª€ç€Ü€€3€€>€Ÿ€å€ê€Ù€¡€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€|€Š€¿€ê€ë€Å€d€€€l€É€ë€À€f€€€O€¥€â€è€´€h€(€€ €P€Œ€¿€ß€ë€å€Ó€½€¨€˜€Œ€†€‡€€œ€®€Ä€Ú€è€ê€Ù€³€|€A€€€8€€Ç€ë€Ö€€9€€+€€Õ€ë€±€P€€'€€Ö€ë€ã€®€€{€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€{€€®€ã€ë€Ö€€'€€P€±€ë€Õ€€+€€9€€Ö€ë€Ç€€8€€€A€|€³€Ù€ê€è€Ú€Ä€®€œ€€‡€†€Œ€˜€¨€½€Ó€å€ë€ß€¿€Œ€P€ €€(€h€´€è€â€¥€O€€€f€À€ë€É€l€€€d€Å€ë€ê€¿€Š€|€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€ €Ú€ë€â€“€2€€E€©€é€Ö€‚€+€€?€—€Ý€è€µ€d€#€€-€k€«€Ú€ë€á€Ã€›€v€W€A€2€+€'€'€,€7€H€a€‚€¨€Ì€æ€é€Ð€›€X€ €€2€|€É€ë€Ï€~€+€€@€ž€å€Þ€€/€€J€¯€é€é€Ì€€z€}€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€}€z€€Ì€é€é€¯€J€€/€€Þ€å€ž€@€€+€~€Ï€ë€É€|€2€€ €X€›€Ð€é€æ€Ì€¨€‚€a€H€7€,€'€'€+€2€A€W€v€›€Ã€á€ë€Ú€«€k€-€€#€d€µ€è€Ý€—€?€€+€‚€Ö€é€©€E€€2€“€â€ë€Ú€ €}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€|€‡€¼€ê€ë€Ã€^€€$€~€Ø€è€¥€D€€+€€Ó€ë€½€i€"€€5€{€À€ç€è€Ç€–€c€9€€€€€€€€€€€€'€E€r€¥€Ò€ë€á€¯€f€%€€3€ƒ€Ð€ë€À€f€€€^€¿€ë€Ã€`€€"€|€Ö€ë€â€ª€€{€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€{€€ª€â€ë€Ö€|€"€€`€Ã€ë€¿€^€€€f€À€ë€Ð€ƒ€3€€%€f€¯€á€ë€Ò€¥€r€E€'€€€€€€€€€€€€9€c€–€Ç€è€ç€À€{€5€€"€i€½€ë€Ó€€+€€D€¥€è€Ø€~€$€€^€Ã€ë€ê€¼€‡€|€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€{€™€Õ€ê€ã€–€2€€L€³€ë€Ê€i€€€c€À€ë€Ì€w€(€€6€‚€Ê€ë€Ý€­€n€9€€€€+€@€R€`€f€d€\€M€9€%€€€ €F€€€½€æ€ç€¸€j€$€€<€’€Ü€è€©€J€€*€‡€Ü€ä€–€3€€J€²€ê€è€Å€Š€z€}€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€}€z€Š€Å€è€ê€²€J€€3€–€ä€Ü€‡€*€€J€©€è€Ü€’€<€€$€j€¸€ç€æ€½€€€F€ €€€%€9€M€\€d€f€`€R€@€+€€€€9€n€­€Ý€ë€Ê€‚€6€€(€w€Ì€ë€À€c€€€i€Ê€ë€³€L€€2€–€ã€ê€Õ€™€{€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€|€€±€æ€ë€Ë€g€€"€€Û€æ€˜€5€€A€¡€æ€Ü€€6€€.€€Ë€ë€Ö€™€T€!€€€>€e€Š€§€º€Å€Ê€Ê€Ã€µ€Ÿ€€W€1€€€,€e€«€á€é€¸€d€€€L€©€è€Ú€†€+€€N€´€ë€Å€`€€%€‡€Ü€ë€Û€Ÿ€}€|€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€|€}€Ÿ€Û€ë€Ü€‡€%€€`€Å€ë€´€N€€+€†€Ú€è€©€L€€€d€¸€é€á€«€e€,€€€1€W€€Ÿ€µ€Ã€Ê€Ê€Å€º€§€Š€e€>€€€!€T€™€Ö€ë€Ë€€.€€6€€Ü€æ€¡€A€€5€˜€æ€Û€€"€€g€Ë€ë€æ€±€€|€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€z€€È€è€é€¦€>€€E€¯€ë€È€b€€ €x€Ó€é€¬€N€€"€p€Å€ë€Ó€€D€€€4€h€ž€Æ€Þ€é€ë€ê€è€è€ë€ë€ç€Ø€º€€X€(€€€V€¥€á€è€¯€V€€€h€Ä€ë€¾€[€€$€€Û€â€‘€-€€Y€Á€ë€ã€¶€ƒ€z€}€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€}€z€ƒ€¶€ã€ë€Á€Y€€-€‘€â€Û€€$€€[€¾€ë€Ä€h€€€V€¯€è€á€¥€V€€€(€X€€º€Ø€ç€ë€ë€è€è€ê€ë€é€Þ€Æ€ž€h€4€€€D€€Ó€ë€Å€p€"€€N€¬€é€Ó€x€ €€b€È€ë€¯€E€€>€¦€é€è€È€€z€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€|€|€ž€Û€ë€Û€~€ €€p€Ó€è€€6€€I€®€ë€Î€q€€€X€¶€ê€Ø€€@€€€J€‹€Ã€å€ë€á€Í€º€«€¥€¦€¯€¿€Ô€å€ë€Ü€µ€y€9€€€U€¨€æ€â€›€@€€1€€ß€â€’€/€€P€¹€ë€¼€R€€4€Ÿ€ç€ë€Ë€Ž€z€|€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€|€z€Ž€Ë€ë€ç€Ÿ€4€€R€¼€ë€¹€P€€/€’€â€ß€€1€€@€›€â€æ€¨€U€€€9€y€µ€Ü€ë€å€Ô€¿€¯€¦€¥€«€º€Í€á€ë€å€Ã€‹€J€€€@€€Ø€ê€¶€X€€€q€Î€ë€®€I€€6€€è€Ó€p€€ €~€Û€ë€Û€ž€|€|€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€{€€±€æ€ë€Á€W€€2€›€è€Ò€m€€€z€Ö€æ€ž€:€€:€š€ã€â€ž€G€€€V€ €×€ë€Ý€¹€€l€S€C€=€>€G€Z€v€ž€Æ€å€ê€Ë€€C€€€^€·€ë€Ó€}€&€€T€¸€ë€Â€[€€*€€â€Ú€{€€€w€Ö€ë€Û€Ÿ€}€{€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€{€}€Ÿ€Û€ë€Ö€w€€€{€Ú€â€€*€€[€Â€ë€¸€T€€&€}€Ó€ë€·€^€€€C€€Ë€ê€å€Æ€ž€v€Z€G€>€=€C€S€l€€¹€Ý€ë€×€ €V€€€G€ž€â€ã€š€:€€:€ž€æ€Ö€z€€€m€Ò€è€›€2€€W€Á€ë€æ€±€€{€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€z€Š€Ä€ç€è€£€7€€S€¿€ë€°€D€€@€©€ê€Ë€h€€€r€Ð€ë€¶€X€€€V€§€à€é€È€Ž€X€1€€€€€€€€ €=€i€¢€Õ€ë€Õ€“€B€€#€t€Ì€ë€·€V€€(€‡€Þ€â€‹€'€€b€Ê€ê€£€8€€R€À€ë€â€±€€{€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€{€€±€â€ë€À€R€€8€£€ê€Ê€b€€'€‹€â€Þ€‡€(€€V€·€ë€Ì€t€#€€B€“€Õ€ë€Õ€¢€i€=€ €€€€€€€€1€X€Ž€È€é€à€§€V€€€X€¶€ë€Ð€r€€€h€Ë€ê€©€@€€D€°€ë€¿€S€€7€£€è€ç€Ä€Š€z€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€z€–€Ô€ë€Ý€ƒ€ €€v€Ú€ã€Š€%€€h€Î€è€¢€;€€D€ª€ë€Ò€x€$€€J€¢€â€è€¹€t€5€€€€0€@€I€G€<€*€€€€G€ˆ€Ê€ë€Õ€Š€4€€7€•€â€ß€€,€€V€½€ë€¶€J€€=€©€ë€Ã€V€€6€¥€é€ë€Ã€ˆ€z€|€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€|€z€ˆ€Ã€ë€é€¥€6€€V€Ã€ë€©€=€€J€¶€ë€½€V€€,€€ß€â€•€7€€4€Š€Õ€ë€Ê€ˆ€G€€€€*€<€G€I€@€0€€€€5€t€¹€è€â€¢€J€€$€x€Ò€ë€ª€D€€;€¢€è€Î€h€€%€Š€ã€Ú€v€€ €ƒ€Ý€ë€Ô€–€z€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€{€}€¤€ß€ë€Ë€c€€.€™€è€Ï€d€€*€‘€å€Ö€t€€€t€Ô€è€¢€?€€4€Ž€Û€é€·€h€'€€€G€p€“€¨€±€°€£€‰€c€8€€€7€~€Ê€ë€Ê€t€ €€Z€½€ë€½€V€€/€”€ç€Ö€p€€"€…€á€Ú€x€€ €…€Þ€ë€Ð€’€{€{€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€{€{€’€Ð€ë€Þ€…€ €€x€Ú€á€…€"€€p€Ö€ç€”€/€€V€½€ë€½€Z€€ €t€Ê€ë€Ê€~€7€€€8€c€‰€£€°€±€¨€“€p€G€€€'€h€·€é€Û€Ž€4€€?€¢€è€Ô€t€€€t€Ö€å€‘€*€€d€Ï€è€™€.€€c€Ë€ë€ß€¤€}€{€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€€²€â€ë€·€I€€E€¶€ë€´€D€€F€´€ë€¹€M€€:€£€ê€Ð€m€€€l€È€ë€Â€l€$€€1€m€§€Ï€â€é€ê€ê€è€Þ€Ã€•€X€!€€4€…€Õ€ê€±€P€€+€Œ€à€Ý€„€$€€l€Ò€è€–€,€€d€Î€è€–€+€€h€Ñ€ë€Ø€Ÿ€|€{€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€{€|€Ÿ€Ø€ë€Ñ€h€€+€–€è€Î€d€€,€–€è€Ò€l€€$€„€Ý€à€Œ€+€€P€±€ê€Õ€…€4€€!€X€•€Ã€Þ€è€ê€ê€é€â€Ï€§€m€1€€$€l€Â€ë€È€l€€€m€Ð€ê€£€:€€M€¹€ë€´€F€€D€´€ë€¶€E€€I€·€ë€â€²€€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€‡€À€è€é€¢€4€€_€Ë€è€™€,€€e€Ï€è€˜€/€€^€È€ë€©€>€€@€¥€è€Ö€‚€-€€3€€Ã€è€ê€Ü€Ê€À€Â€Ï€á€ë€ß€°€g€$€€A€€ä€Ý€‡€(€€\€Ã€ë€¬€A€€H€·€ë€¶€E€€H€·€ë€°€@€€P€Á€ë€á€«€€z€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€z€€«€á€ë€Á€P€€@€°€ë€·€H€€E€¶€ë€·€H€€A€¬€ë€Ã€\€€(€‡€Ý€ä€€A€€$€g€°€ß€ë€á€Ï€Â€À€Ê€Ü€ê€è€Ã€€3€€-€‚€Ö€è€¥€@€€>€©€ë€È€^€€/€˜€è€Ï€e€€,€™€è€Ë€_€€4€¢€é€è€À€‡€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€€Ê€ë€â€€%€€w€Û€ß€~€€€‚€á€Ú€w€€"€ƒ€à€Ý€~€€€n€Ð€é€¨€E€€*€{€Ì€ë€Ü€±€…€f€W€Z€m€’€À€æ€ç€¶€b€€€_€Á€ë€¹€P€€5€ž€è€Ì€c€€-€˜€é€Î€a€€1€Ÿ€ê€Ä€V€€<€¯€ë€è€·€‚€z€Œ€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€Œ€z€‚€·€è€ë€¯€<€€V€Ä€ê€Ÿ€1€€a€Î€é€˜€-€€c€Ì€è€ž€5€€P€¹€ë€Á€_€€€b€¶€ç€æ€À€’€m€Z€W€f€…€±€Ü€ë€Ì€{€*€€E€¨€é€Ð€n€€€~€Ý€à€ƒ€"€€w€Ú€á€‚€€€~€ß€Û€w€€%€€â€ë€Ê€€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€•€Ó€ë€Ù€z€€$€Œ€ä€Ñ€f€€-€œ€é€È€Z€€7€¤€ë€Å€X€€1€š€è€Ò€r€€€c€À€ë€Ô€“€S€)€€€€€3€e€ª€â€æ€¨€J€€.€€ã€Û€z€€€y€Ú€à€ƒ€ €€z€Þ€Þ€z€€"€‡€â€Ô€i€€,€œ€ç€ë€À€‡€z€‹€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€‹€z€‡€À€ë€ç€œ€,€€i€Ô€â€‡€"€€z€Þ€Þ€z€€ €ƒ€à€Ú€y€€€z€Û€ã€€.€€J€¨€æ€â€ª€e€3€€€€€)€S€“€Ô€ë€À€c€€€r€Ò€è€š€1€€X€Å€ë€¤€7€€Z€È€é€œ€-€€f€Ñ€ä€Œ€$€€z€Ù€ë€Ó€•€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€{€œ€Ú€ë€Ð€h€€0€ž€ê€Ã€S€€>€±€ë€´€D€€M€½€ë€ª€;€€Q€¾€ë€°€E€€;€Ÿ€ç€Ü€€@€€€"€/€,€€€€W€¬€è€Ù€‚€%€€b€Ê€ë€¢€5€€X€Å€é€Ÿ€1€€b€Ð€è€‘€&€€t€Ú€Þ€{€€!€‹€â€ë€È€Œ€z€‹€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€‹€z€Œ€È€ë€â€‹€!€€{€Þ€Ú€t€€&€‘€è€Ð€b€€1€Ÿ€é€Å€X€€5€¢€ë€Ê€b€€%€‚€Ù€è€¬€W€€€€,€/€"€€€@€€Ü€ç€Ÿ€;€€E€°€ë€¾€Q€€;€ª€ë€½€M€€D€´€ë€±€>€€S€Ã€ê€ž€0€€h€Ð€ë€Ú€œ€{€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€|€¢€Þ€ë€Ç€[€€<€¬€ë€¶€D€€O€Á€ê€¡€2€€c€Ï€ç€‘€&€€p€Ö€ã€‹€&€€h€Í€ë€«€J€€€L€|€“€€o€;€€€h€Æ€ë€´€J€€>€«€ë€¿€P€€@€°€ë€µ€D€€N€À€ë€£€3€€c€Ð€ä€Œ€#€€|€Ý€ë€Î€‘€{€‹€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€‹€{€‘€Î€ë€Ý€|€€#€Œ€ä€Ð€c€€3€£€ë€À€N€€D€µ€ë€°€@€€P€¿€ë€«€>€€J€´€ë€Æ€h€€€;€o€€“€|€L€€€J€«€ë€Í€h€€&€‹€ã€Ö€p€€&€‘€ç€Ï€c€€2€¡€ê€Á€O€€D€¶€ë€¬€<€€[€Ç€ë€Þ€¢€|€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€~€¨€â€ë€¿€P€€E€·€ë€ª€8€€\€Í€ç€’€'€€v€Û€Ý€z€€!€Š€ä€Ô€l€€(€€å€Ø€t€€€W€¥€Ö€ä€â€Ë€€>€€3€—€æ€Ô€n€€%€€æ€Ô€h€€/€œ€é€Ä€U€€?€²€ë€±€>€€V€Ç€è€˜€*€€p€×€ë€Ó€–€{€‹€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¾€j€F€F€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€E€H€w€Ì€è€¥€[€E€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€G€F€F€j€¾€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€‹€{€–€Ó€ë€×€p€€*€˜€è€Ç€V€€>€±€ë€²€?€€U€Ä€é€œ€/€€h€Ô€æ€€%€€n€Ô€æ€—€3€€>€€Ë€â€ä€Ö€¥€W€€€t€Ø€å€€(€€l€Ô€ä€Š€!€€z€Ý€Û€v€€'€’€ç€Í€\€€8€ª€ë€·€E€€P€¿€ë€â€¨€~€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€«€€€¬€à€ë€¹€H€€M€¿€ë€¡€1€€h€Õ€â€†€€€ƒ€â€Ö€k€€-€œ€é€Ä€U€€=€­€ë€¼€J€€:€œ€á€è€×€Ü€ë€Ó€|€"€€m€Ó€ä€€%€€v€Ü€ß€z€€$€€å€Ï€a€€5€§€ë€»€H€€M€¿€ê€ €1€€h€Ô€ë€Ô€™€{€‹€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€¿€m€G€H€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€G€I€z€Î€é€§€]€F€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€J€H€G€m€¿€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€‹€{€™€Ô€ë€Ô€h€€1€ €ê€¿€M€€H€»€ë€§€5€€a€Ï€å€€$€€z€ß€Ü€v€€%€€ä€Ó€m€€"€|€Ó€ë€Ü€×€è€á€œ€:€€J€¼€ë€­€=€€U€Ä€é€œ€-€€k€Ö€â€ƒ€€€†€â€Õ€h€€1€¡€ë€¿€M€€H€¹€ë€à€¬€€€«€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€æ€á€«€€€€¯€â€ë€µ€D€€S€Ã€é€›€+€€n€Ù€à€}€€$€€æ€Ï€`€€7€©€ë€¸€F€€N€¿€ë€¤€1€€`€Ê€ê€µ€z€ˆ€Ë€ë€­€>€€P€Á€ê€¡€1€€f€Ô€å€‡€ €€‚€â€Ö€j€€/€Ÿ€ë€Á€N€€H€º€ë€¦€5€€b€Ð€ë€Ö€›€{€‹€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€Í€•€z€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€|€ž€×€ê€½€Š€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€z€•€Í€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€‹€{€›€Ö€ë€Ð€b€€5€¦€ë€º€H€€N€Á€ë€Ÿ€/€€j€Ö€â€‚€€ €‡€å€Ô€f€€1€¡€ê€Á€P€€>€­€ë€Ë€ˆ€z€µ€ê€Ê€`€€1€¤€ë€¿€N€€F€¸€ë€©€7€€`€Ï€æ€€$€€}€à€Ù€n€€+€›€é€Ã€S€€D€µ€ë€â€¯€€€€«€á€æ€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ë€à€«€€€€±€â€ë€³€A€€V€Æ€é€˜€)€€s€Û€Ý€y€€&€’€ç€Ê€Z€€;€¯€ë€²€@€€W€È€é€–€&€€v€Ü€Ü€{€%€8€Ÿ€ë€Ä€Q€€C€¶€ë€«€9€€_€Ï€ç€Ž€$€€|€ß€×€o€€+€›€ë€Ã€Q€€D€·€ë€©€7€€`€Ï€ë€×€€{€‹€½€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ç€Þ€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€ß€è€ë€ä€Ü€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Þ€ç€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€½€‹€{€€×€ë€Ï€`€€7€©€ë€·€D€€Q€Ã€ë€›€+€€o€×€ß€|€€$€Ž€ç€Ï€_€€9€«€ë€¶€C€€Q€Ä€ë€Ÿ€8€%€{€Ü€Ü€v€€&€–€é€È€W€€@€²€ë€¯€;€€Z€Ê€ç€’€&€€y€Ý€Û€s€€)€˜€é€Æ€V€€A€³€ë€â€±€€€€«€à€ë€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ë€à€«€€€€±€â€ë€³€A€€V€Æ€é€˜€)€€s€Û€Ý€y€€&€’€ç€Ê€Z€€;€¯€ë€²€@€€W€È€é€–€&€€v€Ü€Ü€{€%€8€Ÿ€ë€Ä€Q€€C€¶€ë€«€9€€_€Ï€ç€Ž€$€€|€ß€×€o€€+€›€ë€Ã€Q€€D€·€ë€©€7€€`€Ï€ë€×€€{€‹€½€è€é€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€é€è€½€‹€{€€×€ë€Ï€`€€7€©€ë€·€D€€Q€Ã€ë€›€+€€o€×€ß€|€€$€Ž€ç€Ï€_€€9€«€ë€¶€C€€Q€Ä€ë€Ÿ€8€%€{€Ü€Ü€v€€&€–€é€È€W€€@€²€ë€¯€;€€Z€Ê€ç€’€&€€y€Ý€Û€s€€)€˜€é€Æ€V€€A€³€ë€â€±€€€€«€à€ë€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€æ€á€«€€€€¯€â€ë€µ€D€€S€Ã€é€›€+€€n€Ù€à€}€€$€€æ€Ï€`€€7€©€ë€¸€F€€N€¿€ë€¤€1€€`€Ê€ê€µ€z€ˆ€Ë€ë€­€>€€P€Á€ê€¡€1€€f€Ô€å€‡€ €€‚€â€Ö€j€€/€Ÿ€ë€Á€N€€H€º€ë€¦€5€€b€Ð€ë€Ö€›€{€‹€¾€é€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€é€¾€‹€{€›€Ö€ë€Ð€b€€5€¦€ë€º€H€€N€Á€ë€Ÿ€/€€j€Ö€â€‚€€ €‡€å€Ô€f€€1€¡€ê€Á€P€€>€­€ë€Ë€ˆ€z€µ€ê€Ê€`€€1€¤€ë€¿€N€€F€¸€ë€©€7€€`€Ï€æ€€$€€}€à€Ù€n€€+€›€é€Ã€S€€D€µ€ë€â€¯€€€€«€á€æ€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€«€€€¬€à€ë€¹€H€€M€¿€ë€¡€1€€h€Õ€â€†€€€ƒ€â€Ö€k€€-€œ€é€Ä€U€€=€­€ë€¼€J€€:€œ€á€è€×€Ü€ë€Ó€|€"€€m€Ó€ä€€%€€v€Ü€ß€z€€$€€å€Ï€a€€5€§€ë€»€H€€M€¿€ê€ €1€€h€Ô€ë€Ô€™€{€‹€¾€ê€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ê€¾€‹€{€™€Ô€ë€Ô€h€€1€ €ê€¿€M€€H€»€ë€§€5€€a€Ï€å€€$€€z€ß€Ü€v€€%€€ä€Ó€m€€"€|€Ó€ë€Ü€×€è€á€œ€:€€J€¼€ë€­€=€€U€Ä€é€œ€-€€k€Ö€â€ƒ€€€†€â€Õ€h€€1€¡€ë€¿€M€€H€¹€ë€à€¬€€€«€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€~€¨€â€ë€¿€P€€E€·€ë€ª€8€€\€Í€ç€’€'€€v€Û€Ý€z€€!€Š€ä€Ô€l€€(€€å€Ø€t€€€W€¥€Ö€ä€â€Ë€€>€€3€—€æ€Ô€n€€%€€æ€Ô€h€€/€œ€é€Ä€U€€?€²€ë€±€>€€V€Ç€è€˜€*€€p€×€ë€Ó€–€{€‹€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€‹€{€–€Ó€ë€×€p€€*€˜€è€Ç€V€€>€±€ë€²€?€€U€Ä€é€œ€/€€h€Ô€æ€€%€€n€Ô€æ€—€3€€>€€Ë€â€ä€Ö€¥€W€€€t€Ø€å€€(€€l€Ô€ä€Š€!€€z€Ý€Û€v€€'€’€ç€Í€\€€8€ª€ë€·€E€€P€¿€ë€â€¨€~€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€|€¢€Þ€ë€Ç€[€€<€¬€ë€¶€D€€O€Á€ê€¡€2€€c€Ï€ç€‘€&€€p€Ö€ã€‹€&€€h€Í€ë€«€J€€€L€|€“€€o€;€€€h€Æ€ë€´€J€€>€«€ë€¿€P€€@€°€ë€µ€D€€N€À€ë€£€3€€c€Ð€ä€Œ€#€€|€Ý€ë€Î€‘€{€‹€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€‹€{€‘€Î€ë€Ý€|€€#€Œ€ä€Ð€c€€3€£€ë€À€N€€D€µ€ë€°€@€€P€¿€ë€«€>€€J€´€ë€Æ€h€€€;€o€€“€|€L€€€J€«€ë€Í€h€€&€‹€ã€Ö€p€€&€‘€ç€Ï€c€€2€¡€ê€Á€O€€D€¶€ë€¬€<€€[€Ç€ë€Þ€¢€|€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€{€œ€Ú€ë€Ð€h€€0€ž€ê€Ã€S€€>€±€ë€´€D€€M€½€ë€ª€;€€Q€¾€ë€°€E€€;€Ÿ€ç€Ü€€@€€€"€/€,€€€€W€¬€è€Ù€‚€%€€b€Ê€ë€¢€5€€X€Å€é€Ÿ€1€€b€Ð€è€‘€&€€t€Ú€Þ€{€€!€‹€â€ë€È€Œ€z€‹€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€‹€z€Œ€È€ë€â€‹€!€€{€Þ€Ú€t€€&€‘€è€Ð€b€€1€Ÿ€é€Å€X€€5€¢€ë€Ê€b€€%€‚€Ù€è€¬€W€€€€,€/€"€€€@€€Ü€ç€Ÿ€;€€E€°€ë€¾€Q€€;€ª€ë€½€M€€D€´€ë€±€>€€S€Ã€ê€ž€0€€h€Ð€ë€Ú€œ€{€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€•€Ó€ë€Ù€z€€$€Œ€ä€Ñ€f€€-€œ€é€È€Z€€7€¤€ë€Å€X€€1€š€è€Ò€r€€€c€À€ë€Ô€“€S€)€€€€€3€e€ª€â€æ€¨€J€€.€€ã€Û€z€€€y€Ú€à€ƒ€ €€z€Þ€Þ€z€€"€‡€â€Ô€i€€,€œ€ç€ë€À€‡€z€‹€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€‹€z€‡€À€ë€ç€œ€,€€i€Ô€â€‡€"€€z€Þ€Þ€z€€ €ƒ€à€Ú€y€€€z€Û€ã€€.€€J€¨€æ€â€ª€e€3€€€€€)€S€“€Ô€ë€À€c€€€r€Ò€è€š€1€€X€Å€ë€¤€7€€Z€È€é€œ€-€€f€Ñ€ä€Œ€$€€z€Ù€ë€Ó€•€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€€Ê€ë€â€€%€€w€Û€ß€~€€€‚€á€Ú€w€€"€ƒ€à€Ý€~€€€n€Ð€é€¨€E€€*€{€Ì€ë€Ü€±€…€f€W€Z€m€’€À€æ€ç€¶€b€€€_€Á€ë€¹€P€€5€ž€è€Ì€c€€-€˜€é€Î€a€€1€Ÿ€ê€Ä€V€€<€¯€ë€è€·€‚€z€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€z€‚€·€è€ë€¯€<€€V€Ä€ê€Ÿ€1€€a€Î€é€˜€-€€c€Ì€è€ž€5€€P€¹€ë€Á€_€€€b€¶€ç€æ€À€’€m€Z€W€f€…€±€Ü€ë€Ì€{€*€€E€¨€é€Ð€n€€€~€Ý€à€ƒ€"€€w€Ú€á€‚€€€~€ß€Û€w€€%€€â€ë€Ê€€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€‡€À€è€é€¢€4€€_€Ë€è€™€,€€e€Ï€è€˜€/€€^€È€ë€©€>€€@€¥€è€Ö€‚€-€€3€€Ã€è€ê€Ü€Ê€À€Â€Ï€á€ë€ß€°€g€$€€A€€ä€Ý€‡€(€€\€Ã€ë€¬€A€€H€·€ë€¶€E€€H€·€ë€°€@€€P€Á€ë€á€«€€z€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€z€€«€á€ë€Á€P€€@€°€ë€·€H€€E€¶€ë€·€H€€A€¬€ë€Ã€\€€(€‡€Ý€ä€€A€€$€g€°€ß€ë€á€Ï€Â€À€Ê€Ü€ê€è€Ã€€3€€-€‚€Ö€è€¥€@€€>€©€ë€È€^€€/€˜€è€Ï€e€€,€™€è€Ë€_€€4€¢€é€è€À€‡€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€€²€â€ë€·€I€€E€¶€ë€´€D€€F€´€ë€¹€M€€:€£€ê€Ð€m€€€l€È€ë€Â€l€$€€1€m€§€Ï€â€é€ê€ê€è€Þ€Ã€•€X€!€€4€…€Õ€ê€±€P€€+€Œ€à€Ý€„€$€€l€Ò€è€–€,€€d€Î€è€–€+€€h€Ñ€ë€Ø€Ÿ€|€{€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€{€|€Ÿ€Ø€ë€Ñ€h€€+€–€è€Î€d€€,€–€è€Ò€l€€$€„€Ý€à€Œ€+€€P€±€ê€Õ€…€4€€!€X€•€Ã€Þ€è€ê€ê€é€â€Ï€§€m€1€€$€l€Â€ë€È€l€€€m€Ð€ê€£€:€€M€¹€ë€´€F€€D€´€ë€¶€E€€I€·€ë€â€²€€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€{€}€¤€ß€ë€Ë€c€€.€™€è€Ï€d€€*€‘€å€Ö€t€€€t€Ô€è€¢€?€€4€Ž€Û€é€·€h€'€€€G€p€“€¨€±€°€£€‰€c€8€€€7€~€Ê€ë€Ê€t€ €€Z€½€ë€½€V€€/€”€ç€Ö€p€€"€…€á€Ú€x€€ €…€Þ€ë€Ð€’€{€{€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€{€{€’€Ð€ë€Þ€…€ €€x€Ú€á€…€"€€p€Ö€ç€”€/€€V€½€ë€½€Z€€ €t€Ê€ë€Ê€~€7€€€8€c€‰€£€°€±€¨€“€p€G€€€'€h€·€é€Û€Ž€4€€?€¢€è€Ô€t€€€t€Ö€å€‘€*€€d€Ï€è€™€.€€c€Ë€ë€ß€¤€}€{€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€z€–€Ô€ë€Ý€ƒ€ €€v€Ú€ã€Š€%€€h€Î€è€¢€;€€D€ª€ë€Ò€x€$€€J€¢€â€è€¹€t€5€€€€0€@€I€G€<€*€€€€G€ˆ€Ê€ë€Õ€Š€4€€7€•€â€ß€€,€€V€½€ë€¶€J€€=€©€ë€Ã€V€€6€¥€é€ë€Ã€ˆ€z€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€z€ˆ€Ã€ë€é€¥€6€€V€Ã€ë€©€=€€J€¶€ë€½€V€€,€€ß€â€•€7€€4€Š€Õ€ë€Ê€ˆ€G€€€€*€<€G€I€@€0€€€€5€t€¹€è€â€¢€J€€$€x€Ò€ë€ª€D€€;€¢€è€Î€h€€%€Š€ã€Ú€v€€ €ƒ€Ý€ë€Ô€–€z€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€z€Š€Ä€ç€è€£€7€€S€¿€ë€°€D€€@€©€ê€Ë€h€€€r€Ð€ë€¶€X€€€V€§€à€é€È€Ž€X€1€€€€€€€€ €=€i€¢€Õ€ë€Õ€“€B€€#€t€Ì€ë€·€V€€(€‡€Þ€â€‹€'€€b€Ê€ê€£€8€€R€À€ë€â€±€€{€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€{€€±€â€ë€À€R€€8€£€ê€Ê€b€€'€‹€â€Þ€‡€(€€V€·€ë€Ì€t€#€€B€“€Õ€ë€Õ€¢€i€=€ €€€€€€€€1€X€Ž€È€é€à€§€V€€€X€¶€ë€Ð€r€€€h€Ë€ê€©€@€€D€°€ë€¿€S€€7€£€è€ç€Ä€Š€z€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€{€€±€æ€ë€Á€W€€2€›€è€Ò€m€€€z€Ö€æ€ž€:€€:€š€ã€â€ž€G€€€V€ €×€ë€Ý€¹€€l€S€C€=€>€G€Z€v€ž€Æ€å€ê€Ë€€C€€€^€·€ë€Ó€}€&€€T€¸€ë€Â€[€€*€€â€Ú€{€€€w€Ö€ë€Û€Ÿ€}€{€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€{€}€Ÿ€Û€ë€Ö€w€€€{€Ú€â€€*€€[€Â€ë€¸€T€€&€}€Ó€ë€·€^€€€C€€Ë€ê€å€Æ€ž€v€Z€G€>€=€C€S€l€€¹€Ý€ë€×€ €V€€€G€ž€â€ã€š€:€€:€ž€æ€Ö€z€€€m€Ò€è€›€2€€W€Á€ë€æ€±€€{€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€|€|€ž€Û€ë€Û€~€ €€p€Ó€è€€6€€I€®€ë€Î€q€€€X€¶€ê€Ø€€@€€€J€‹€Ã€å€ë€á€Í€º€«€¥€¦€¯€¿€Ô€å€ë€Ü€µ€y€9€€€U€¨€æ€â€›€@€€1€€ß€â€’€/€€P€¹€ë€¼€R€€4€Ÿ€ç€ë€Ë€Ž€z€|€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€|€z€Ž€Ë€ë€ç€Ÿ€4€€R€¼€ë€¹€P€€/€’€â€ß€€1€€@€›€â€æ€¨€U€€€9€y€µ€Ü€ë€å€Ô€¿€¯€¦€¥€«€º€Í€á€ë€å€Ã€‹€J€€€@€€Ø€ê€¶€X€€€q€Î€ë€®€I€€6€€è€Ó€p€€ €~€Û€ë€Û€ž€|€|€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€z€€È€è€é€¦€>€€E€¯€ë€È€b€€ €x€Ó€é€¬€N€€"€p€Å€ë€Ó€€D€€€4€h€ž€Æ€Þ€é€ë€ê€è€è€ë€ë€ç€Ø€º€€X€(€€€V€¥€á€è€¯€V€€€h€Ä€ë€¾€[€€$€€Û€â€‘€-€€Y€Á€ë€ã€¶€ƒ€z€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€z€ƒ€¶€ã€ë€Á€Y€€-€‘€â€Û€€$€€[€¾€ë€Ä€h€€€V€¯€è€á€¥€V€€€(€X€€º€Ø€ç€ë€ë€è€è€ê€ë€é€Þ€Æ€ž€h€4€€€D€€Ó€ë€Å€p€"€€N€¬€é€Ó€x€ €€b€È€ë€¯€E€€>€¦€é€è€È€€z€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€|€€±€æ€ë€Ë€g€€"€€Û€æ€˜€5€€A€¡€æ€Ü€€6€€.€€Ë€ë€Ö€™€T€!€€€>€e€Š€§€º€Å€Ê€Ê€Ã€µ€Ÿ€€W€1€€€,€e€«€á€é€¸€d€€€L€©€è€Ú€†€+€€N€´€ë€Å€`€€%€‡€Ü€ë€Û€Ÿ€}€|€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€|€}€Ÿ€Û€ë€Ü€‡€%€€`€Å€ë€´€N€€+€†€Ú€è€©€L€€€d€¸€é€á€«€e€,€€€1€W€€Ÿ€µ€Ã€Ê€Ê€Å€º€§€Š€e€>€€€!€T€™€Ö€ë€Ë€€.€€6€€Ü€æ€¡€A€€5€˜€æ€Û€€"€€g€Ë€ë€æ€±€€|€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€{€™€Õ€ê€ã€–€2€€L€³€ë€Ê€i€€€c€À€ë€Ì€w€(€€6€‚€Ê€ë€Ý€­€n€9€€€€+€@€R€`€f€d€\€M€9€%€€€ €F€€€½€æ€ç€¸€j€$€€<€’€Ü€è€©€J€€*€‡€Ü€ä€–€3€€J€²€ê€è€Å€Š€z€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€z€Š€Å€è€ê€²€J€€3€–€ä€Ü€‡€*€€J€©€è€Ü€’€<€€$€j€¸€ç€æ€½€€€F€ €€€%€9€M€\€d€f€`€R€@€+€€€€9€n€­€Ý€ë€Ê€‚€6€€(€w€Ì€ë€À€c€€€i€Ê€ë€³€L€€2€–€ã€ê€Õ€™€{€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€|€‡€¼€ê€ë€Ã€^€€$€~€Ø€è€¥€D€€+€€Ó€ë€½€i€"€€5€{€À€ç€è€Ç€–€c€9€€€€€€€€€€€€'€E€r€¥€Ò€ë€á€¯€f€%€€3€ƒ€Ð€ë€À€f€€€^€¿€ë€Ã€`€€"€|€Ö€ë€â€ª€€{€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€{€€ª€â€ë€Ö€|€"€€`€Ã€ë€¿€^€€€f€À€ë€Ð€ƒ€3€€%€f€¯€á€ë€Ò€¥€r€E€'€€€€€€€€€€€€9€c€–€Ç€è€ç€À€{€5€€"€i€½€ë€Ó€€+€€D€¥€è€Ø€~€$€€^€Ã€ë€ê€¼€‡€|€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€ €Ú€ë€â€“€2€€E€©€é€Ö€‚€+€€?€—€Ý€è€µ€d€#€€-€k€«€Ú€ë€á€Ã€›€v€W€A€2€+€'€'€,€7€H€a€‚€¨€Ì€æ€é€Ð€›€X€ €€2€|€É€ë€Ï€~€+€€@€ž€å€Þ€€/€€J€¯€é€é€Ì€€z€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€z€€Ì€é€é€¯€J€€/€€Þ€å€ž€@€€+€~€Ï€ë€É€|€2€€ €X€›€Ð€é€æ€Ì€¨€‚€a€H€7€,€'€'€+€2€A€W€v€›€Ã€á€ë€Ú€«€k€-€€#€d€µ€è€Ý€—€?€€+€‚€Ö€é€©€E€€2€“€â€ë€Ú€ €}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€|€Š€¿€ê€ë€Å€d€€€l€É€ë€À€f€€€O€¥€â€è€´€h€(€€ €P€Œ€¿€ß€ë€å€Ó€½€¨€˜€Œ€†€‡€€œ€®€Ä€Ú€è€ê€Ù€³€|€A€€€8€€Ç€ë€Ö€€9€€+€€Õ€ë€±€P€€'€€Ö€ë€ã€®€€{€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€{€€®€ã€ë€Ö€€'€€P€±€ë€Õ€€+€€9€€Ö€ë€Ç€€8€€€A€|€³€Ù€ê€è€Ú€Ä€®€œ€€‡€†€Œ€˜€¨€½€Ó€å€ë€ß€¿€Œ€P€ €€(€h€´€è€â€¥€O€€€f€À€ë€É€l€€€d€Å€ë€ê€¿€Š€|€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€¡€Ù€ê€å€Ÿ€>€€3€€Ü€ç€ª€Q€€€X€«€ã€è€»€t€6€€€2€a€“€¼€Ø€ç€ë€é€ä€á€Þ€Þ€â€æ€ê€ê€ã€Ð€±€…€T€'€€€F€Š€Ì€ë€×€“€C€€ €i€Á€ë€Ë€r€!€€W€¸€ë€è€Ì€’€z€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€z€’€Ì€è€ë€¸€W€€!€r€Ë€ë€Á€i€ €€C€“€×€ë€Ì€Š€F€€€'€T€…€±€Ð€ã€ê€ê€æ€â€Þ€Þ€á€ä€é€ë€ç€Ø€¼€“€a€2€€€6€t€»€è€ã€«€X€€€Q€ª€ç€Ü€€3€€>€Ÿ€å€ê€Ù€¡€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€|€‡€½€è€ë€Ò€x€$€€M€©€ç€Þ€™€D€€€Z€©€á€ê€È€Œ€M€!€€€3€X€€ €¸€Ê€Õ€Û€Ü€Ü€Ú€Ò€Å€±€–€t€M€+€€€+€]€Ÿ€Ö€ë€Ó€“€E€€€[€±€è€Ü€€5€€8€”€à€ë€â€«€€|€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€€†€Š€€”€™€Ÿ€£€¨€«€®€°€¶€Ë€æ€æ€Ë€¶€°€®€«€¨€£€Ÿ€™€”€€Š€†€€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€|€€«€â€ë€à€”€8€€5€€Ü€è€±€[€€€E€“€Ó€ë€Ö€Ÿ€]€+€€€+€M€t€–€±€Å€Ò€Ú€Ü€Ü€Û€Õ€Ê€¸€ €€X€3€€€!€M€Œ€È€ê€á€©€Z€€€D€™€Þ€ç€©€M€€$€x€Ò€ë€è€½€‡€|€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€š€Ó€ë€ê€·€W€€€d€¼€ë€×€€?€€€U€Ÿ€Ø€ë€Ù€ª€q€?€€€€%€;€R€f€u€€…€ƒ€|€q€`€J€3€€€€%€K€€¸€â€ë€Ê€ˆ€A€€€T€¦€ã€å€¥€J€€#€s€Ì€ë€ê€Ã€€{€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€€‡€€—€¢€­€·€À€Ê€Ñ€×€Ü€á€ä€æ€è€ê€ê€ê€ë€ë€ë€ë€ë€ë€ë€ë€ê€ê€ê€è€æ€ä€á€Ü€×€Ñ€Ê€À€·€­€¢€—€€‡€€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€{€€Ã€ê€ë€Ì€s€#€€J€¥€å€ã€¦€T€€€A€ˆ€Ê€ë€â€¸€€K€%€€€€3€J€`€q€|€ƒ€…€€u€f€R€;€%€€€€?€q€ª€Ù€ë€Ø€Ÿ€U€€€?€€×€ë€¼€d€€€W€·€ê€ë€Ó€š€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€|€‚€±€à€ë€â€œ€@€€'€u€Ç€ë€Ó€€@€€€H€€É€è€è€Ê€Ÿ€n€E€'€€€€€€"€%€%€!€€€€€€.€O€z€«€Õ€ë€ã€¹€w€7€€€S€¢€à€è€²€\€€€Y€µ€é€é€×€ €~€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€€„€Ž€š€©€·€Å€Ñ€Ü€â€è€ê€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ê€è€â€Ü€Ñ€Å€·€©€š€Ž€„€€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€~€ €×€é€é€µ€Y€€€\€²€è€à€¢€S€€€7€w€¹€ã€ë€Õ€«€z€O€.€€€€€€!€%€%€"€€€€€€'€E€n€Ÿ€Ê€è€è€É€€H€€€@€€Ó€ë€Ç€u€'€€@€œ€â€ë€à€±€‚€|€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€|€Ž€Å€è€ë€Õ€„€0€€1€€Ì€ë€Ó€‘€G€€€7€r€®€Ù€ë€ä€Ë€¨€‚€_€D€1€%€€€€€€€(€7€M€j€€²€Ó€è€é€Ð€ž€_€(€€!€[€¥€ß€é€º€h€ €€E€Ÿ€â€ë€ä€´€…€|€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€€‹€š€«€½€Í€Û€ä€é€ë€ë€ë€ë€ë€ë€ë€ë€é€ç€â€Þ€Ù€Ô€Ï€Ê€Å€Â€½€º€·€¹€Ì€ç€ç€Ì€¹€·€º€½€Â€Å€Ê€Ï€Ô€Ù€Þ€â€ç€é€ë€ë€ë€ë€ë€ë€ë€ë€é€ä€Û€Í€½€«€š€‹€€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€|€…€´€ä€ë€â€Ÿ€E€€ €h€º€é€ß€¥€[€!€€(€_€ž€Ð€é€è€Ó€²€€j€M€7€(€€€€€€€%€1€D€_€‚€¨€Ë€ä€ë€Ù€®€r€7€€€G€‘€Ó€ë€Ì€€1€€0€„€Õ€ë€è€Å€Ž€|€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€|€}€€Õ€ë€ë€Ç€q€&€€8€„€Ì€ë€×€œ€U€€€#€P€‡€¹€Ü€ê€è€Ú€Ã€«€•€‚€t€l€h€h€n€y€ˆ€œ€´€Ë€ß€ë€è€Ô€­€y€A€€€-€i€°€â€è€»€m€&€€8€Œ€Ù€ë€ê€Æ€€|€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€€€Ÿ€³€Ç€Ø€ã€ê€ë€ë€ë€ë€ë€ë€é€ã€Ü€Ó€È€½€²€¨€Ÿ€˜€’€Œ€‡€…€‚€€€€~€~€}€ƒ€«€â€â€«€ƒ€}€~€~€€€€‚€…€‡€Œ€’€˜€Ÿ€¨€²€½€È€Ó€Ü€ã€é€ë€ë€ë€ë€ë€ë€ê€ã€Ø€Ç€³€Ÿ€€€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€|€€Æ€ê€ë€Ù€Œ€8€€&€m€»€è€â€°€i€-€€€A€y€­€Ô€è€ë€ß€Ë€´€œ€ˆ€y€n€h€h€l€t€‚€•€«€Ã€Ú€è€ê€Ü€¹€‡€P€#€€€U€œ€×€ë€Ì€„€8€€&€q€Ç€ë€ë€Õ€€}€|€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€{€€«€Þ€ë€é€»€f€"€€8€€Ç€ë€ß€¬€j€1€€€.€Y€‡€±€Ð€ä€ë€ê€ã€Ü€Ô€Ï€Ì€Ì€Ð€Ö€Þ€æ€ë€ê€ß€É€§€{€L€%€€€@€~€½€ç€å€·€l€'€€1€€€Ð€ë€ë€Ò€œ€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€~€‡€š€±€Ç€Ú€æ€ë€ë€ë€ë€ë€ë€ç€Ý€Ð€Â€³€¥€™€Ž€‡€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€‡€Ž€™€¥€³€Â€Ð€Ý€ç€ë€ë€ë€ë€ë€ë€æ€Ú€Ç€±€š€‡€~€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€œ€Ò€ë€ë€Ð€€€1€€'€l€·€å€ç€½€~€@€€€%€L€{€§€É€ß€ê€ë€æ€Þ€Ö€Ð€Ì€Ì€Ï€Ô€Ü€ã€ê€ë€ä€Ð€±€‡€Y€.€€€1€j€¬€ß€ë€Ç€€8€€"€f€»€é€ë€Þ€«€€{€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€{€‡€¸€â€ë€æ€³€b€!€€3€w€½€ç€è€Â€ˆ€M€$€€€,€N€t€–€´€Ê€×€à€å€è€è€è€ç€ä€Ý€Ó€Ã€«€€i€D€%€€€-€]€›€Ð€ë€Þ€«€c€%€€/€z€É€ë€ê€Ú€¨€€|€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€½€ª€¼€Ó€ã€ê€ë€ë€ë€ë€è€á€Ò€Â€°€Ÿ€‘€†€€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€€†€‘€Ÿ€°€Â€Ò€á€è€ë€ë€ë€ë€ê€ã€Ó€¼€ª€½€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€|€€¨€Ú€ê€ë€É€z€/€€%€c€«€Þ€ë€Ð€›€]€-€€€%€D€i€€«€Ã€Ó€Ý€ä€ç€è€è€è€å€à€×€Ê€´€–€t€N€,€€€$€M€ˆ€Â€è€ç€½€w€3€€!€b€³€æ€ë€â€¸€‡€{€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€{€€Â€æ€ë€å€±€c€$€€+€h€«€Ý€ë€Ø€¬€v€E€#€€€€3€M€e€z€‹€˜€Ÿ€¢€¢€€”€†€t€]€D€,€€€€*€Q€‡€»€â€ë€Ñ€™€U€€€2€z€Æ€ë€ê€ß€±€„€|€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€„€°€â€ê€ã€ç€ë€ë€ë€ë€é€ß€Ï€»€¦€”€‡€€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€€‡€”€¦€»€Ï€ß€é€ë€ë€ë€ë€ç€ã€ê€â€°€„€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€|€„€±€ß€ê€ë€Æ€z€2€€€U€™€Ñ€ë€â€»€‡€Q€*€€€€,€D€]€t€†€”€€¢€¢€Ÿ€˜€‹€z€e€M€3€€€€#€E€v€¬€Ø€ë€Ý€«€h€+€€$€c€±€å€ë€æ€Â€€{€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€|€{€’€È€ç€ë€å€µ€k€+€€€R€“€Ê€è€è€Ð€¦€x€O€.€€€€€ €*€2€8€:€:€7€0€&€€€€€€5€Y€„€²€Ù€ë€â€¼€€€A€€€:€€€È€ë€ê€â€·€‡€{€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€¥€Ä€à€ë€ë€ë€ë€ë€ä€Õ€¿€©€”€…€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€…€”€©€¿€Õ€ä€ë€ë€ë€ë€ë€à€Ä€¥€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€{€‡€·€â€ê€ë€È€€€:€€€A€€€¼€â€ë€Ù€²€„€Y€5€€€€€€&€0€7€:€:€8€2€*€ €€€€€.€O€x€¦€Ð€è€è€Ê€“€R€€€+€k€µ€å€ë€ç€È€’€{€|€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€|€|€•€Ê€è€ê€ç€½€y€8€€€:€r€«€Ö€ê€è€Ó€²€€j€L€4€%€€€€€€€€€€€)€;€T€t€—€¼€Ú€ê€ç€Ë€š€a€,€€€H€€Í€ê€ê€â€º€Š€{€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€‡€Ÿ€½€×€è€ë€ë€ë€ë€æ€Ð€´€œ€‰€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€‰€œ€´€Ð€æ€ë€ë€ë€ë€è€×€½€Ÿ€‡€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€{€Š€º€â€ê€ê€Í€€H€€€,€a€š€Ë€ç€ê€Ú€¼€—€t€T€;€)€€€€€€€€€€€%€4€L€j€€²€Ó€è€ê€Ö€«€r€:€€€8€y€½€ç€ê€è€Ê€•€|€|€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€|€•€È€é€ê€ê€Ê€€L€€€"€L€€±€Ö€è€ë€ß€Ê€±€˜€€n€_€T€N€J€J€O€W€c€t€ˆ€ €¹€Ñ€ã€ë€å€Í€¥€q€>€€€'€]€Ÿ€×€ê€ë€ä€¸€‰€{€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€“€±€Ð€å€ë€ë€ë€ê€ä€è€è€À€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€À€è€è€ä€ê€ë€ë€ë€å€Ð€±€“€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€{€‰€¸€ä€ë€ê€×€Ÿ€]€'€€€>€q€¥€Í€å€ë€ã€Ñ€¹€ €ˆ€t€c€W€O€J€J€N€T€_€n€€˜€±€Ê€ß€ë€è€Ö€±€€L€"€€€L€€Ê€ê€ê€é€È€•€|€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€“€Â€æ€é€ë€Ú€¦€g€1€€€)€P€~€¨€Ê€ß€ê€ë€å€Û€Ð€Ä€¼€·€´€´€·€¾€È€Ó€Þ€è€ë€è€Ú€Â€€q€D€€€€?€y€·€â€ë€é€à€³€ˆ€{€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€†€ €Á€Ü€ê€ë€ë€ë€ã€Î€³€´€Ü€å€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€å€Ü€´€³€Î€ã€ë€ë€ë€ê€Ü€Á€ €†€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€{€ˆ€³€à€é€ë€â€·€y€?€€€€D€q€€Â€Ú€è€ë€è€Þ€Ó€È€¾€·€´€´€·€¼€Ä€Ð€Û€å€ë€ê€ß€Ê€¨€~€P€)€€€1€g€¦€Ú€ë€é€æ€Â€“€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€¹€á€é€ë€æ€Â€Š€R€'€€€%€D€h€€«€Ä€Ö€â€ç€ê€ë€ë€ë€ë€ë€ë€é€æ€Þ€Ñ€½€¤€ƒ€^€;€€€€2€b€›€Ï€é€é€é€Ù€«€…€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€‹€«€Í€å€ë€ë€ë€è€Ö€º€œ€…€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€…€œ€º€Ö€è€ë€ë€ë€å€Í€«€‹€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€…€«€Ù€é€é€é€Ï€›€b€2€€€€;€^€ƒ€¤€½€Ñ€Þ€æ€é€ë€ë€ë€ë€ë€ë€ê€ç€â€Ö€Ä€«€€h€D€%€€€'€R€Š€Â€æ€ë€é€á€¹€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€†€«€×€ê€è€ë€Ü€±€~€N€)€€€€,€E€`€y€Ž€Ÿ€­€¶€»€½€½€º€³€©€š€‡€q€X€>€&€€€€1€\€€¿€ã€ë€è€é€Í€Ÿ€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€‘€³€Õ€é€ë€ë€ë€à€Æ€§€€€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€€€§€Æ€à€ë€ë€ë€é€Õ€³€‘€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€Ÿ€Í€é€è€ë€ã€¿€€\€1€€€€&€>€X€q€‡€š€©€³€º€½€½€»€¶€­€Ÿ€Ž€y€`€E€,€€€€)€N€~€±€Ü€ë€è€ê€×€«€†€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€›€Æ€ä€é€é€ê€Ö€¯€‚€X€6€€€€€€,€9€D€M€S€V€V€Q€J€A€5€(€€€€€$€>€c€€¼€Þ€ë€é€é€ß€º€‘€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€•€¸€Û€ê€ë€ë€é€×€·€˜€ƒ€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€ƒ€˜€·€×€é€ë€ë€ê€Û€¸€•€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€‘€º€ß€é€é€ë€Þ€¼€€c€>€$€€€€€(€5€A€J€Q€V€V€S€M€D€9€,€€€€€€6€X€‚€¯€Ö€ê€é€é€ä€Æ€›€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‰€®€Ö€é€è€é€é€Ú€»€˜€t€T€:€&€€€€€€€€€€€€€€€+€@€\€}€¡€Ä€à€ë€è€é€æ€Ì€£€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€€–€¼€Ý€ë€ë€ë€ç€Ð€¬€€~€|€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€|€~€€¬€Ð€ç€ë€ë€ë€Ý€¼€–€€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€£€Ì€æ€é€è€ë€à€Ä€¡€}€\€@€+€€€€€€€€€€€€€€€&€:€T€t€˜€»€Ú€é€é€è€é€Ö€®€‰€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€”€º€Ü€ê€è€é€ë€ä€Ò€¹€Ÿ€…€m€Z€J€?€8€3€1€1€4€:€C€O€`€t€Œ€¥€À€Ø€è€ë€è€é€è€Ó€®€Œ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€–€¼€Þ€ë€ë€ë€ä€Ê€¥€‡€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€‡€¥€Ê€ä€ë€ë€ë€Þ€¼€–€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€Œ€®€Ó€è€é€è€ë€è€Ø€À€¥€Œ€t€`€O€C€:€4€1€1€3€8€?€J€Z€m€…€Ÿ€¹€Ò€ä€ë€é€è€ê€Ü€º€”€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€˜€»€Ù€é€ê€è€é€ë€è€Ý€Ï€À€³€§€Ÿ€™€—€—€š€¡€«€·€Å€Ô€á€é€ë€é€è€ë€ç€Ñ€°€€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€’€¸€Ý€ë€ë€ë€â€Å€Ÿ€…€|€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€|€…€Ÿ€Å€â€ë€ë€ë€Ý€¸€’€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€€°€Ñ€ç€ë€è€é€ë€é€á€Ô€Å€·€«€¡€š€—€—€™€Ÿ€§€³€À€Ï€Ý€è€ë€é€è€ê€é€Ù€»€˜€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€“€°€Ì€á€ë€é€è€è€é€ë€ë€é€è€ç€æ€æ€ç€è€ê€ë€ê€è€è€è€ë€é€Ü€Å€§€Œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€|€}€€²€Ù€ë€ë€ë€â€Ã€€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€€Ã€â€ë€ë€ë€Ù€²€€}€|€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€Œ€§€Å€Ü€é€ë€è€è€è€ê€ë€ê€è€ç€æ€æ€ç€è€é€ë€ë€é€è€è€é€ë€á€Ì€°€“€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€‡€š€²€É€Ú€å€ë€ë€é€è€è€è€è€è€è€è€é€ê€ë€é€â€Ö€Ã€«€”€ƒ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€|€†€¨€Ò€é€ë€ë€ã€Å€ž€‚€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‚€ž€Å€ã€ë€ë€é€Ò€¨€†€|€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€ƒ€”€«€Ã€Ö€â€é€ë€ê€é€è€è€è€è€è€è€è€é€ë€ë€å€Ú€É€²€š€‡€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€ƒ€€Ÿ€¯€½€É€Ð€Ö€Ù€Û€Û€Ø€Õ€Î€Å€¸€ª€š€Œ€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€|€€€É€æ€ë€ë€æ€Ê€ €ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€ €Ê€æ€ë€ë€æ€É€€€|€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€Œ€š€ª€¸€Å€Î€Õ€Ø€Û€Û€Ù€Ö€Ð€É€½€¯€Ÿ€€ƒ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€…€‰€Œ€€€‹€ˆ€„€€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€’€½€á€ë€ë€é€Ñ€§€…€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€…€§€Ñ€é€ë€ë€á€½€’€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€€„€ˆ€‹€€€Œ€‰€…€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€{€‡€«€×€ë€ë€ë€Ú€±€Š€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Š€±€Ú€ë€ë€ë€×€«€‡€{€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¿€ë€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€š€É€è€ë€ë€â€¾€•€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€•€¾€â€ë€ë€è€É€š€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ë€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Í€ê€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€ €¨€Ä€â€ë€ë€é€Ö€¸€¤€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¤€¸€Ö€é€ë€ë€â€Ä€¨€ €¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€ê€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€â€è€ë€ë€ë€é€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€é€ë€ë€ë€è€â€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë{êévé‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuèç|æ{åƒäuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuäƒäuä}ãvâxâvâyãxæêë€ë€ë}è}äxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâ{áyà‚ß‚ÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞˆÞŠÞ†á‡æ€ê€ë€ë€é„ä…߈ފޅ݊݀܋Ü|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|ۋۀڈه؂׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~ׇÖÖ‚Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Ò€¸€Œ€Y€-€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è`ä…à>Ü‹Ú5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ8Ù‰ÓfÍbÇ“Á:¾™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿’¾6ºp¶<²P¯A¼o×ké€ë€ëxávÇQ²E­N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®^ªU¤‹ŸŽ™²”¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•³“Àš¸¥Ý€ë€ë‚è‚Χ¨±•¡‘€ŠÇ†e„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„e„Ë‚„|²v±p‹jËhsiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitg°cx_[~X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€W€N€=€+€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQáˆÛ ÖÒÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÒÑÈY¿T¶­ª¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««›¨£hœUµHÜ€ë€ë}è}ËF¤7’7’#’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’NŒA„{•sÉlÝmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜlÉm܇š¾¡æ€ë€ëÕž®nÛa€]èWYTîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîTYTîR†IÉ@Ç7.î,m-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n*Æ$u–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡k§(Ç{æ{ë€ë€ÞV¸K—6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÅt×¢ŠÙë€ë€ã•±ªsZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªš§´yÕdê€ë€êjÐd§6‘#‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞk¸‹ÆÅéë€ê€Å€ÏTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¬‘Â=à€ë€ëzãxÀ?›-‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞz£®­à€ë€ë€×[WìQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª£¯Ì‚çyë€ë€ÛQ±D“6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÈnÛ˜ŠÑ“ë€ë€án¢µ_ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªµÔYé€ë€êxÑ_¨8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj¦Í¾€è‚ë烵alÝQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªœ».Û€ë€ë‚çyÉk¤$–7‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj°eâm€¨±á€ë€ëwÆ›zZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¥«†ànë€ë€ãÂ>¤gœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ__æ‘zØŽë€ë€ÒhŠÇTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª­•ÇCå€ë€ëˆÞi½›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_ZêUdÏÌ€ë€ë|Ü‹—\ZêQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¢°Í‚èzë€êמ·'ª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðqu½¢ê€ë€ão¤´aZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª³ÒUê€ë€éÑS³¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQ`gà®çƒë肯_gáQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªŸµ#Ö€êë‚çyË£¯ª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQð_n¡¶á€ë€êt¹¤kZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª·ŠÙaë€ë€ä•ÆA¬¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQ\Xë•|ÛŒë€ë€ÁbpÚQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¸)Û€ë€ë…âpÂ¥«ª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðTiŒÅÕ€ë€ëwÆ›tZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªºˆÝhë€ë€àš¿4ª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZSïƒyÑ“ë€ë€ÊdxÔQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªœ».Þ€ë€ë‡Þj¼¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQe|ÑÍ€ë€ëxÌ—{ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¼ˆÞjë€ë€Ýœº,ª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðwxÉ™ë€ë€Ìe|ÑQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›¼/Þ€ë€ë‰Üf¸¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQct×Ç€ë€ëyÍ–|ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª»ˆÞjë€ë€Û¸)ª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðswÆ›ë€ë€Ìd{ÒQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªœº,Ý€ë€ë‰Ûe¸¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQct×Æ€ë€ëxʘxZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¸‰Üfë€ë€Û¹*ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðuwÆ›ë€ë€Çct×QZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªŸ¶&Ú€ë€ëˆÜg¹¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQcwÕÉ€ë€ëvÃoZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª³‹×^ë€ë€Þœ».ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðzxÌ–ë€ë€½`hßQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¢±Ô€ë€ë‡àm½¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQeÏÑ€ë€ês´¨bZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª®ÏPê€ë€â™À6ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZRð…{Õëè‚©]\èQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¤¬Ê‚è{ë„äuÃ¥ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðSiÅÛ€ë€ämž¸XZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª«–Ä>å€ë€ç”ÈC«¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ[Ví˜}á‡ë}ÞŠ‘[TîQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¿…âpëé|̤­ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðZn£´æ€ë€ÕfƒÌQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¹*Ý€ë€êŽÒU¯¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ^_æ±€êëxʘuZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª³‹×^ë€ë€Ø ³!ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðhu¾¡ë€ë€½`hàQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª£®Ѐë€ëˆÞj¸¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQct×Ì€ë€ëp¬®]ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª«”ÈDè€ë€ãš¿4ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðƒ{ØŽë~ä…™[UíQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¿„ätë‚çzÆ¥«ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðTk”¿ã€ë€Úg…ËQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªž·(Ý€ë€êÎO®¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ][騀êëxʘrZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª±ÔYë€ë€×¡³ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðgt»£ë€ë€µ^bäQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¥¬Êé|ë‡ßk¹¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQcwÕ΀ë€æm¹VZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªš¿4ä€ë€å—Â;ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZRðŒ}ÝŠë|ÛŒƒZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªµ‰Üfë€êͤ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðXo¤´é€ë€ÇalÝQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª£®Ñ€ë€ë‹×^²¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ_eâ½€ë€ëq®­\ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª—Ä=ç€ë€àœº-ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðyzÒ’ë}á‡ZSïQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¸‡ßkë‚çzÆ¥ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðSk”¿ã€ë€Îcs×QZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª£¯Ó€ë€ëŽÓW¯¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ]^ç²€ë€ër´¨^ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª–Æ@è€ë€ßž·'ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðqyΕë~㆓ZSïQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¸‡ßkëƒçy檪¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQiŽÄá€ë€Ïct×QZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª£®Ò€ë€ëÒU®¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ]]è°€ë€ër±ª\ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª—Ã<ç€ë€ßž¸(ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðsyÏ•ë~⇎ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¶ˆÝgë‚è{Ŧªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQj’Áä€ë€ÉanÛQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¤¬Í€ë€ëÔY¯¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ^_æµ€ë€ëo¦³WZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªš¾2ä€ë€âœ»-ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðz{Õë|ÛŒ€ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª±ŒÖ]ë€êÊ¥«ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðTmž¸ê€ë€»^bäQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªÅ‚è{ëŠÚc³¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ`hßÀë€äj“ÁQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªŸµ$Ý€ë€æ˜Â9ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðŠ}àˆëxË—mZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª«’ÌKê€ë€Ó£®ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð\r²©ëé‚¢[UíQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¹…âpë…âp»¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQdzÓÕ€ë€ÕcwÕQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¤­Ñ€ë€ë‘ÍL¬¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ[V준ë€ëq®¬[ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªš½2ä€ë€ÞŸ¶%ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðnxÌ–ë|ÚŒ€ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¯ÕZëé}È¥«ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðTl˜½ç€ë€·]^çQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªÀƒæwë‰Ûe³¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ`gàÆ€ë€ßg†ÉQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª£¯×€ë€è–Ä>ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð‘~ä…ët»£^ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª™À7ç€ë€Ù¡±ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðdvÁŸë~ᇇZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¯ŒÖ\ë‚çy¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQiŒÅá€ë€º]_æQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªÁ‚çyë‹Ø_±¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ_cã¾€ë€áhˆÈQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª£¯Õ€ë€ç˜Â:ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð‹~á‡ët¸¥^ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª™À6ç€ë€Ù¡±ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðduÀ ë}ᇅZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª®ÔXë‚è{檪¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQiŽÄä€ë€µ]\éQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª½ƒåvë‰Ûe²¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ_eâÆ€ë€Ýf€ÎQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¤¬Ñ€ë€ê•ÇCª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð—è‚ëq®­XZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªœº,ã€ë€ÞŸµ#ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðlxÌ—ë{ØŽwZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª’ÌLë€ë€Ë¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðRmŸ·ë€ë€£[SïQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¶‡ßkë†áo¸¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQcs×Ô€ë€ÎanÛQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªÆé|ëÐQ¬¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ[Vì«€ë€æk•¿QZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¡±Ù€ë€å›½1ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð}ÞŠëvÁŸcZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª™¿5æ€ë€Ö£®ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð]t¹¤ë}߉„ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¬ÑTëé}Ħªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQiÃç€ë€¯\XëQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¸†ánëˆÝg³¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ`hßÉ€ë€ÓbsØQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªÈê~ë’ÌK«¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ[Uí¢€ë€èl™¼QZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¡±Ù€ë€ãœº-ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðy|ÙëvÁŸcZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªš½2å€ë€Õ£®ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð]t¸¥ë|Ý‹€ZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª¬‘ÎNëé}Ħªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQjÂç€ë€§[VìQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª´ˆÝhë‡ßkµ¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQamÜ΀ë€Ê`ißQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªÁ‚èzëÐR­¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ\Y묀ë€ãh‰ÈQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¤­Ñ€ë€ç™À6ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð†~á‡ëq¯¬ZZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªªŸµ$߀ë€Ü ³ ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðhwÈ™ëyÏ•mZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª—Ã;é€ë€Î¥«ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðVo¦²ëçƒZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ª­ŽÒUëƒæw¾¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQf‚Ìހ뀱\YêQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªµ‡ßlë‰Üf³¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ`gàÇ€ë€ÏamÜQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªÂé}ë‘ÎN«¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQ[Të€çh‹ÆQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¤¬Ñ€ë€æ™¿5ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQð…}àˆëq­­WZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª ³ Þ€ë€Þ ´"ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðjxÌ—ëxÌ—hZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª™¿4è€ë€Ñ¥¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðVq®­ë~ㆃZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQàˆÛÕÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÒ’ÒÑŽÇY¾Sµ¬ª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª’ÌKë‚è{檪¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª¦ªª›§¡hœ–8‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘6‘"‘M‹@‚‘y•pÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞjÊjÞj±eâ_€ZêTZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQiŽÄä€ë€£[SïQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðQZQðO†FÊ=É4*ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n)ð)n&È t–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€æQáˆÛ ÖÒÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÓÓ’ÒÑÈY¿T¶­ª¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¦ª±ŠÙbë†áo¸¦ª«¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««¥««›¨£h˜9“$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’7’$’NŒA„{•sÉlÝmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜmÉmÜm°gàb€]èWYTîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîQct×Ô€ë€Á^bäS[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîT[TîTYTîR†IÉ@Ç7.î,m-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n-î-n*Æ$u–|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è`ä…à>Ü‹Ú5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ5ÚŒÚ8Ù‰ÓfÍbÇ“Á:¾™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿š¿4ʃæxëˆÝhš¿4¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿™¿5¿’¾6ºp¶<²O¯A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®N®A®^ªU¤‹ŸŽ™²”¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•²•¿•¡‘€ŠÇ†e„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„˃h‹ÆÊ€ë€àm¹ƒg„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„g„Ë„e„Ë‚„|²v±p‹jËhsiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitiËitg°cx_[~X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€W€N€=€+€€€€0€b€™€Ë€è€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë{êévé‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuè‚èuèç|æ{åƒäuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuç€ë€ë‚çzä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuä„äuäƒäuä}ãvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâxâvâ{áyà‚߂ވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފވފޅ݊݀܋Ü|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹ã€ë€ë~â‡Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|Û‹Û|ۋۀڈه؂׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~׋×~ׇÖÖ‚Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Ò€¸€Œ€Y€-€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ç€ë€ê€ã€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€ã€ê€ë€ç€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¨€Ç€è€á€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Í€ê€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €«€Ü€ë€Ü€¬€ €¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€ €¬€Ü€ë€Ü€«€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€ê€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€á€è€Ç€¨€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€‰€·€è€Ü€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¿€ë€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€Ÿ€â€ë€Ã€ƒ€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€ƒ€Ã€ë€â€Ÿ€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ë€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ü€è€·€‰€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€¯€ê€é€­€{€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€{€­€é€ê€¯€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€Ã€ë€â€›€{€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€{€›€â€ë€Ã€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€Œ€Ô€ë€Ô€Œ€|€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€|€Œ€Ô€ë€Ô€Œ€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€›€á€ë€Â€€|€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€|€€Â€ë€á€›€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€«€è€ë€°€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€°€ë€è€«€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€½€ë€å€Ÿ€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€Ÿ€å€ë€½€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€‡€Í€ë€Ù€€{€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€{€€Ù€ë€Í€‡€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€“€Û€ë€Ê€…€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€…€Ê€ë€Û€“€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€ €ã€ë€º€€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€€º€ë€ã€ €y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€°€è€ë€ª€}€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€}€ª€ë€è€°€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€¾€ë€ã€›€{€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€{€›€ã€ë€¾€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Í€ë€×€Ž€{€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€{€Ž€×€ë€Í€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€’€Ø€ë€Ê€†€{€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€{€†€Ê€ë€Ø€’€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€€à€ë€½€€{€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€{€€½€ë€à€€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€¨€æ€ë€¯€~€|€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€|€~€¯€ë€æ€¨€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€µ€ë€è€£€|€|€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€|€|€£€è€ë€µ€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€€Á€ë€ß€—€z€|€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€|€z€—€ß€ë€Á€€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Ì€ë€Ö€€z€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€z€€Ö€ë€Ì€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€€Ö€ë€Ë€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Ë€ë€Ö€€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€˜€Ü€ë€À€‚€z€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€z€‚€À€ë€Ü€˜€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€ €â€ë€¶€€€{€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€{€€€¶€ë€â€ €x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€«€è€ë€«€}€{€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€{€}€«€ë€è€«€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€|€´€ë€ç€¡€{€|€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€|€{€¡€ç€ë€´€|€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€€½€ë€á€™€z€|€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€|€z€™€á€ë€½€€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€…€Æ€ë€Ù€’€z€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€z€’€Ù€ë€Æ€…€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€‰€Î€ë€Ñ€Œ€y€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€y€Œ€Ñ€ë€Î€‰€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€Ž€Ô€ë€Ê€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Ê€ë€Ô€Ž€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€“€Ù€ë€Ã€„€z€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€z€„€Ã€ë€Ù€“€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€™€Þ€ë€½€€z€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€z€€½€ë€Þ€™€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€y€Ÿ€â€ë€¶€€{€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€{€€¶€ë€â€Ÿ€y€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€¥€ç€ë€¯€}€{€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€{€}€¯€ë€ç€¥€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€ª€ê€ë€ª€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€ª€ë€ê€ª€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€|€°€ë€è€¤€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€¤€è€ë€°€|€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€~€´€ë€ä€Ÿ€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€Ÿ€ä€ë€´€~€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€€€¹€ë€â€›€y€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€y€›€â€ë€¹€€€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€€½€ë€Þ€—€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€—€Þ€ë€½€€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€ƒ€Á€ë€Û€”€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€”€Û€ë€Á€ƒ€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€…€Å€ë€Ù€’€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€’€Ù€ë€Å€…€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€†€È€ë€Ö€€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€€Ö€ë€È€†€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Ê€ë€Ô€€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€€Ô€ë€Ê€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€ˆ€Ë€ë€Ò€€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€€Ò€ë€Ë€ˆ€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€ˆ€Í€ë€Ñ€Œ€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€Œ€Ñ€ë€Í€ˆ€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€‰€·€è€Ü€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¿€ë€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€{€Œ€Ï€ë€Ð€€{€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€{€€Ð€ë€Ï€Œ€{€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ë€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ü€è€·€‰€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¨€Ç€è€á€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Í€ê€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€×€ë€Ù€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ù€ë€×€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€ê€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€á€è€Ç€¨€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€è€ë€è€â€ß€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ß€â€è€ë€è€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€è€ë€è€â€ß€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ß€â€è€ë€è€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¨€Ç€è€á€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Í€ê€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€×€ë€Ù€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ù€ë€×€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€ê€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€á€è€Ç€¨€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€‰€·€è€Ü€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¿€ë€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€{€Œ€Ï€ë€Ð€€{€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€{€€Ð€ë€Ï€Œ€{€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ë€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ü€è€·€‰€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€ˆ€Í€ë€Ñ€Œ€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€Œ€Ñ€ë€Í€ˆ€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€ˆ€Ë€ë€Ò€€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€€Ò€ë€Ë€ˆ€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Ê€ë€Ô€€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€€Ô€ë€Ê€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€†€È€ë€Ö€€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€€Ö€ë€È€†€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€…€Å€ë€Ù€’€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€’€Ù€ë€Å€…€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€ƒ€Á€ë€Û€”€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€”€Û€ë€Á€ƒ€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€€½€ë€Þ€—€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€—€Þ€ë€½€€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€€€¹€ë€â€›€y€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€y€›€â€ë€¹€€€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€~€´€ë€ä€Ÿ€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€Ÿ€ä€ë€´€~€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€|€°€ë€è€¤€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€¤€è€ë€°€|€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€ª€ê€ë€ª€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€ª€ë€ê€ª€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€¥€ç€ë€¯€}€{€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€{€}€¯€ë€ç€¥€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€y€Ÿ€â€ë€¶€€{€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€{€€¶€ë€â€Ÿ€y€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€™€Þ€ë€½€€z€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€z€€½€ë€Þ€™€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€“€Ù€ë€Ã€„€z€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€z€„€Ã€ë€Ù€“€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€Ž€Ô€ë€Ê€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Ê€ë€Ô€Ž€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€‰€Î€ë€Ñ€Œ€y€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€y€Œ€Ñ€ë€Î€‰€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€…€Æ€ë€Ù€’€z€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€z€’€Ù€ë€Æ€…€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€€½€ë€á€™€z€|€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€|€z€™€á€ë€½€€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€|€´€ë€ç€¡€{€|€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€|€{€¡€ç€ë€´€|€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€z€«€è€ë€«€}€{€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€{€}€«€ë€è€«€z€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€ €â€ë€¶€€€{€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€{€€€¶€ë€â€ €x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€˜€Ü€ë€À€‚€z€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€z€‚€À€ë€Ü€˜€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€€Ö€ë€Ë€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Ë€ë€Ö€€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Ì€ë€Ö€€z€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€z€€Ö€ë€Ì€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€€Á€ë€ß€—€z€|€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€|€z€—€ß€ë€Á€€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€µ€ë€è€£€|€|€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€|€|€£€è€ë€µ€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€¨€æ€ë€¯€~€|€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€|€~€¯€ë€æ€¨€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€x€€à€ë€½€€{€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€{€€½€ë€à€€x€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€’€Ø€ë€Ê€†€{€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€{€†€Ê€ë€Ø€’€y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€‡€Í€ë€×€Ž€{€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€{€Ž€×€ë€Í€‡€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€¾€ë€ã€›€{€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€{€›€ã€ë€¾€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€°€è€ë€ª€}€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€}€ª€ë€è€°€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€y€ €ã€ë€º€€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€€º€ë€ã€ €y€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€“€Û€ë€Ê€…€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€…€Ê€ë€Û€“€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€‡€Í€ë€Ù€€{€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€{€€Ù€ë€Í€‡€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€½€ë€å€Ÿ€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€Ÿ€å€ë€½€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€«€è€ë€°€|€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€|€°€ë€è€«€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€z€›€á€ë€Â€€|€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€|€€Â€ë€á€›€z€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€Œ€Ô€ë€Ô€Œ€|€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€|€Œ€Ô€ë€Ô€Œ€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€Ã€ë€â€›€{€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€{€›€â€ë€Ã€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€¯€ê€é€­€{€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€{€­€é€ê€¯€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€‰€·€è€Ü€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¿€ë€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€Ÿ€â€ë€Ã€ƒ€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€ƒ€Ã€ë€â€Ÿ€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ë€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ü€è€·€‰€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¨€Ç€è€á€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Í€ê€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €«€Ü€ë€Ü€¬€ €¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€ €¬€Ü€ë€Ü€«€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€ê€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€á€è€Ç€¨€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ç€ë€ê€ã€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€ã€ê€ë€ç€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€-€Y€Œ€¸€Ò€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Ö€Ö€Ö€×€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ù€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€â€ë€ë€ã€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Ü€Ý€Ý€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€ß€à€à€á€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€ã€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€è€ë€ë€è€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€ç€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€é€é€ê€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€+€=€N€W€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€\€a€f€j€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€n€s€w€|€€€€€€€€€€€€€€€€€€€€€€€€€€š€à€ë€Ê€‰€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€„€‰€€’€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€š€Ÿ€¤€©€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€±€µ€º€¿€Ã€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Á€Ä€Þ€ë€ç€Ì€Á€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Ã€Ç€Ì€Ð€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ù€Ý€â€ç€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€!€(€/€3€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€3€:€A€I€P€R€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€P€_€À€ë€Ô€r€L€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€P€T€\€b€i€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€u€|€‚€Š€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€–€€¤€«€¯€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€¬€»€â€ë€Û€´€­€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€­€°€·€¾€Å€Ì€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Ì€Ñ€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€P€¡€ë€ã€Œ€I€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€Å€è€ë€Î€®€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€L€€ã€ë€¬€S€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€Ò€ë€è€Â€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€e€Ë€ë€Ë€h€I€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€·€Þ€ë€Þ€·€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€S€«€ë€ß€‚€G€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€Â€æ€ë€Ò€°€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€M€‰€ç€ë€¥€Q€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€Ð€ë€é€Ä€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€i€Ï€ë€Æ€d€H€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€¶€Ý€ë€à€¸€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€V€°€ë€Ý€€€H€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€Á€æ€ë€Ó€±€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€M€‹€ç€ë€¥€R€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€Ð€ë€é€Å€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€I€j€Î€ë€Ç€d€H€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€¶€Ý€ë€à€¸€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€V€­€ë€á€ƒ€J€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€«€Ã€ç€ë€Ó€±€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€K€‡€ã€ë€«€V€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€°€Ò€ë€è€Ã€¬€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€G€f€Ê€ë€Î€j€H€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€¸€ß€ë€Þ€·€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€S€¥€ë€è€Ž€M€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€­€Ç€é€ë€Ð€¯€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€H€}€Ü€ë€·€Z€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€±€Ö€ë€å€À€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€I€`€À€ë€Ù€v€J€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€½€ä€ë€Ú€´€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€M€—€è€ë€ €Q€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€Î€ë€é€Ê€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€G€p€Ó€ë€È€e€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€·€Ý€ë€â€º€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€U€­€ë€è€€N€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€­€Å€é€ë€Ó€°€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€H€‚€ß€ë€¸€Z€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€±€×€ë€æ€Â€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€`€À€ë€Ý€}€L€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¿€æ€ë€Ú€´€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€K€“€æ€ë€ª€R€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€Ñ€ë€é€É€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€k€Í€ë€Ô€q€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€»€â€ë€à€¸€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€P€¡€ë€ë€ž€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€®€Ì€ë€ë€Î€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€t€×€ë€Ê€h€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¸€ß€ë€â€¼€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€T€«€ë€è€”€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€É€é€ë€Ó€°€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€}€Ý€ë€Å€b€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¶€Ü€ë€å€À€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€X€³€ë€ä€Œ€J€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€Æ€è€ë€Ö€±€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€M€‚€à€ë€¾€`€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€´€Ú€ë€ç€Ã€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€Z€·€ë€á€‰€J€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€Ä€ç€ë€×€²€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€M€…€á€ë€½€`€I€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€´€Ù€ë€è€Ã€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€\€¹€ë€á€Š€J€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¬€Å€è€ë€×€²€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€M€…€â€ë€À€a€H€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€µ€Ú€ë€ç€Ã€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€[€»€ë€ã€Ž€M€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€­€Ç€è€ë€×€²€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€L€„€Þ€ë€Ä€d€I€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€¶€Ü€ë€æ€Ã€¬€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€I€[€µ€ë€è€–€P€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€®€Ê€é€ë€Ö€²€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€J€}€Ú€ë€Ë€k€J€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€¸€Þ€ë€ä€À€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€W€¬€ë€ë€¢€S€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€Ï€ë€ë€Ó€±€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€H€t€Õ€ë€Õ€w€L€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€½€â€ë€â€½€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€Q€ €è€ë€±€X€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€±€Õ€ë€ê€Î€¯€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€I€j€Ê€ë€à€‡€M€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€Ã€ç€ë€Þ€¸€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€M€€ä€ë€Ã€e€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¶€Û€ë€è€È€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€_€º€ë€ê€œ€P€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€®€Ì€ê€ë€×€´€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€~€Û€ë€Õ€w€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€½€â€ë€å€À€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€T€¤€ë€ë€µ€\€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€²€Õ€ë€ë€Ð€°€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€j€É€ë€ä€€M€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€Ç€è€ë€Ý€¹€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€M€Œ€â€ë€Î€o€I€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€»€à€ë€è€Å€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€Y€°€ë€ë€®€Y€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€±€Ô€ë€ë€Ô€±€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€L€r€Ï€ë€á€Œ€M€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¬€Æ€ç€ë€ß€»€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€P€’€ã€ë€Î€n€H€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€º€ß€ë€è€È€®€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€Z€²€ë€ë€±€[€I€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€²€Ô€ë€ë€Õ€±€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€J€p€Î€ë€â€’€P€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€®€É€è€ë€ß€»€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€O€€á€ë€Ñ€v€K€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€½€â€ë€ç€Æ€®€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€X€¬€ë€ë€¼€b€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€µ€Ù€ë€ë€Ò€±€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€I€i€Ç€ë€è€£€T€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€°€Î€ê€ë€Ü€·€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€K€€Û€ë€Ü€Š€O€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€­€Å€æ€ë€å€Á€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€R€›€æ€ë€Î€t€L€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¼€ß€ë€è€Ë€¯€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€_€´€ë€ë€º€c€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¶€Ø€ë€ë€Ö€´€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€o€Ê€ë€ê€¦€W€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€±€Ð€ë€ë€Þ€º€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€‚€Ú€ë€â€’€P€M€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€®€È€è€ë€ä€Â€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€—€ä€ë€Ø€€€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€Á€ã€ë€è€Ê€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Z€«€ë€ë€Ë€q€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€¼€ß€ë€ë€Ñ€±€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€e€¼€ë€ë€½€e€I€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€¶€Ù€ë€ë€Ù€¶€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€L€r€Ê€ë€ê€°€\€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€³€Ó€ê€ë€Þ€»€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€N€€€Õ€ë€æ€¢€V€J€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€«€±€Î€è€ë€â€Á€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€P€Ž€Ý€ë€á€–€R€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€Ê€ç€ë€æ€Æ€®€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€T€œ€ä€ë€Û€Œ€P€K€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€®€Å€å€ë€è€Ì€°€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€Y€¨€è€ë€Ö€ƒ€N€L€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€­€Â€â€ë€é€Ð€±€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€_€³€ê€ë€Ð€}€M€M€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¿€à€ë€ë€Õ€´€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€e€»€ë€ë€Ë€x€M€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€½€ß€ë€ë€Ù€·€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€l€Â€ë€ë€È€t€L€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€¬€½€Ý€ë€ë€Û€¹€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€q€Æ€ë€ë€Æ€r€K€N€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€­€¬€»€Ü€ë€ë€Ü€»€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€u€Ê€ë€ë€Å€q€J€N€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€­€¬€»€Ü€ë€ë€Ý€½€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€y€Ë€ë€ë€Å€p€J€N€N€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€­€«€»€Ü€ë€ë€ß€¾€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€M€z€Ì€ë€ë€Æ€q€K€M€N€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€­€­€¬€»€Ü€ë€ë€ß€¾€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€N€z€Ë€ë€ë€É€t€L€M€N€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€­€¬€¬€½€Ý€ë€ë€ß€¿€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€N€y€Ë€ë€ë€Ì€z€N€L€N€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€­€¬€­€¾€ß€ë€ë€Þ€½€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€M€u€É€ë€ë€Ð€€O€L€N€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€­€¬€­€Á€á€ë€ë€Þ€½€¬€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€L€r€Æ€ë€ë€Õ€‰€P€L€N€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€¬€¯€Ä€â€ë€ë€Ü€»€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€K€n€¿€ë€ë€Ú€“€V€M€N€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€­€°€È€å€ë€ë€Ú€¹€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€h€¸€é€ë€á€Ÿ€\€M€N€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€­€­€²€Î€è€ë€ê€Ö€·€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€c€®€è€ë€ç€¬€c€L€M€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€®€¬€¶€Ó€é€ë€ê€Ó€¶€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€]€£€ã€ë€ê€¼€n€J€Q€Y€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€­€º€Ù€ë€ë€è€Ï€³€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€V€•€Ü€ë€ë€Ë€|€R€W€_€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€›€¢€ª€À€Þ€ë€ë€å€Ê€±€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€ˆ€Ñ€ë€ë€×€€^€\€g€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€”€™€¥€Ä€ä€ë€ë€á€Ã€®€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€N€x€Å€ë€ë€á€¨€n€d€m€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€“€£€Ê€ç€ë€ë€Ü€¾€­€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€L€h€´€è€ë€è€¾€ƒ€m€m€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€¦€Ñ€é€ë€é€Ö€¸€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€J€\€ €â€ë€ë€Ò€š€q€m€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€¯€Ú€ë€ë€è€Í€²€«€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€K€T€Ž€Ö€ë€ë€à€¯€|€m€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€™€¿€ã€ë€ë€á€Ä€°€¬€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€L€R€€Å€ê€ë€é€Å€€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€Ž€¥€Ð€ê€ë€ê€Ö€µ€ª€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$€+€0€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€/€0€7€>€E€L€O€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€N€M€Q€W€s€±€ä€ë€ë€Ù€¤€w€l€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€n€s€z€€ˆ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€Œ€”€·€Þ€ë€ë€å€Å€¦€¡€ª€®€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€­€¬€¯€¶€½€Ä€Ë€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ì€Ë€Ð€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€!€(€/€3€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€2€3€:€A€I€P€R€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€Q€P€T€\€b€p€ €Ö€ë€ë€ç€¿€‰€p€o€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€p€u€|€‚€Š€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€Ž€€¢€Ê€è€ë€ë€Û€´€š€œ€¤€«€¯€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€®€­€°€·€¾€Å€Ì€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Í€Ì€Ñ€×€Ý€å€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€€+€=€N€W€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€X€\€a€f€j€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€m€n€s€w€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€„€‰€€’€–€ª€Ð€è€ë€ë€Ý€¹€œ€–€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€—€š€Ÿ€¤€©€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€¬€«€°€Æ€á€ë€ë€é€Ö€º€¬€±€µ€º€¿€Ã€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Â€Ã€Ç€Ì€Ð€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ö€Ù€Ý€â€ç€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€-€Y€Œ€¸€Ò€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Ö€Ö€Ö€×€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ù€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Ü€Ý€Ý€Þ€Þ€ß€ä€é€ë€ë€ê€ç€á€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€ß€à€à€á€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€ä€è€ë€ë€ë€ê€æ€â€â€â€â€â€ã€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€ç€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€é€é€ê€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€-€Y€Œ€¸€Ò€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Ö€ß€é€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€ç€Ý€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ø€Ü€å€ë€æ€Þ€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€ß€è€ë€æ€Ý€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€Û€à€è€ë€å€à€Þ€Þ€Þ€â€ç€ê€ë€ë€é€ä€ß€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€ß€ã€é€ê€å€à€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€Þ€ß€ä€ê€ê€å€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€æ€ê€é€å€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€â€ç€ê€ë€ë€ë€è€ä€â€â€â€â€è€ê€é€ç€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€æ€è€ë€é€ç€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€å€ç€ê€ë€ê€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€è€ê€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€è€Ë€™€b€0€€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Í€ê€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€ €¨€Ä€â€ë€ë€é€Ö€¸€¤€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¤€¸€Ö€é€ë€ë€â€Ä€¨€ €¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€ê€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¿€ë€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€š€É€è€ë€ë€â€¾€•€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€•€¾€â€ë€ë€è€É€š€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ë€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€{€‡€«€×€ë€ë€ë€Ú€±€Š€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Š€±€Ú€ë€ë€ë€×€«€‡€{€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€…€‰€Œ€€€‹€ˆ€„€€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€’€½€á€ë€ë€é€Ñ€§€…€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€…€§€Ñ€é€ë€ë€á€½€’€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€€„€ˆ€‹€€€Œ€‰€…€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€ƒ€€Ÿ€¯€½€É€Ð€Ö€Ù€Û€Û€Ø€Õ€Î€Å€¸€ª€š€Œ€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€|€€€É€æ€ë€ë€æ€Ê€ €ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€ €Ê€æ€ë€ë€æ€É€€€|€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€Œ€š€ª€¸€Å€Î€Õ€Ø€Û€Û€Ù€Ö€Ð€É€½€¯€Ÿ€€ƒ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€‡€š€²€É€Ú€å€ë€ë€é€è€è€è€è€è€è€è€é€ê€ë€é€â€Ö€Ã€«€”€ƒ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€|€†€¨€Ò€é€ë€ë€ã€Å€ž€‚€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‚€ž€Å€ã€ë€ë€é€Ò€¨€†€|€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€ƒ€”€«€Ã€Ö€â€é€ë€ê€é€è€è€è€è€è€è€è€é€ë€ë€å€Ú€É€²€š€‡€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€“€°€Ì€á€ë€é€è€è€é€ë€ë€é€è€ç€æ€æ€ç€è€ê€ë€ê€è€è€è€ë€é€Ü€Å€§€Œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€|€}€€²€Ù€ë€ë€ë€â€Ã€€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€€Ã€â€ë€ë€ë€Ù€²€€}€|€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€Œ€§€Å€Ü€é€ë€è€è€è€ê€ë€ê€è€ç€æ€æ€ç€è€é€ë€ë€é€è€è€é€ë€á€Ì€°€“€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€˜€»€Ù€é€ê€è€é€ë€è€Ý€Ï€À€³€§€Ÿ€™€—€—€š€¡€«€·€Å€Ô€á€é€ë€é€è€ë€ç€Ñ€°€€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€’€¸€Ý€ë€ë€ë€â€Å€Ÿ€…€|€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€|€…€Ÿ€Å€â€ë€ë€ë€Ý€¸€’€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€€°€Ñ€ç€ë€è€é€ë€é€á€Ô€Å€·€«€¡€š€—€—€™€Ÿ€§€³€À€Ï€Ý€è€ë€é€è€ê€é€Ù€»€˜€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€”€º€Ü€ê€è€é€ë€ä€Ò€¹€Ÿ€…€m€Z€J€?€8€3€1€1€4€:€C€O€`€t€Œ€¥€À€Ø€è€ë€è€é€è€Ó€®€Œ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€–€¼€Þ€ë€ë€ë€ä€Ê€¥€‡€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€‡€¥€Ê€ä€ë€ë€ë€Þ€¼€–€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€Œ€®€Ó€è€é€è€ë€è€Ø€À€¥€Œ€t€`€O€C€:€4€1€1€3€8€?€J€Z€m€…€Ÿ€¹€Ò€ä€ë€é€è€ê€Ü€º€”€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‰€®€Ö€é€è€é€é€Ú€»€˜€t€T€:€&€€€€€€€€€€€€€€€+€@€\€}€¡€Ä€à€ë€è€é€æ€Ì€£€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€€–€¼€Ý€ë€ë€ë€ç€Ð€¬€€~€|€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€|€~€€¬€Ð€ç€ë€ë€ë€Ý€¼€–€€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€£€Ì€æ€é€è€ë€à€Ä€¡€}€\€@€+€€€€€€€€€€€€€€€&€:€T€t€˜€»€Ú€é€é€è€é€Ö€®€‰€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€›€Æ€ä€é€é€ê€Ö€¯€‚€X€6€€€€€€,€9€D€M€S€V€V€Q€J€A€5€(€€€€€$€>€c€€¼€Þ€ë€é€é€ß€º€‘€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€•€¸€Û€ê€ë€ë€é€×€·€˜€ƒ€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€ƒ€˜€·€×€é€ë€ë€ê€Û€¸€•€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€‘€º€ß€é€é€ë€Þ€¼€€c€>€$€€€€€(€5€A€J€Q€V€V€S€M€D€9€,€€€€€€6€X€‚€¯€Ö€ê€é€é€ä€Æ€›€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€†€«€×€ê€è€ë€Ü€±€~€N€)€€€€,€E€`€y€Ž€Ÿ€­€¶€»€½€½€º€³€©€š€‡€q€X€>€&€€€€1€\€€¿€ã€ë€è€é€Í€Ÿ€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€‘€³€Õ€é€ë€ë€ë€à€Æ€§€€€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€€€§€Æ€à€ë€ë€ë€é€Õ€³€‘€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€Ÿ€Í€é€è€ë€ã€¿€€\€1€€€€&€>€X€q€‡€š€©€³€º€½€½€»€¶€­€Ÿ€Ž€y€`€E€,€€€€)€N€~€±€Ü€ë€è€ê€×€«€†€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€¹€á€é€ë€æ€Â€Š€R€'€€€%€D€h€€«€Ä€Ö€â€ç€ê€ë€ë€ë€ë€ë€ë€é€æ€Þ€Ñ€½€¤€ƒ€^€;€€€€2€b€›€Ï€é€é€é€Ù€«€…€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€‹€«€Í€å€ë€ë€ë€è€Ö€º€œ€…€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€…€œ€º€Ö€è€ë€ë€ë€å€Í€«€‹€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€…€«€Ù€é€é€é€Ï€›€b€2€€€€;€^€ƒ€¤€½€Ñ€Þ€æ€é€ë€ë€ë€ë€ë€ë€ê€ç€â€Ö€Ä€«€€h€D€%€€€'€R€Š€Â€æ€ë€é€á€¹€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€“€Â€æ€é€ë€Ú€¦€g€1€€€)€P€~€¨€Ê€ß€ê€ë€å€Û€Ð€Ä€¼€·€´€´€·€¾€È€Ó€Þ€è€ë€è€Ú€Â€€q€D€€€€?€y€·€â€ë€é€à€³€ˆ€{€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€†€ €Á€Ü€ê€ë€ë€ë€ã€Î€³€´€Ü€å€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€å€Ü€´€³€Î€ã€ë€ë€ë€ê€Ü€Á€ €†€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€{€ˆ€³€à€é€ë€â€·€y€?€€€€D€q€€Â€Ú€è€ë€è€Þ€Ó€È€¾€·€´€´€·€¼€Ä€Ð€Û€å€ë€ê€ß€Ê€¨€~€P€)€€€1€g€¦€Ú€ë€é€æ€Â€“€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€|€•€È€é€ê€ê€Ê€€L€€€"€L€€±€Ö€è€ë€ß€Ê€±€˜€€n€_€T€N€J€J€O€W€c€t€ˆ€ €¹€Ñ€ã€ë€å€Í€¥€q€>€€€'€]€Ÿ€×€ê€ë€ä€¸€‰€{€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€“€±€Ð€å€ë€ë€ë€ê€ä€è€è€À€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€À€è€è€ä€ê€ë€ë€ë€å€Ð€±€“€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€{€‰€¸€ä€ë€ê€×€Ÿ€]€'€€€>€q€¥€Í€å€ë€ã€Ñ€¹€ €ˆ€t€c€W€O€J€J€N€T€_€n€€˜€±€Ê€ß€ë€è€Ö€±€€L€"€€€L€€Ê€ê€ê€é€È€•€|€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€|€|€•€Ê€è€ê€ç€½€y€8€€€:€r€«€Ö€ê€è€Ó€²€€j€L€4€%€€€€€€€€€€€)€;€T€t€—€¼€Ú€ê€ç€Ë€š€a€,€€€H€€Í€ê€ê€â€º€Š€{€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€‡€Ÿ€½€×€è€ë€ë€ë€ë€æ€Ð€´€œ€‰€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€‰€œ€´€Ð€æ€ë€ë€ë€ë€è€×€½€Ÿ€‡€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€{€Š€º€â€ê€ê€Í€€H€€€,€a€š€Ë€ç€ê€Ú€¼€—€t€T€;€)€€€€€€€€€€€%€4€L€j€€²€Ó€è€ê€Ö€«€r€:€€€8€y€½€ç€ê€è€Ê€•€|€|€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€|€{€’€È€ç€ë€å€µ€k€+€€€R€“€Ê€è€è€Ð€¦€x€O€.€€€€€ €*€2€8€:€:€7€0€&€€€€€€5€Y€„€²€Ù€ë€â€¼€€€A€€€:€€€È€ë€ê€â€·€‡€{€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€¥€Ä€à€ë€ë€ë€ë€ë€ä€Õ€¿€©€”€…€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€…€”€©€¿€Õ€ä€ë€ë€ë€ë€ë€à€Ä€¥€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€{€‡€·€â€ê€ë€È€€€:€€€A€€€¼€â€ë€Ù€²€„€Y€5€€€€€€&€0€7€:€:€8€2€*€ €€€€€.€O€x€¦€Ð€è€è€Ê€“€R€€€+€k€µ€å€ë€ç€È€’€{€|€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€{€€Â€æ€ë€å€±€c€$€€+€h€«€Ý€ë€Ø€¬€v€E€#€€€€3€M€e€z€‹€˜€Ÿ€¢€¢€€”€†€t€]€D€,€€€€*€Q€‡€»€â€ë€Ñ€™€U€€€2€z€Æ€ë€ê€ß€±€„€|€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€„€°€â€ê€ã€ç€ë€ë€ë€ë€é€ß€Ï€»€¦€”€‡€€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€€‡€”€¦€»€Ï€ß€é€ë€ë€ë€ë€ç€ã€ê€â€°€„€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€|€„€±€ß€ê€ë€Æ€z€2€€€U€™€Ñ€ë€â€»€‡€Q€*€€€€,€D€]€t€†€”€€¢€¢€Ÿ€˜€‹€z€e€M€3€€€€#€E€v€¬€Ø€ë€Ý€«€h€+€€$€c€±€å€ë€æ€Â€€{€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€{€‡€¸€â€ë€æ€³€b€!€€3€w€½€ç€è€Â€ˆ€M€$€€€,€N€t€–€´€Ê€×€à€å€è€è€è€ç€ä€Ý€Ó€Ã€«€€i€D€%€€€-€]€›€Ð€ë€Þ€«€c€%€€/€z€É€ë€ê€Ú€¨€€|€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€½€ª€¼€Ó€ã€ê€ë€ë€ë€ë€è€á€Ò€Â€°€Ÿ€‘€†€€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€€†€‘€Ÿ€°€Â€Ò€á€è€ë€ë€ë€ë€ê€ã€Ó€¼€ª€½€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€|€€¨€Ú€ê€ë€É€z€/€€%€c€«€Þ€ë€Ð€›€]€-€€€%€D€i€€«€Ã€Ó€Ý€ä€ç€è€è€è€å€à€×€Ê€´€–€t€N€,€€€$€M€ˆ€Â€è€ç€½€w€3€€!€b€³€æ€ë€â€¸€‡€{€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€{€€«€Þ€ë€é€»€f€"€€8€€Ç€ë€ß€¬€j€1€€€.€Y€‡€±€Ð€ä€ë€ê€ã€Ü€Ô€Ï€Ì€Ì€Ð€Ö€Þ€æ€ë€ê€ß€É€§€{€L€%€€€@€~€½€ç€å€·€l€'€€1€€€Ð€ë€ë€Ò€œ€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€~€‡€š€±€Ç€Ú€æ€ë€ë€ë€ë€ë€ë€ç€Ý€Ð€Â€³€¥€™€Ž€‡€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€‡€Ž€™€¥€³€Â€Ð€Ý€ç€ë€ë€ë€ë€ë€ë€æ€Ú€Ç€±€š€‡€~€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€œ€Ò€ë€ë€Ð€€€1€€'€l€·€å€ç€½€~€@€€€%€L€{€§€É€ß€ê€ë€æ€Þ€Ö€Ð€Ì€Ì€Ï€Ô€Ü€ã€ê€ë€ä€Ð€±€‡€Y€.€€€1€j€¬€ß€ë€Ç€€8€€"€f€»€é€ë€Þ€«€€{€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€|€}€€Õ€ë€ë€Ç€q€&€€8€„€Ì€ë€×€œ€U€€€#€P€‡€¹€Ü€ê€è€Ú€Ã€«€•€‚€t€l€h€h€n€y€ˆ€œ€´€Ë€ß€ë€è€Ô€­€y€A€€€-€i€°€â€è€»€m€&€€8€Œ€Ù€ë€ê€Æ€€|€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€€€Ÿ€³€Ç€Ø€ã€ê€ë€ë€ë€ë€ë€ë€é€ã€Ü€Ó€È€½€²€¨€Ÿ€˜€’€Œ€‡€…€‚€€€€~€~€}€ƒ€«€â€â€«€ƒ€}€~€~€€€€‚€…€‡€Œ€’€˜€Ÿ€¨€²€½€È€Ó€Ü€ã€é€ë€ë€ë€ë€ë€ë€ê€ã€Ø€Ç€³€Ÿ€€€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€|€€Æ€ê€ë€Ù€Œ€8€€&€m€»€è€â€°€i€-€€€A€y€­€Ô€è€ë€ß€Ë€´€œ€ˆ€y€n€h€h€l€t€‚€•€«€Ã€Ú€è€ê€Ü€¹€‡€P€#€€€U€œ€×€ë€Ì€„€8€€&€q€Ç€ë€ë€Õ€€}€|€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€|€Ž€Å€è€ë€Õ€„€0€€1€€Ì€ë€Ó€‘€G€€€7€r€®€Ù€ë€ä€Ë€¨€‚€_€D€1€%€€€€€€€(€7€M€j€€²€Ó€è€é€Ð€ž€_€(€€!€[€¥€ß€é€º€h€ €€E€Ÿ€â€ë€ä€´€…€|€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€€‹€š€«€½€Í€Û€ä€é€ë€ë€ë€ë€ë€ë€ë€ë€é€ç€â€Þ€Ù€Ô€Ï€Ê€Å€Â€½€º€·€¹€Ì€ç€ç€Ì€¹€·€º€½€Â€Å€Ê€Ï€Ô€Ù€Þ€â€ç€é€ë€ë€ë€ë€ë€ë€ë€ë€é€ä€Û€Í€½€«€š€‹€€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€|€…€´€ä€ë€â€Ÿ€E€€ €h€º€é€ß€¥€[€!€€(€_€ž€Ð€é€è€Ó€²€€j€M€7€(€€€€€€€%€1€D€_€‚€¨€Ë€ä€ë€Ù€®€r€7€€€G€‘€Ó€ë€Ì€€1€€0€„€Õ€ë€è€Å€Ž€|€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€|€‚€±€à€ë€â€œ€@€€'€u€Ç€ë€Ó€€@€€€H€€É€è€è€Ê€Ÿ€n€E€'€€€€€€"€%€%€!€€€€€€.€O€z€«€Õ€ë€ã€¹€w€7€€€S€¢€à€è€²€\€€€Y€µ€é€é€×€ €~€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€€„€Ž€š€©€·€Å€Ñ€Ü€â€è€ê€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ë€ê€è€â€Ü€Ñ€Å€·€©€š€Ž€„€€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€~€ €×€é€é€µ€Y€€€\€²€è€à€¢€S€€€7€w€¹€ã€ë€Õ€«€z€O€.€€€€€€!€%€%€"€€€€€€'€E€n€Ÿ€Ê€è€è€É€€H€€€@€€Ó€ë€Ç€u€'€€@€œ€â€ë€à€±€‚€|€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€š€Ó€ë€ê€·€W€€€d€¼€ë€×€€?€€€U€Ÿ€Ø€ë€Ù€ª€q€?€€€€%€;€R€f€u€€…€ƒ€|€q€`€J€3€€€€%€K€€¸€â€ë€Ê€ˆ€A€€€T€¦€ã€å€¥€J€€#€s€Ì€ë€ê€Ã€€{€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€€‡€€—€¢€­€·€À€Ê€Ñ€×€Ü€á€ä€æ€è€ê€ê€ê€ë€ë€ë€ë€ë€ë€ë€ë€ê€ê€ê€è€æ€ä€á€Ü€×€Ñ€Ê€À€·€­€¢€—€€‡€€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€{€€Ã€ê€ë€Ì€s€#€€J€¥€å€ã€¦€T€€€A€ˆ€Ê€ë€â€¸€€K€%€€€€3€J€`€q€|€ƒ€…€€u€f€R€;€%€€€€?€q€ª€Ù€ë€Ø€Ÿ€U€€€?€€×€ë€¼€d€€€W€·€ê€ë€Ó€š€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€|€‡€½€è€ë€Ò€x€$€€M€©€ç€Þ€™€D€€€Z€©€á€ê€È€Œ€M€!€€€3€X€€ €¸€Ê€Õ€Û€Ü€Ü€Ú€Ò€Å€±€–€t€M€+€€€+€]€Ÿ€Ö€ë€Ó€“€E€€€[€±€è€Ü€€5€€8€”€à€ë€â€«€€|€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€€†€Š€€”€™€Ÿ€£€¨€«€®€°€¶€Ë€æ€æ€Ë€¶€°€®€«€¨€£€Ÿ€™€”€€Š€†€€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€|€€«€â€ë€à€”€8€€5€€Ü€è€±€[€€€E€“€Ó€ë€Ö€Ÿ€]€+€€€+€M€t€–€±€Å€Ò€Ú€Ü€Ü€Û€Õ€Ê€¸€ €€X€3€€€!€M€Œ€È€ê€á€©€Z€€€D€™€Þ€ç€©€M€€$€x€Ò€ë€è€½€‡€|€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€¡€Ù€ê€å€Ÿ€>€€3€€Ü€ç€ª€Q€€€X€«€ã€è€»€t€6€€€2€a€“€¼€Ø€ç€ë€é€ä€á€Þ€Þ€â€æ€ê€ê€ã€Ð€±€…€T€'€€€F€Š€Ì€ë€×€“€C€€ €i€Á€ë€Ë€r€!€€W€¸€ë€è€Ì€’€z€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€z€’€Ì€è€ë€¸€W€€!€r€Ë€ë€Á€i€ €€C€“€×€ë€Ì€Š€F€€€'€T€…€±€Ð€ã€ê€ê€æ€â€Þ€Þ€á€ä€é€ë€ç€Ø€¼€“€a€2€€€6€t€»€è€ã€«€X€€€Q€ª€ç€Ü€€3€€>€Ÿ€å€ê€Ù€¡€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€|€Š€¿€ê€ë€Å€d€€€l€É€ë€À€f€€€O€¥€â€è€´€h€(€€ €P€Œ€¿€ß€ë€å€Ó€½€¨€˜€Œ€†€‡€€œ€®€Ä€Ú€è€ê€Ù€³€|€A€€€8€€Ç€ë€Ö€€9€€+€€Õ€ë€±€P€€'€€Ö€ë€ã€®€€{€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€{€€®€ã€ë€Ö€€'€€P€±€ë€Õ€€+€€9€€Ö€ë€Ç€€8€€€A€|€³€Ù€ê€è€Ú€Ä€®€œ€€‡€†€Œ€˜€¨€½€Ó€å€ë€ß€¿€Œ€P€ €€(€h€´€è€â€¥€O€€€f€À€ë€É€l€€€d€Å€ë€ê€¿€Š€|€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€ €Ú€ë€â€“€2€€E€©€é€Ö€‚€+€€?€—€Ý€è€µ€d€#€€-€k€«€Ú€ë€á€Ã€›€v€W€A€2€+€'€'€,€7€H€a€‚€¨€Ì€æ€é€Ð€›€X€ €€2€|€É€ë€Ï€~€+€€@€ž€å€Þ€€/€€J€¯€é€é€Ì€€z€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€z€€Ì€é€é€¯€J€€/€€Þ€å€ž€@€€+€~€Ï€ë€É€|€2€€ €X€›€Ð€é€æ€Ì€¨€‚€a€H€7€,€'€'€+€2€A€W€v€›€Ã€á€ë€Ú€«€k€-€€#€d€µ€è€Ý€—€?€€+€‚€Ö€é€©€E€€2€“€â€ë€Ú€ €}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€|€‡€¼€ê€ë€Ã€^€€$€~€Ø€è€¥€D€€+€€Ó€ë€½€i€"€€5€{€À€ç€è€Ç€–€c€9€€€€€€€€€€€€'€E€r€¥€Ò€ë€á€¯€f€%€€3€ƒ€Ð€ë€À€f€€€^€¿€ë€Ã€`€€"€|€Ö€ë€â€ª€€{€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€{€€ª€â€ë€Ö€|€"€€`€Ã€ë€¿€^€€€f€À€ë€Ð€ƒ€3€€%€f€¯€á€ë€Ò€¥€r€E€'€€€€€€€€€€€€9€c€–€Ç€è€ç€À€{€5€€"€i€½€ë€Ó€€+€€D€¥€è€Ø€~€$€€^€Ã€ë€ê€¼€‡€|€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€{€™€Õ€ê€ã€–€2€€L€³€ë€Ê€i€€€c€À€ë€Ì€w€(€€6€‚€Ê€ë€Ý€­€n€9€€€€+€@€R€`€f€d€\€M€9€%€€€ €F€€€½€æ€ç€¸€j€$€€<€’€Ü€è€©€J€€*€‡€Ü€ä€–€3€€J€²€ê€è€Å€Š€z€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€z€Š€Å€è€ê€²€J€€3€–€ä€Ü€‡€*€€J€©€è€Ü€’€<€€$€j€¸€ç€æ€½€€€F€ €€€%€9€M€\€d€f€`€R€@€+€€€€9€n€­€Ý€ë€Ê€‚€6€€(€w€Ì€ë€À€c€€€i€Ê€ë€³€L€€2€–€ã€ê€Õ€™€{€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€|€€±€æ€ë€Ë€g€€"€€Û€æ€˜€5€€A€¡€æ€Ü€€6€€.€€Ë€ë€Ö€™€T€!€€€>€e€Š€§€º€Å€Ê€Ê€Ã€µ€Ÿ€€W€1€€€,€e€«€á€é€¸€d€€€L€©€è€Ú€†€+€€N€´€ë€Å€`€€%€‡€Ü€ë€Û€Ÿ€}€|€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€|€}€Ÿ€Û€ë€Ü€‡€%€€`€Å€ë€´€N€€+€†€Ú€è€©€L€€€d€¸€é€á€«€e€,€€€1€W€€Ÿ€µ€Ã€Ê€Ê€Å€º€§€Š€e€>€€€!€T€™€Ö€ë€Ë€€.€€6€€Ü€æ€¡€A€€5€˜€æ€Û€€"€€g€Ë€ë€æ€±€€|€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€z€€È€è€é€¦€>€€E€¯€ë€È€b€€ €x€Ó€é€¬€N€€"€p€Å€ë€Ó€€D€€€4€h€ž€Æ€Þ€é€ë€ê€è€è€ë€ë€ç€Ø€º€€X€(€€€V€¥€á€è€¯€V€€€h€Ä€ë€¾€[€€$€€Û€â€‘€-€€Y€Á€ë€ã€¶€ƒ€z€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€z€ƒ€¶€ã€ë€Á€Y€€-€‘€â€Û€€$€€[€¾€ë€Ä€h€€€V€¯€è€á€¥€V€€€(€X€€º€Ø€ç€ë€ë€è€è€ê€ë€é€Þ€Æ€ž€h€4€€€D€€Ó€ë€Å€p€"€€N€¬€é€Ó€x€ €€b€È€ë€¯€E€€>€¦€é€è€È€€z€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€|€|€ž€Û€ë€Û€~€ €€p€Ó€è€€6€€I€®€ë€Î€q€€€X€¶€ê€Ø€€@€€€J€‹€Ã€å€ë€á€Í€º€«€¥€¦€¯€¿€Ô€å€ë€Ü€µ€y€9€€€U€¨€æ€â€›€@€€1€€ß€â€’€/€€P€¹€ë€¼€R€€4€Ÿ€ç€ë€Ë€Ž€z€|€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€|€z€Ž€Ë€ë€ç€Ÿ€4€€R€¼€ë€¹€P€€/€’€â€ß€€1€€@€›€â€æ€¨€U€€€9€y€µ€Ü€ë€å€Ô€¿€¯€¦€¥€«€º€Í€á€ë€å€Ã€‹€J€€€@€€Ø€ê€¶€X€€€q€Î€ë€®€I€€6€€è€Ó€p€€ €~€Û€ë€Û€ž€|€|€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€{€€±€æ€ë€Á€W€€2€›€è€Ò€m€€€z€Ö€æ€ž€:€€:€š€ã€â€ž€G€€€V€ €×€ë€Ý€¹€€l€S€C€=€>€G€Z€v€ž€Æ€å€ê€Ë€€C€€€^€·€ë€Ó€}€&€€T€¸€ë€Â€[€€*€€â€Ú€{€€€w€Ö€ë€Û€Ÿ€}€{€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€{€}€Ÿ€Û€ë€Ö€w€€€{€Ú€â€€*€€[€Â€ë€¸€T€€&€}€Ó€ë€·€^€€€C€€Ë€ê€å€Æ€ž€v€Z€G€>€=€C€S€l€€¹€Ý€ë€×€ €V€€€G€ž€â€ã€š€:€€:€ž€æ€Ö€z€€€m€Ò€è€›€2€€W€Á€ë€æ€±€€{€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€z€Š€Ä€ç€è€£€7€€S€¿€ë€°€D€€@€©€ê€Ë€h€€€r€Ð€ë€¶€X€€€V€§€à€é€È€Ž€X€1€€€€€€€€ €=€i€¢€Õ€ë€Õ€“€B€€#€t€Ì€ë€·€V€€(€‡€Þ€â€‹€'€€b€Ê€ê€£€8€€R€À€ë€â€±€€{€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€{€€±€â€ë€À€R€€8€£€ê€Ê€b€€'€‹€â€Þ€‡€(€€V€·€ë€Ì€t€#€€B€“€Õ€ë€Õ€¢€i€=€ €€€€€€€€1€X€Ž€È€é€à€§€V€€€X€¶€ë€Ð€r€€€h€Ë€ê€©€@€€D€°€ë€¿€S€€7€£€è€ç€Ä€Š€z€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€z€–€Ô€ë€Ý€ƒ€ €€v€Ú€ã€Š€%€€h€Î€è€¢€;€€D€ª€ë€Ò€x€$€€J€¢€â€è€¹€t€5€€€€0€@€I€G€<€*€€€€G€ˆ€Ê€ë€Õ€Š€4€€7€•€â€ß€€,€€V€½€ë€¶€J€€=€©€ë€Ã€V€€6€¥€é€ë€Ã€ˆ€z€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€z€ˆ€Ã€ë€é€¥€6€€V€Ã€ë€©€=€€J€¶€ë€½€V€€,€€ß€â€•€7€€4€Š€Õ€ë€Ê€ˆ€G€€€€*€<€G€I€@€0€€€€5€t€¹€è€â€¢€J€€$€x€Ò€ë€ª€D€€;€¢€è€Î€h€€%€Š€ã€Ú€v€€ €ƒ€Ý€ë€Ô€–€z€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€{€}€¤€ß€ë€Ë€c€€.€™€è€Ï€d€€*€‘€å€Ö€t€€€t€Ô€è€¢€?€€4€Ž€Û€é€·€h€'€€€G€p€“€¨€±€°€£€‰€c€8€€€7€~€Ê€ë€Ê€t€ €€Z€½€ë€½€V€€/€”€ç€Ö€p€€"€…€á€Ú€x€€ €…€Þ€ë€Ð€’€{€{€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€{€{€’€Ð€ë€Þ€…€ €€x€Ú€á€…€"€€p€Ö€ç€”€/€€V€½€ë€½€Z€€ €t€Ê€ë€Ê€~€7€€€8€c€‰€£€°€±€¨€“€p€G€€€'€h€·€é€Û€Ž€4€€?€¢€è€Ô€t€€€t€Ö€å€‘€*€€d€Ï€è€™€.€€c€Ë€ë€ß€¤€}€{€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€€²€â€ë€·€I€€E€¶€ë€´€D€€F€´€ë€¹€M€€:€£€ê€Ð€m€€€l€È€ë€Â€l€$€€1€m€§€Ï€â€é€ê€ê€è€Þ€Ã€•€X€!€€4€…€Õ€ê€±€P€€+€Œ€à€Ý€„€$€€l€Ò€è€–€,€€d€Î€è€–€+€€h€Ñ€ë€Ø€Ÿ€|€{€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€{€|€Ÿ€Ø€ë€Ñ€h€€+€–€è€Î€d€€,€–€è€Ò€l€€$€„€Ý€à€Œ€+€€P€±€ê€Õ€…€4€€!€X€•€Ã€Þ€è€ê€ê€é€â€Ï€§€m€1€€$€l€Â€ë€È€l€€€m€Ð€ê€£€:€€M€¹€ë€´€F€€D€´€ë€¶€E€€I€·€ë€â€²€€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€‡€À€è€é€¢€4€€_€Ë€è€™€,€€e€Ï€è€˜€/€€^€È€ë€©€>€€@€¥€è€Ö€‚€-€€3€€Ã€è€ê€Ü€Ê€À€Â€Ï€á€ë€ß€°€g€$€€A€€ä€Ý€‡€(€€\€Ã€ë€¬€A€€H€·€ë€¶€E€€H€·€ë€°€@€€P€Á€ë€á€«€€z€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€z€€«€á€ë€Á€P€€@€°€ë€·€H€€E€¶€ë€·€H€€A€¬€ë€Ã€\€€(€‡€Ý€ä€€A€€$€g€°€ß€ë€á€Ï€Â€À€Ê€Ü€ê€è€Ã€€3€€-€‚€Ö€è€¥€@€€>€©€ë€È€^€€/€˜€è€Ï€e€€,€™€è€Ë€_€€4€¢€é€è€À€‡€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€€Ê€ë€â€€%€€w€Û€ß€~€€€‚€á€Ú€w€€"€ƒ€à€Ý€~€€€n€Ð€é€¨€E€€*€{€Ì€ë€Ü€±€…€f€W€Z€m€’€À€æ€ç€¶€b€€€_€Á€ë€¹€P€€5€ž€è€Ì€c€€-€˜€é€Î€a€€1€Ÿ€ê€Ä€V€€<€¯€ë€è€·€‚€z€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€z€‚€·€è€ë€¯€<€€V€Ä€ê€Ÿ€1€€a€Î€é€˜€-€€c€Ì€è€ž€5€€P€¹€ë€Á€_€€€b€¶€ç€æ€À€’€m€Z€W€f€…€±€Ü€ë€Ì€{€*€€E€¨€é€Ð€n€€€~€Ý€à€ƒ€"€€w€Ú€á€‚€€€~€ß€Û€w€€%€€â€ë€Ê€€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€•€Ó€ë€Ù€z€€$€Œ€ä€Ñ€f€€-€œ€é€È€Z€€7€¤€ë€Å€X€€1€š€è€Ò€r€€€c€À€ë€Ô€“€S€)€€€€€3€e€ª€â€æ€¨€J€€.€€ã€Û€z€€€y€Ú€à€ƒ€ €€z€Þ€Þ€z€€"€‡€â€Ô€i€€,€œ€ç€ë€À€‡€z€‹€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€‹€z€‡€À€ë€ç€œ€,€€i€Ô€â€‡€"€€z€Þ€Þ€z€€ €ƒ€à€Ú€y€€€z€Û€ã€€.€€J€¨€æ€â€ª€e€3€€€€€)€S€“€Ô€ë€À€c€€€r€Ò€è€š€1€€X€Å€ë€¤€7€€Z€È€é€œ€-€€f€Ñ€ä€Œ€$€€z€Ù€ë€Ó€•€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€{€œ€Ú€ë€Ð€h€€0€ž€ê€Ã€S€€>€±€ë€´€D€€M€½€ë€ª€;€€Q€¾€ë€°€E€€;€Ÿ€ç€Ü€€@€€€"€/€,€€€€W€¬€è€Ù€‚€%€€b€Ê€ë€¢€5€€X€Å€é€Ÿ€1€€b€Ð€è€‘€&€€t€Ú€Þ€{€€!€‹€â€ë€È€Œ€z€‹€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€‹€z€Œ€È€ë€â€‹€!€€{€Þ€Ú€t€€&€‘€è€Ð€b€€1€Ÿ€é€Å€X€€5€¢€ë€Ê€b€€%€‚€Ù€è€¬€W€€€€,€/€"€€€@€€Ü€ç€Ÿ€;€€E€°€ë€¾€Q€€;€ª€ë€½€M€€D€´€ë€±€>€€S€Ã€ê€ž€0€€h€Ð€ë€Ú€œ€{€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€|€¢€Þ€ë€Ç€[€€<€¬€ë€¶€D€€O€Á€ê€¡€2€€c€Ï€ç€‘€&€€p€Ö€ã€‹€&€€h€Í€ë€«€J€€€L€|€“€€o€;€€€h€Æ€ë€´€J€€>€«€ë€¿€P€€@€°€ë€µ€D€€N€À€ë€£€3€€c€Ð€ä€Œ€#€€|€Ý€ë€Î€‘€{€‹€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€‹€{€‘€Î€ë€Ý€|€€#€Œ€ä€Ð€c€€3€£€ë€À€N€€D€µ€ë€°€@€€P€¿€ë€«€>€€J€´€ë€Æ€h€€€;€o€€“€|€L€€€J€«€ë€Í€h€€&€‹€ã€Ö€p€€&€‘€ç€Ï€c€€2€¡€ê€Á€O€€D€¶€ë€¬€<€€[€Ç€ë€Þ€¢€|€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€~€¨€â€ë€¿€P€€E€·€ë€ª€8€€\€Í€ç€’€'€€v€Û€Ý€z€€!€Š€ä€Ô€l€€(€€å€Ø€t€€€W€¥€Ö€ä€â€Ë€€>€€3€—€æ€Ô€n€€%€€æ€Ô€h€€/€œ€é€Ä€U€€?€²€ë€±€>€€V€Ç€è€˜€*€€p€×€ë€Ó€–€{€‹€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€‹€{€–€Ó€ë€×€p€€*€˜€è€Ç€V€€>€±€ë€²€?€€U€Ä€é€œ€/€€h€Ô€æ€€%€€n€Ô€æ€—€3€€>€€Ë€â€ä€Ö€¥€W€€€t€Ø€å€€(€€l€Ô€ä€Š€!€€z€Ý€Û€v€€'€’€ç€Í€\€€8€ª€ë€·€E€€P€¿€ë€â€¨€~€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€«€€€¬€à€ë€¹€H€€M€¿€ë€¡€1€€h€Õ€â€†€€€ƒ€â€Ö€k€€-€œ€é€Ä€U€€=€­€ë€¼€J€€:€œ€á€è€×€Ü€ë€Ó€|€"€€m€Ó€ä€€%€€v€Ü€ß€z€€$€€å€Ï€a€€5€§€ë€»€H€€M€¿€ê€ €1€€h€Ô€ë€Ô€™€{€‹€¾€ê€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ê€¾€‹€{€™€Ô€ë€Ô€h€€1€ €ê€¿€M€€H€»€ë€§€5€€a€Ï€å€€$€€z€ß€Ü€v€€%€€ä€Ó€m€€"€|€Ó€ë€Ü€×€è€á€œ€:€€J€¼€ë€­€=€€U€Ä€é€œ€-€€k€Ö€â€ƒ€€€†€â€Õ€h€€1€¡€ë€¿€M€€H€¹€ë€à€¬€€€«€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€æ€á€«€€€€¯€â€ë€µ€D€€S€Ã€é€›€+€€n€Ù€à€}€€$€€æ€Ï€`€€7€©€ë€¸€F€€N€¿€ë€¤€1€€`€Ê€ê€µ€z€ˆ€Ë€ë€­€>€€P€Á€ê€¡€1€€f€Ô€å€‡€ €€‚€â€Ö€j€€/€Ÿ€ë€Á€N€€H€º€ë€¦€5€€b€Ð€ë€Ö€›€{€‹€¾€é€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€é€¾€‹€{€›€Ö€ë€Ð€b€€5€¦€ë€º€H€€N€Á€ë€Ÿ€/€€j€Ö€â€‚€€ €‡€å€Ô€f€€1€¡€ê€Á€P€€>€­€ë€Ë€ˆ€z€µ€ê€Ê€`€€1€¤€ë€¿€N€€F€¸€ë€©€7€€`€Ï€æ€€$€€}€à€Ù€n€€+€›€é€Ã€S€€D€µ€ë€â€¯€€€€«€á€æ€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ë€à€«€€€€±€â€ë€³€A€€V€Æ€é€˜€)€€s€Û€Ý€y€€&€’€ç€Ê€Z€€;€¯€ë€²€@€€W€È€é€–€&€€v€Ü€Ü€{€%€8€Ÿ€ë€Ä€Q€€C€¶€ë€«€9€€_€Ï€ç€Ž€$€€|€ß€×€o€€+€›€ë€Ã€Q€€D€·€ë€©€7€€`€Ï€ë€×€€{€‹€½€è€é€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€é€è€½€‹€{€€×€ë€Ï€`€€7€©€ë€·€D€€Q€Ã€ë€›€+€€o€×€ß€|€€$€Ž€ç€Ï€_€€9€«€ë€¶€C€€Q€Ä€ë€Ÿ€8€%€{€Ü€Ü€v€€&€–€é€È€W€€@€²€ë€¯€;€€Z€Ê€ç€’€&€€y€Ý€Û€s€€)€˜€é€Æ€V€€A€³€ë€â€±€€€€«€à€ë€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ë€à€«€€€€±€â€ë€³€A€€V€Æ€é€˜€)€€s€Û€Ý€y€€&€’€ç€Ê€Z€€;€¯€ë€²€@€€W€È€é€–€&€€v€Ü€Ü€{€%€8€Ÿ€ë€Ä€Q€€C€¶€ë€«€9€€_€Ï€ç€Ž€$€€|€ß€×€o€€+€›€ë€Ã€Q€€D€·€ë€©€7€€`€Ï€ë€×€€{€‹€½€è€ë€æ€Þ€×€Ö€Ø€Þ€å€é€é€ä€Ý€×€Ö€Ø€Þ€å€é€è€ä€Ý€×€Ö€Ù€Þ€å€é€è€ä€Ý€Ø€Ö€Ø€Þ€å€é€è€ä€Ý€Ø€Ö€Ü€ç€ë€ë€ç€Ü€Ö€Ü€ç€é€à€Ö€Ø€ã€é€ä€Ú€Ö€Þ€è€è€Ý€Ö€Ú€å€é€â€Ø€×€á€è€ç€Ü€Ö€Ü€ç€é€à€×€Ø€â€é€ä€Ú€Ö€ß€è€è€Ý€Ö€Û€æ€é€â€Ø€×€á€é€æ€Ü€Ö€Ü€ç€è€à€Ö€Ø€ã€é€ä€Ù€Ö€Þ€è€è€Ý€Ö€Û€å€é€â€Ø€×€á€é€æ€Û€Ö€á€ê€ë€ã€Ü€å€æ€Ù€Ù€è€å€Ø€Ü€è€ã€×€Ý€è€á€Ö€à€é€ß€Ö€â€è€Ü€×€ä€è€Û€Ø€æ€ç€Ù€Ú€ç€ä€×€Ü€è€â€Ö€Ý€é€á€×€à€è€Þ€×€â€è€Ü€×€ã€è€Û€Ù€æ€æ€Ù€Ú€è€å€Ø€Ü€è€â€Ö€Þ€è€à€Ö€à€é€ß€Ö€â€è€Ü€Ø€ä€è€Û€Ø€å€æ€á€é€ë€â€Ý€è€Ü€Û€è€Þ€Ù€è€ß€Ø€æ€à€×€æ€â€×€ä€ä€Ø€ã€ä€×€â€æ€Ø€à€ç€Ù€ß€è€Ù€Þ€è€Ú€Ü€è€Ü€Û€è€Ý€Ú€è€Þ€Ú€ç€ß€Ø€ç€â€Ø€å€â€Ø€å€ã€×€ã€å€×€â€å€Ø€á€ç€Ø€ß€è€Ú€Ý€è€Û€Ü€è€Ü€Û€è€Ü€Ú€è€Þ€Ù€ç€à€Û€è€ê€è€è€ß€Ù€ç€à€Ù€ç€ß€Ù€æ€à€Ú€æ€à€Ú€å€à€Ú€æ€Þ€Ú€ç€ß€Ù€æ€ß€Ù€ç€ß€Ù€ç€ß€Ù€ç€à€Ù€æ€à€Ù€æ€à€Ú€ç€à€Ù€æ€ß€Ú€æ€Þ€Ú€ç€Þ€Ú€ç€Þ€Ú€ç€ß€Ú€ç€Þ€Ú€ç€ß€Ù€ç€à€Ù€ç€ß€Ú€æ€ß€Ù€æ€à€Ú€æ€ß€Ú€æ€Þ€Û€è€é€ê€è€Ü€â€á€Ü€å€Û€á€â€Ú€å€Ü€ß€ã€Ú€ä€Þ€Þ€å€Ú€â€à€Ü€æ€Û€â€â€Û€æ€Ü€ß€ã€Ú€ä€Þ€Þ€å€Ú€â€à€Ü€ç€é€è€½€‹€{€€×€ë€Ï€`€€7€©€ë€·€D€€Q€Ã€ë€›€+€€o€×€ß€|€€$€Ž€ç€Ï€_€€9€«€ë€¶€C€€Q€Ä€ë€Ÿ€8€%€{€Ü€Ü€v€€&€–€é€È€W€€@€²€ë€¯€;€€Z€Ê€ç€’€&€€y€Ý€Û€s€€)€˜€é€Æ€V€€A€³€ë€â€±€€€€«€à€ë€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€æ€á€«€€€€¯€â€ë€µ€D€€S€Ã€é€›€+€€n€Ù€à€}€€$€€æ€Ï€`€€7€©€ë€¸€F€€N€¿€ë€¤€1€€`€Ê€ê€µ€z€ˆ€Ë€ë€­€>€€P€Á€ê€¡€1€€f€Ô€å€‡€ €€‚€â€Ö€j€€/€Ÿ€ë€Á€N€€H€º€ë€¦€5€€b€Ð€ë€Ö€›€{€‹€½€é€é€Ê€’€j€a€r€™€Ã€Þ€Ü€¾€“€m€`€r€™€Ã€Þ€Ü€½€’€m€`€q€™€Ä€ß€Ü€½€’€n€`€p€˜€Ã€Þ€Û€½€’€j€]€‡€Ï€ë€ë€Ï€†€_€Š€Î€Ü€¢€f€o€¶€â€¾€x€b€–€×€Õ€“€a€{€Ã€â€±€n€h€¥€Ý€Ë€„€_€‰€Ï€Ü€£€f€q€´€à€¾€v€b€™€Ú€Ô€’€b€}€Ä€ß€¯€l€h€¨€ß€Ê€ƒ€a€‹€Ð€Ü€Ÿ€e€r€·€à€½€w€c€™€Ù€Ó€‘€`€}€Å€à€¯€m€i€©€ß€Ê€€€b€§€æ€ë€·€„€Ä€Ë€t€z€Ò€Ã€l€„€Ö€·€h€’€Û€¥€c€¡€Þ€œ€d€«€Ù€Œ€j€¼€Õ€€o€È€Î€v€x€Ï€Â€n€‡€Ø€µ€e€€Ü€¦€e€£€Ü€–€e€±€Ú€ˆ€h€¼€Ô€€q€Ê€Ê€q€z€Ó€Á€k€‡€×€²€g€”€Ü€¥€b€£€Ý€™€f€¯€Ø€‡€j€¿€Õ€}€n€Ç€Í€«€Ý€é€©€€Ö€Š€|€Ö€–€w€Ð€ž€s€Î€¥€n€É€±€k€¿€¹€l€¸€¿€l€±€È€m€¥€Ï€s€œ€Ñ€x€–€Õ€|€‹€×€†€€Ö€€}€Ó€–€x€Ó€€p€Í€¨€n€Æ€¯€l€Â€·€i€¹€Ã€l€®€È€o€§€Ì€q€Ÿ€Ó€v€“€Õ€€€‹€Õ€…€…€Ö€€z€Õ€™€u€Ð€ €~€Û€ê€Ø€Ù€€q€Ì€¢€t€Ë€Ÿ€w€Ë€Ÿ€v€Ê€¡€y€É€ž€{€Ë€™€y€Í€œ€w€Í€œ€x€Ï€š€v€Ð€œ€r€Ð€¢€s€Ë€¡€v€Ê€Ÿ€x€Ì€ €v€É€ž€|€Ê€™€~€Î€—€z€Ï€š€y€Ï€™€y€Ð€—€w€Ó€œ€t€Ï€Ÿ€v€Ì€ž€y€Í€œ€w€Ë€Ÿ€y€Ê€œ€|€Ë€–€z€Ð€ß€è€ß€‹€´€¤€ˆ€È€ƒ€«€­€~€Æ€Œ€ž€¸€z€¾€–€“€Ã€z€µ€£€‰€Ç€‚€«€®€€Ç€€ž€·€z€¿€–€’€Â€z€µ€ €‡€Ð€Ý€ç€¾€‹€{€›€Ö€ë€Ð€b€€5€¦€ë€º€H€€N€Á€ë€Ÿ€/€€j€Ö€â€‚€€ €‡€å€Ô€f€€1€¡€ê€Á€P€€>€­€ë€Ë€ˆ€z€µ€ê€Ê€`€€1€¤€ë€¿€N€€F€¸€ë€©€7€€`€Ï€æ€€$€€}€à€Ù€n€€+€›€é€Ã€S€€D€µ€ë€â€¯€€€€«€á€æ€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€«€€€¬€à€ë€¹€H€€M€¿€ë€¡€1€€h€Õ€â€†€€€ƒ€â€Ö€k€€-€œ€é€Ä€U€€=€­€ë€¼€J€€:€œ€á€è€×€Ü€ë€Ó€|€"€€m€Ó€ä€€%€€v€Ü€ß€z€€$€€å€Ï€a€€5€§€ë€»€H€€M€¿€ê€ €1€€h€Ô€ë€Ô€™€{€‹€½€é€è€»€h€/€ €:€t€±€Ø€Õ€©€h€2€€:€s€±€Ø€Õ€¨€h€2€€9€s€±€Ø€Õ€©€h€3€€8€q€±€Ø€Ô€¨€h€/€€Z€Á€ë€ë€Â€V€€\€À€Ô€€(€8€€Þ€ª€C€$€o€Ï€Ê€i€!€G€±€Ý€•€4€+€…€×€½€V€€\€Á€Ö€€(€8€›€Û€ª€@€#€t€Ñ€È€h€"€J€²€Ú€“€1€,€‰€Ù€º€S€!€^€Ã€Õ€}€&€:€Ÿ€Ü€¨€A€%€t€Ð€É€g€€J€´€Û€”€2€,€Š€Ù€¹€N€"€‡€ã€ë€¡€T€³€½€>€E€Æ€±€1€U€Í€ž€+€h€Ô€†€%€€Ø€w€&€Ž€Ñ€`€.€¥€Ê€N€6€·€À€@€D€Ã€®€3€X€Ð€œ€'€f€Õ€‡€'€€Ô€n€(€—€Ó€[€,€¦€É€M€9€¹€º€9€G€È€®€0€Z€Ï€™€*€m€Ö€„€#€€×€s€'€“€Ð€[€0€ª€É€J€5€·€¾€€×€é€‹€e€Ë€]€J€Ë€n€A€Ä€z€<€À€…€3€¹€–€/€«€¢€1€¡€«€1€—€·€1€†€Â€<€w€Ä€C€n€Ê€J€_€Ï€W€P€Ê€e€J€È€n€D€É€y€8€¾€‰€4€µ€“€2€¯€Ÿ€-€¢€¯€1€’€·€6€ˆ€½€8€z€È€A€j€Ë€M€^€Ê€V€U€Í€b€F€Ê€s€>€Â€}€K€Ô€é€Ð€Ñ€y€8€¾€€€>€¼€|€C€½€{€@€º€€€D€¹€z€H€½€t€D€¿€x€B€¿€w€B€Â€t€B€Ä€w€;€Ã€€;€½€€€@€¼€z€C€¾€€@€¹€z€H€»€s€K€À€p€E€Â€t€D€Á€s€D€Ä€p€C€É€w€<€Â€|€?€¾€y€D€¾€v€A€½€{€D€»€w€I€½€o€H€Ã€Ú€è€Ù€_€›€ƒ€[€·€S€€‘€K€¶€`€z€¡€D€ª€n€k€±€F€œ€‚€\€·€Q€€’€L€¶€a€z€ €E€«€o€i€®€E€›€€Y€Ã€Ö€ç€¾€‹€{€™€Ô€ë€Ô€h€€1€ €ê€¿€M€€H€»€ë€§€5€€a€Ï€å€€$€€z€ß€Ü€v€€%€€ä€Ó€m€€"€|€Ó€ë€Ü€×€è€á€œ€:€€J€¼€ë€­€=€€U€Ä€é€œ€-€€k€Ö€â€ƒ€€€†€â€Õ€h€€1€¡€ë€¿€M€€H€¹€ë€à€¬€€€«€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€~€¨€â€ë€¿€P€€E€·€ë€ª€8€€\€Í€ç€’€'€€v€Û€Ý€z€€!€Š€ä€Ô€l€€(€€å€Ø€t€€€W€¥€Ö€ä€â€Ë€€>€€3€—€æ€Ô€n€€%€€æ€Ô€h€€/€œ€é€Ä€U€€?€²€ë€±€>€€V€Ç€è€˜€*€€p€×€ë€Ó€–€{€‹€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€‹€{€–€Ó€ë€×€p€€*€˜€è€Ç€V€€>€±€ë€²€?€€U€Ä€é€œ€/€€h€Ô€æ€€%€€n€Ô€æ€—€3€€>€€Ë€â€ä€Ö€¥€W€€€t€Ø€å€€(€€l€Ô€ä€Š€!€€z€Ý€Û€v€€'€’€ç€Í€\€€8€ª€ë€·€E€€P€¿€ë€â€¨€~€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€|€¢€Þ€ë€Ç€[€€<€¬€ë€¶€D€€O€Á€ê€¡€2€€c€Ï€ç€‘€&€€p€Ö€ã€‹€&€€h€Í€ë€«€J€€€L€|€“€€o€;€€€h€Æ€ë€´€J€€>€«€ë€¿€P€€@€°€ë€µ€D€€N€À€ë€£€3€€c€Ð€ä€Œ€#€€|€Ý€ë€Î€‘€{€‹€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€‹€{€‘€Î€ë€Ý€|€€#€Œ€ä€Ð€c€€3€£€ë€À€N€€D€µ€ë€°€@€€P€¿€ë€«€>€€J€´€ë€Æ€h€€€;€o€€“€|€L€€€J€«€ë€Í€h€€&€‹€ã€Ö€p€€&€‘€ç€Ï€c€€2€¡€ê€Á€O€€D€¶€ë€¬€<€€[€Ç€ë€Þ€¢€|€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€‚€{€œ€Ú€ë€Ð€h€€0€ž€ê€Ã€S€€>€±€ë€´€D€€M€½€ë€ª€;€€Q€¾€ë€°€E€€;€Ÿ€ç€Ü€€@€€€"€/€,€€€€W€¬€è€Ù€‚€%€€b€Ê€ë€¢€5€€X€Å€é€Ÿ€1€€b€Ð€è€‘€&€€t€Ú€Þ€{€€!€‹€â€ë€È€Œ€z€‹€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€‹€z€Œ€È€ë€â€‹€!€€{€Þ€Ú€t€€&€‘€è€Ð€b€€1€Ÿ€é€Å€X€€5€¢€ë€Ê€b€€%€‚€Ù€è€¬€W€€€€,€/€"€€€@€€Ü€ç€Ÿ€;€€E€°€ë€¾€Q€€;€ª€ë€½€M€€D€´€ë€±€>€€S€Ã€ê€ž€0€€h€Ð€ë€Ú€œ€{€‚€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€•€Ó€ë€Ù€z€€$€Œ€ä€Ñ€f€€-€œ€é€È€Z€€7€¤€ë€Å€X€€1€š€è€Ò€r€€€c€À€ë€Ô€“€S€)€€€€€3€e€ª€â€æ€¨€J€€.€€ã€Û€z€€€y€Ú€à€ƒ€ €€z€Þ€Þ€z€€"€‡€â€Ô€i€€,€œ€ç€ë€À€‡€z€‹€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€‹€z€‡€À€ë€ç€œ€,€€i€Ô€â€‡€"€€z€Þ€Þ€z€€ €ƒ€à€Ú€y€€€z€Û€ã€€.€€J€¨€æ€â€ª€e€3€€€€€)€S€“€Ô€ë€À€c€€€r€Ò€è€š€1€€X€Å€ë€¤€7€€Z€È€é€œ€-€€f€Ñ€ä€Œ€$€€z€Ù€ë€Ó€•€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€€Ê€ë€â€€%€€w€Û€ß€~€€€‚€á€Ú€w€€"€ƒ€à€Ý€~€€€n€Ð€é€¨€E€€*€{€Ì€ë€Ü€±€…€f€W€Z€m€’€À€æ€ç€¶€b€€€_€Á€ë€¹€P€€5€ž€è€Ì€c€€-€˜€é€Î€a€€1€Ÿ€ê€Ä€V€€<€¯€ë€è€·€‚€z€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€z€‚€·€è€ë€¯€<€€V€Ä€ê€Ÿ€1€€a€Î€é€˜€-€€c€Ì€è€ž€5€€P€¹€ë€Á€_€€€b€¶€ç€æ€À€’€m€Z€W€f€…€±€Ü€ë€Ì€{€*€€E€¨€é€Ð€n€€€~€Ý€à€ƒ€"€€w€Ú€á€‚€€€~€ß€Û€w€€%€€â€ë€Ê€€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€‡€À€è€é€¢€4€€_€Ë€è€™€,€€e€Ï€è€˜€/€€^€È€ë€©€>€€@€¥€è€Ö€‚€-€€3€€Ã€è€ê€Ü€Ê€À€Â€Ï€á€ë€ß€°€g€$€€A€€ä€Ý€‡€(€€\€Ã€ë€¬€A€€H€·€ë€¶€E€€H€·€ë€°€@€€P€Á€ë€á€«€€z€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€z€€«€á€ë€Á€P€€@€°€ë€·€H€€E€¶€ë€·€H€€A€¬€ë€Ã€\€€(€‡€Ý€ä€€A€€$€g€°€ß€ë€á€Ï€Â€À€Ê€Ü€ê€è€Ã€€3€€-€‚€Ö€è€¥€@€€>€©€ë€È€^€€/€˜€è€Ï€e€€,€™€è€Ë€_€€4€¢€é€è€À€‡€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€z€€²€â€ë€·€I€€E€¶€ë€´€D€€F€´€ë€¹€M€€:€£€ê€Ð€m€€€l€È€ë€Â€l€$€€1€m€§€Ï€â€é€ê€ê€è€Þ€Ã€•€X€!€€4€…€Õ€ê€±€P€€+€Œ€à€Ý€„€$€€l€Ò€è€–€,€€d€Î€è€–€+€€h€Ñ€ë€Ø€Ÿ€|€{€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€{€|€Ÿ€Ø€ë€Ñ€h€€+€–€è€Î€d€€,€–€è€Ò€l€€$€„€Ý€à€Œ€+€€P€±€ê€Õ€…€4€€!€X€•€Ã€Þ€è€ê€ê€é€â€Ï€§€m€1€€$€l€Â€ë€È€l€€€m€Ð€ê€£€:€€M€¹€ë€´€F€€D€´€ë€¶€E€€I€·€ë€â€²€€z€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€{€}€¤€ß€ë€Ë€c€€.€™€è€Ï€d€€*€‘€å€Ö€t€€€t€Ô€è€¢€?€€4€Ž€Û€é€·€h€'€€€G€p€“€¨€±€°€£€‰€c€8€€€7€~€Ê€ë€Ê€t€ €€Z€½€ë€½€V€€/€”€ç€Ö€p€€"€…€á€Ú€x€€ €…€Þ€ë€Ð€’€{€{€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€{€{€’€Ð€ë€Þ€…€ €€x€Ú€á€…€"€€p€Ö€ç€”€/€€V€½€ë€½€Z€€ €t€Ê€ë€Ê€~€7€€€8€c€‰€£€°€±€¨€“€p€G€€€'€h€·€é€Û€Ž€4€€?€¢€è€Ô€t€€€t€Ö€å€‘€*€€d€Ï€è€™€.€€c€Ë€ë€ß€¤€}€{€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€z€–€Ô€ë€Ý€ƒ€ €€v€Ú€ã€Š€%€€h€Î€è€¢€;€€D€ª€ë€Ò€x€$€€J€¢€â€è€¹€t€5€€€€0€@€I€G€<€*€€€€G€ˆ€Ê€ë€Õ€Š€4€€7€•€â€ß€€,€€V€½€ë€¶€J€€=€©€ë€Ã€V€€6€¥€é€ë€Ã€ˆ€z€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€z€ˆ€Ã€ë€é€¥€6€€V€Ã€ë€©€=€€J€¶€ë€½€V€€,€€ß€â€•€7€€4€Š€Õ€ë€Ê€ˆ€G€€€€*€<€G€I€@€0€€€€5€t€¹€è€â€¢€J€€$€x€Ò€ë€ª€D€€;€¢€è€Î€h€€%€Š€ã€Ú€v€€ €ƒ€Ý€ë€Ô€–€z€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€z€Š€Ä€ç€è€£€7€€S€¿€ë€°€D€€@€©€ê€Ë€h€€€r€Ð€ë€¶€X€€€V€§€à€é€È€Ž€X€1€€€€€€€€ €=€i€¢€Õ€ë€Õ€“€B€€#€t€Ì€ë€·€V€€(€‡€Þ€â€‹€'€€b€Ê€ê€£€8€€R€À€ë€â€±€€{€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€{€€±€â€ë€À€R€€8€£€ê€Ê€b€€'€‹€â€Þ€‡€(€€V€·€ë€Ì€t€#€€B€“€Õ€ë€Õ€¢€i€=€ €€€€€€€€1€X€Ž€È€é€à€§€V€€€X€¶€ë€Ð€r€€€h€Ë€ê€©€@€€D€°€ë€¿€S€€7€£€è€ç€Ä€Š€z€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€{€€±€æ€ë€Á€W€€2€›€è€Ò€m€€€z€Ö€æ€ž€:€€:€š€ã€â€ž€G€€€V€ €×€ë€Ý€¹€€l€S€C€=€>€G€Z€v€ž€Æ€å€ê€Ë€€C€€€^€·€ë€Ó€}€&€€T€¸€ë€Â€[€€*€€â€Ú€{€€€w€Ö€ë€Û€Ÿ€}€{€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€{€}€Ÿ€Û€ë€Ö€w€€€{€Ú€â€€*€€[€Â€ë€¸€T€€&€}€Ó€ë€·€^€€€C€€Ë€ê€å€Æ€ž€v€Z€G€>€=€C€S€l€€¹€Ý€ë€×€ €V€€€G€ž€â€ã€š€:€€:€ž€æ€Ö€z€€€m€Ò€è€›€2€€W€Á€ë€æ€±€€{€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€|€|€ž€Û€ë€Û€~€ €€p€Ó€è€€6€€I€®€ë€Î€q€€€X€¶€ê€Ø€€@€€€J€‹€Ã€å€ë€á€Í€º€«€¥€¦€¯€¿€Ô€å€ë€Ü€µ€y€9€€€U€¨€æ€â€›€@€€1€€ß€â€’€/€€P€¹€ë€¼€R€€4€Ÿ€ç€ë€Ë€Ž€z€|€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€|€z€Ž€Ë€ë€ç€Ÿ€4€€R€¼€ë€¹€P€€/€’€â€ß€€1€€@€›€â€æ€¨€U€€€9€y€µ€Ü€ë€å€Ô€¿€¯€¦€¥€«€º€Í€á€ë€å€Ã€‹€J€€€@€€Ø€ê€¶€X€€€q€Î€ë€®€I€€6€€è€Ó€p€€ €~€Û€ë€Û€ž€|€|€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€z€€È€è€é€¦€>€€E€¯€ë€È€b€€ €x€Ó€é€¬€N€€"€p€Å€ë€Ó€€D€€€4€h€ž€Æ€Þ€é€ë€ê€è€è€ë€ë€ç€Ø€º€€X€(€€€V€¥€á€è€¯€V€€€h€Ä€ë€¾€[€€$€€Û€â€‘€-€€Y€Á€ë€ã€¶€ƒ€z€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€z€ƒ€¶€ã€ë€Á€Y€€-€‘€â€Û€€$€€[€¾€ë€Ä€h€€€V€¯€è€á€¥€V€€€(€X€€º€Ø€ç€ë€ë€è€è€ê€ë€é€Þ€Æ€ž€h€4€€€D€€Ó€ë€Å€p€"€€N€¬€é€Ó€x€ €€b€È€ë€¯€E€€>€¦€é€è€È€€z€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€|€€±€æ€ë€Ë€g€€"€€Û€æ€˜€5€€A€¡€æ€Ü€€6€€.€€Ë€ë€Ö€™€T€!€€€>€e€Š€§€º€Å€Ê€Ê€Ã€µ€Ÿ€€W€1€€€,€e€«€á€é€¸€d€€€L€©€è€Ú€†€+€€N€´€ë€Å€`€€%€‡€Ü€ë€Û€Ÿ€}€|€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€|€}€Ÿ€Û€ë€Ü€‡€%€€`€Å€ë€´€N€€+€†€Ú€è€©€L€€€d€¸€é€á€«€e€,€€€1€W€€Ÿ€µ€Ã€Ê€Ê€Å€º€§€Š€e€>€€€!€T€™€Ö€ë€Ë€€.€€6€€Ü€æ€¡€A€€5€˜€æ€Û€€"€€g€Ë€ë€æ€±€€|€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€{€™€Õ€ê€ã€–€2€€L€³€ë€Ê€i€€€c€À€ë€Ì€w€(€€6€‚€Ê€ë€Ý€­€n€9€€€€+€@€R€`€f€d€\€M€9€%€€€ €F€€€½€æ€ç€¸€j€$€€<€’€Ü€è€©€J€€*€‡€Ü€ä€–€3€€J€²€ê€è€Å€Š€z€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€z€Š€Å€è€ê€²€J€€3€–€ä€Ü€‡€*€€J€©€è€Ü€’€<€€$€j€¸€ç€æ€½€€€F€ €€€%€9€M€\€d€f€`€R€@€+€€€€9€n€­€Ý€ë€Ê€‚€6€€(€w€Ì€ë€À€c€€€i€Ê€ë€³€L€€2€–€ã€ê€Õ€™€{€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€|€‡€¼€ê€ë€Ã€^€€$€~€Ø€è€¥€D€€+€€Ó€ë€½€i€"€€5€{€À€ç€è€Ç€–€c€9€€€€€€€€€€€€'€E€r€¥€Ò€ë€á€¯€f€%€€3€ƒ€Ð€ë€À€f€€€^€¿€ë€Ã€`€€"€|€Ö€ë€â€ª€€{€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€{€€ª€â€ë€Ö€|€"€€`€Ã€ë€¿€^€€€f€À€ë€Ð€ƒ€3€€%€f€¯€á€ë€Ò€¥€r€E€'€€€€€€€€€€€€9€c€–€Ç€è€ç€À€{€5€€"€i€½€ë€Ó€€+€€D€¥€è€Ø€~€$€€^€Ã€ë€ê€¼€‡€|€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€ €Ú€ë€â€“€2€€E€©€é€Ö€‚€+€€?€—€Ý€è€µ€d€#€€-€k€«€Ú€ë€á€Ã€›€v€W€A€2€+€'€'€,€7€H€a€‚€¨€Ì€æ€é€Ð€›€X€ €€2€|€É€ë€Ï€~€+€€@€ž€å€Þ€€/€€J€¯€é€é€Ì€€z€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€z€€Ì€é€é€¯€J€€/€€Þ€å€ž€@€€+€~€Ï€ë€É€|€2€€ €X€›€Ð€é€æ€Ì€¨€‚€a€H€7€,€'€'€+€2€A€W€v€›€Ã€á€ë€Ú€«€k€-€€#€d€µ€è€Ý€—€?€€+€‚€Ö€é€©€E€€2€“€â€ë€Ú€ €}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€|€Š€¿€ê€ë€Å€d€€€l€É€ë€À€f€€€O€¥€â€è€´€h€(€€ €P€Œ€¿€ß€ë€å€Ó€½€¨€˜€Œ€†€‡€€œ€®€Ä€Ú€è€ê€Ù€³€|€A€€€8€€Ç€ë€Ö€€9€€+€€Õ€ë€±€P€€'€€Ö€ë€ã€®€€{€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€{€€®€ã€ë€Ö€€'€€P€±€ë€Õ€€+€€9€€Ö€ë€Ç€€8€€€A€|€³€Ù€ê€è€Ú€Ä€®€œ€€‡€†€Œ€˜€¨€½€Ó€å€ë€ß€¿€Œ€P€ €€(€h€´€è€â€¥€O€€€f€À€ë€É€l€€€d€Å€ë€ê€¿€Š€|€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€¡€Ù€ê€å€Ÿ€>€€3€€Ü€ç€ª€Q€€€X€«€ã€è€»€t€6€€€2€a€“€¼€Ø€ç€ë€é€ä€á€Þ€Þ€â€æ€ê€ê€ã€Ð€±€…€T€'€€€F€Š€Ì€ë€×€“€C€€ €i€Á€ë€Ë€r€!€€W€¸€ë€è€Ì€’€z€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€z€’€Ì€è€ë€¸€W€€!€r€Ë€ë€Á€i€ €€C€“€×€ë€Ì€Š€F€€€'€T€…€±€Ð€ã€ê€ê€æ€â€Þ€Þ€á€ä€é€ë€ç€Ø€¼€“€a€2€€€6€t€»€è€ã€«€X€€€Q€ª€ç€Ü€€3€€>€Ÿ€å€ê€Ù€¡€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€|€‡€½€è€ë€Ò€x€$€€M€©€ç€Þ€™€D€€€Z€©€á€ê€È€Œ€M€!€€€3€X€€ €¸€Ê€Õ€Û€Ü€Ü€Ú€Ò€Å€±€–€t€M€+€€€+€]€Ÿ€Ö€ë€Ó€“€E€€€[€±€è€Ü€€5€€8€”€à€ë€â€«€€|€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€|€€«€â€ë€à€”€8€€5€€Ü€è€±€[€€€E€“€Ó€ë€Ö€Ÿ€]€+€€€+€M€t€–€±€Å€Ò€Ú€Ü€Ü€Û€Õ€Ê€¸€ €€X€3€€€!€M€Œ€È€ê€á€©€Z€€€D€™€Þ€ç€©€M€€$€x€Ò€ë€è€½€‡€|€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€š€Ó€ë€ê€·€W€€€d€¼€ë€×€€?€€€U€Ÿ€Ø€ë€Ù€ª€q€?€€€€%€;€R€f€u€€…€ƒ€|€q€`€J€3€€€€%€K€€¸€â€ë€Ê€ˆ€A€€€T€¦€ã€å€¥€J€€#€s€Ì€ë€ê€Ã€€{€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€{€€Ã€ê€ë€Ì€s€#€€J€¥€å€ã€¦€T€€€A€ˆ€Ê€ë€â€¸€€K€%€€€€3€J€`€q€|€ƒ€…€€u€f€R€;€%€€€€?€q€ª€Ù€ë€Ø€Ÿ€U€€€?€€×€ë€¼€d€€€W€·€ê€ë€Ó€š€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€|€‚€±€à€ë€â€œ€@€€'€u€Ç€ë€Ó€€@€€€H€€É€è€è€Ê€Ÿ€n€E€'€€€€€€"€%€%€!€€€€€€.€O€z€«€Õ€ë€ã€¹€w€7€€€S€¢€à€è€²€\€€€Y€µ€é€é€×€ €~€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€~€ €×€é€é€µ€Y€€€\€²€è€à€¢€S€€€7€w€¹€ã€ë€Õ€«€z€O€.€€€€€€!€%€%€"€€€€€€'€E€n€Ÿ€Ê€è€è€É€€H€€€@€€Ó€ë€Ç€u€'€€@€œ€â€ë€à€±€‚€|€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€|€Ž€Å€è€ë€Õ€„€0€€1€€Ì€ë€Ó€‘€G€€€7€r€®€Ù€ë€ä€Ë€¨€‚€_€D€1€%€€€€€€€(€7€M€j€€²€Ó€è€é€Ð€ž€_€(€€!€[€¥€ß€é€º€h€ €€E€Ÿ€â€ë€ä€´€…€|€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€|€…€´€ä€ë€â€Ÿ€E€€ €h€º€é€ß€¥€[€!€€(€_€ž€Ð€é€è€Ó€²€€j€M€7€(€€€€€€€%€1€D€_€‚€¨€Ë€ä€ë€Ù€®€r€7€€€G€‘€Ó€ë€Ì€€1€€0€„€Õ€ë€è€Å€Ž€|€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€|€}€€Õ€ë€ë€Ç€q€&€€8€„€Ì€ë€×€œ€U€€€#€P€‡€¹€Ü€ê€è€Ú€Ã€«€•€‚€t€l€h€h€n€y€ˆ€œ€´€Ë€ß€ë€è€Ô€­€y€A€€€-€i€°€â€è€»€m€&€€8€Œ€Ù€ë€ê€Æ€€|€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€|€€Æ€ê€ë€Ù€Œ€8€€&€m€»€è€â€°€i€-€€€A€y€­€Ô€è€ë€ß€Ë€´€œ€ˆ€y€n€h€h€l€t€‚€•€«€Ã€Ú€è€ê€Ü€¹€‡€P€#€€€U€œ€×€ë€Ì€„€8€€&€q€Ç€ë€ë€Õ€€}€|€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€{€€«€Þ€ë€é€»€f€"€€8€€Ç€ë€ß€¬€j€1€€€.€Y€‡€±€Ð€ä€ë€ê€ã€Ü€Ô€Ï€Ì€Ì€Ð€Ö€Þ€æ€ë€ê€ß€É€§€{€L€%€€€@€~€½€ç€å€·€l€'€€1€€€Ð€ë€ë€Ò€œ€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€œ€Ò€ë€ë€Ð€€€1€€'€l€·€å€ç€½€~€@€€€%€L€{€§€É€ß€ê€ë€æ€Þ€Ö€Ð€Ì€Ì€Ï€Ô€Ü€ã€ê€ë€ä€Ð€±€‡€Y€.€€€1€j€¬€ß€ë€Ç€€8€€"€f€»€é€ë€Þ€«€€{€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€{€‡€¸€â€ë€æ€³€b€!€€3€w€½€ç€è€Â€ˆ€M€$€€€,€N€t€–€´€Ê€×€à€å€è€è€è€ç€ä€Ý€Ó€Ã€«€€i€D€%€€€-€]€›€Ð€ë€Þ€«€c€%€€/€z€É€ë€ê€Ú€¨€€|€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€|€€¨€Ú€ê€ë€É€z€/€€%€c€«€Þ€ë€Ð€›€]€-€€€%€D€i€€«€Ã€Ó€Ý€ä€ç€è€è€è€å€à€×€Ê€´€–€t€N€,€€€$€M€ˆ€Â€è€ç€½€w€3€€!€b€³€æ€ë€â€¸€‡€{€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€{€€Â€æ€ë€å€±€c€$€€+€h€«€Ý€ë€Ø€¬€v€E€#€€€€3€M€e€z€‹€˜€Ÿ€¢€¢€€”€†€t€]€D€,€€€€*€Q€‡€»€â€ë€Ñ€™€U€€€2€z€Æ€ë€ê€ß€±€„€|€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€|€„€±€ß€ê€ë€Æ€z€2€€€U€™€Ñ€ë€â€»€‡€Q€*€€€€,€D€]€t€†€”€€¢€¢€Ÿ€˜€‹€z€e€M€3€€€€#€E€v€¬€Ø€ë€Ý€«€h€+€€$€c€±€å€ë€æ€Â€€{€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€|€{€’€È€ç€ë€å€µ€k€+€€€R€“€Ê€è€è€Ð€¦€x€O€.€€€€€ €*€2€8€:€:€7€0€&€€€€€€5€Y€„€²€Ù€ë€â€¼€€€A€€€:€€€È€ë€ê€â€·€‡€{€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€{€‡€·€â€ê€ë€È€€€:€€€A€€€¼€â€ë€Ù€²€„€Y€5€€€€€€&€0€7€:€:€8€2€*€ €€€€€.€O€x€¦€Ð€è€è€Ê€“€R€€€+€k€µ€å€ë€ç€È€’€{€|€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€|€|€•€Ê€è€ê€ç€½€y€8€€€:€r€«€Ö€ê€è€Ó€²€€j€L€4€%€€€€€€€€€€€)€;€T€t€—€¼€Ú€ê€ç€Ë€š€a€,€€€H€€Í€ê€ê€â€º€Š€{€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€{€Š€º€â€ê€ê€Í€€H€€€,€a€š€Ë€ç€ê€Ú€¼€—€t€T€;€)€€€€€€€€€€€%€4€L€j€€²€Ó€è€ê€Ö€«€r€:€€€8€y€½€ç€ê€è€Ê€•€|€|€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€|€•€È€é€ê€ê€Ê€€L€€€"€L€€±€Ö€è€ë€ß€Ê€±€˜€€n€_€T€N€J€J€O€W€c€t€ˆ€ €¹€Ñ€ã€ë€å€Í€¥€q€>€€€'€]€Ÿ€×€ê€ë€ä€¸€‰€{€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€{€‰€¸€ä€ë€ê€×€Ÿ€]€'€€€>€q€¥€Í€å€ë€ã€Ñ€¹€ €ˆ€t€c€W€O€J€J€N€T€_€n€€˜€±€Ê€ß€ë€è€Ö€±€€L€"€€€L€€Ê€ê€ê€é€È€•€|€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€“€Â€æ€é€ë€Ú€¦€g€1€€€)€P€~€¨€Ê€ß€ê€ë€å€Û€Ð€Ä€¼€·€´€´€·€¾€È€Ó€Þ€è€ë€è€Ú€Â€€q€D€€€€?€y€·€â€ë€é€à€³€ˆ€{€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€{€ˆ€³€à€é€ë€â€·€y€?€€€€D€q€€Â€Ú€è€ë€è€Þ€Ó€È€¾€·€´€´€·€¼€Ä€Ð€Û€å€ë€ê€ß€Ê€¨€~€P€)€€€1€g€¦€Ú€ë€é€æ€Â€“€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€¹€á€é€ë€æ€Â€Š€R€'€€€%€D€h€€«€Ä€Ö€â€ç€ê€ë€ë€ë€ë€ë€ë€é€æ€Þ€Ñ€½€¤€ƒ€^€;€€€€2€b€›€Ï€é€é€é€Ù€«€…€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€…€«€Ù€é€é€é€Ï€›€b€2€€€€;€^€ƒ€¤€½€Ñ€Þ€æ€é€ë€ë€ë€ë€ë€ë€ê€ç€â€Ö€Ä€«€€h€D€%€€€'€R€Š€Â€æ€ë€é€á€¹€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€†€«€×€ê€è€ë€Ü€±€~€N€)€€€€,€E€`€y€Ž€Ÿ€­€¶€»€½€½€º€³€©€š€‡€q€X€>€&€€€€1€\€€¿€ã€ë€è€é€Í€Ÿ€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€Ÿ€Í€é€è€ë€ã€¿€€\€1€€€€&€>€X€q€‡€š€©€³€º€½€½€»€¶€­€Ÿ€Ž€y€`€E€,€€€€)€N€~€±€Ü€ë€è€ê€×€«€†€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€€›€Æ€ä€é€é€ê€Ö€¯€‚€X€6€€€€€€,€9€D€M€S€V€V€Q€J€A€5€(€€€€€$€>€c€€¼€Þ€ë€é€é€ß€º€‘€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€‘€º€ß€é€é€ë€Þ€¼€€c€>€$€€€€€(€5€A€J€Q€V€V€S€M€D€9€,€€€€€€6€X€‚€¯€Ö€ê€é€é€ä€Æ€›€€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‰€®€Ö€é€è€é€é€Ú€»€˜€t€T€:€&€€€€€€€€€€€€€€€+€@€\€}€¡€Ä€à€ë€è€é€æ€Ì€£€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€£€Ì€æ€é€è€ë€à€Ä€¡€}€\€@€+€€€€€€€€€€€€€€€&€:€T€t€˜€»€Ú€é€é€è€é€Ö€®€‰€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€”€º€Ü€ê€è€é€ë€ä€Ò€¹€Ÿ€…€m€Z€J€?€8€3€1€1€4€:€C€O€`€t€Œ€¥€À€Ø€è€ë€è€é€è€Ó€®€Œ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€Œ€®€Ó€è€é€è€ë€è€Ø€À€¥€Œ€t€`€O€C€:€4€1€1€3€8€?€J€Z€m€…€Ÿ€¹€Ò€ä€ë€é€è€ê€Ü€º€”€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€˜€»€Ù€é€ê€è€é€ë€è€Ý€Ï€À€³€§€Ÿ€™€—€—€š€¡€«€·€Å€Ô€á€é€ë€é€è€ë€ç€Ñ€°€€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€€°€Ñ€ç€ë€è€é€ë€é€á€Ô€Å€·€«€¡€š€—€—€™€Ÿ€§€³€À€Ï€Ý€è€ë€é€è€ê€é€Ù€»€˜€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€“€°€Ì€á€ë€é€è€è€é€ë€ë€é€è€ç€æ€æ€ç€è€ê€ë€ê€è€è€è€ë€é€Ü€Å€§€Œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€Œ€§€Å€Ü€é€ë€è€è€è€ê€ë€ê€è€ç€æ€æ€ç€è€é€ë€ë€é€è€è€é€ë€á€Ì€°€“€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€‡€š€²€É€Ú€å€ë€ë€é€è€è€è€è€è€è€è€é€ê€ë€é€â€Ö€Ã€«€”€ƒ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€ƒ€”€«€Ã€Ö€â€é€ë€ê€é€è€è€è€è€è€è€è€é€ë€ë€å€Ú€É€²€š€‡€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€ƒ€€Ÿ€¯€½€É€Ð€Ö€Ù€Û€Û€Ø€Õ€Î€Å€¸€ª€š€Œ€€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€€Œ€š€ª€¸€Å€Î€Õ€Ø€Û€Û€Ù€Ö€Ð€É€½€¯€Ÿ€€ƒ€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€…€‰€Œ€€€‹€ˆ€„€€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€~€€€„€ˆ€‹€€€Œ€‰€…€€~€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€½€é€è€¹€h€-€€7€q€±€×€Ô€¨€f€/€€7€p€°€Ø€Ô€§€f€/€€6€q€±€Ø€Ô€§€f€0€€4€o€±€Ø€Ó€¦€e€+€€W€À€ë€ë€Á€V€€Z€¿€Ô€€%€3€›€Ý€¨€@€€m€Î€Ê€h€€D€¯€Ü€“€0€(€ƒ€Ö€¼€R€€Y€Á€Õ€€€%€5€™€Û€©€=€€r€Ñ€È€f€€G€±€Ú€‘€-€)€‡€Ù€¹€P€€\€Â€Õ€z€"€7€ž€Ü€§€>€ €q€Ð€È€d€€G€²€Ú€“€/€)€ˆ€Ø€¸€M€!€…€ã€ë€Ÿ€Q€³€¼€:€B€Å€°€.€Q€Í€€'€f€Ó€„€!€|€Ø€t€"€Œ€Ð€]€*€¥€Ê€J€1€¶€¿€<€@€Á€­€0€V€Ð€š€#€c€Ô€„€#€€Ô€l€$€•€Ñ€X€)€¥€É€J€6€¸€¹€6€D€È€¬€,€V€Ï€—€%€j€Ö€‚€€€€Ö€p€$€’€Ð€W€+€©€É€F€1€¶€¾€Š€Ö€é€ˆ€c€Ë€[€F€Ê€k€>€Ã€w€8€¿€‚€/€¸€”€+€©€¡€-€Ÿ€©€,€•€·€.€„€Á€8€u€Ã€?€l€Ê€E€\€Ï€T€M€Ê€b€F€Ç€k€?€È€w€4€¾€‡€1€´€’€.€­€ž€*€ €®€,€€¶€1€‡€½€5€y€Ç€>€g€Ê€J€\€Ê€S€R€Ì€_€D€Ê€p€:€Á€}€I€Ó€é€Î€Ð€y€6€½€~€;€»€z€>€¼€z€=€¸€}€A€·€w€D€¼€r€A€½€u€>€¾€u€?€Á€s€>€Ä€t€7€Â€~€8€¼€}€>€»€y€?€½€|€>€·€x€D€º€q€H€¿€n€C€Á€r€A€Á€p€B€Ã€n€?€È€t€8€Á€z€<€½€w€A€½€t€>€¼€y€A€¹€u€F€¼€n€G€Â€Ù€è€Ù€\€š€€W€·€P€Œ€€H€´€]€x€Ÿ€B€¨€l€h€¯€C€š€€€Y€¶€O€‹€€J€µ€^€y€Ÿ€B€ª€m€g€­€C€™€~€Y€Ã€Ö€ç€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¾€ê€è€»€h€/€ €:€t€±€Ø€Õ€©€h€2€€:€s€±€Ø€Õ€¨€h€2€€9€s€±€Ø€Õ€©€h€3€€8€q€±€Ø€Ô€¨€h€/€€Z€Á€ë€ë€Â€V€€\€À€Ô€€(€8€€Þ€ª€C€$€o€Ï€Ê€i€!€G€±€Ý€•€4€+€…€×€½€V€€\€Á€Ö€€(€8€›€Û€ª€@€#€t€Ñ€È€h€"€J€²€Ú€“€1€,€‰€Ù€º€S€!€^€Ã€Õ€}€&€:€Ÿ€Ü€¨€A€%€t€Ð€É€g€€J€´€Û€”€2€,€Š€Ù€¹€N€"€‡€ã€ë€¡€T€³€½€>€E€Æ€±€1€U€Í€ž€+€h€Ô€†€%€€Ø€w€&€Ž€Ñ€`€.€¥€Ê€N€6€·€À€@€D€Ã€®€3€X€Ð€œ€'€f€Õ€‡€'€€Ô€n€(€—€Ó€[€,€¦€É€M€9€¹€º€9€G€È€®€0€Z€Ï€™€*€m€Ö€„€#€€×€s€'€“€Ð€[€0€ª€É€J€5€·€¾€€×€é€‹€e€Ë€]€J€Ë€n€A€Ä€z€<€À€…€3€¹€–€/€«€¢€1€¡€«€1€—€·€1€†€Â€<€w€Ä€C€n€Ê€J€_€Ï€W€P€Ê€e€J€È€n€D€É€y€8€¾€‰€4€µ€“€2€¯€Ÿ€-€¢€¯€1€’€·€6€ˆ€½€8€z€È€A€j€Ë€M€^€Ê€V€U€Í€b€F€Ê€s€>€Â€}€K€Ô€é€Ð€Ñ€y€8€¾€€€>€¼€|€C€½€{€@€º€€€D€¹€z€H€½€t€D€¿€x€B€¿€w€B€Â€t€B€Ä€w€;€Ã€€;€½€€€@€¼€z€C€¾€€@€¹€z€H€»€s€K€À€p€E€Â€t€D€Á€s€D€Ä€p€C€É€w€<€Â€|€?€¾€y€D€¾€v€A€½€{€D€»€w€I€½€o€H€Ã€Ú€è€Ù€_€›€ƒ€[€·€S€€‘€K€¶€`€z€¡€D€ª€n€k€±€F€œ€‚€\€·€Q€€’€L€¶€a€z€ €E€«€o€i€®€E€›€€Y€Ã€Ö€è€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Ì€ê€é€Ê€’€j€a€r€™€Ã€Þ€Ü€¾€“€m€`€r€™€Ã€Þ€Ü€½€’€m€`€q€™€Ä€ß€Ü€½€’€n€`€p€˜€Ã€Þ€Û€½€’€j€]€‡€Ï€ë€ë€Ï€†€_€Š€Î€Ü€¢€f€o€¶€â€¾€x€b€–€×€Õ€“€a€{€Ã€â€±€n€h€¥€Ý€Ë€„€_€‰€Ï€Ü€£€f€q€´€à€¾€v€b€™€Ú€Ô€’€b€}€Ä€ß€¯€l€h€¨€ß€Ê€ƒ€a€‹€Ð€Ü€Ÿ€e€r€·€à€½€w€c€™€Ù€Ó€‘€`€}€Å€à€¯€m€i€©€ß€Ê€€€b€§€æ€ë€·€„€Ä€Ë€t€z€Ò€Ã€l€„€Ö€·€h€’€Û€¥€c€¡€Þ€œ€d€«€Ù€Œ€j€¼€Õ€€o€È€Î€v€x€Ï€Â€n€‡€Ø€µ€e€€Ü€¦€e€£€Ü€–€e€±€Ú€ˆ€h€¼€Ô€€q€Ê€Ê€q€z€Ó€Á€k€‡€×€²€g€”€Ü€¥€b€£€Ý€™€f€¯€Ø€‡€j€¿€Õ€}€n€Ç€Í€«€Ý€é€©€€Ö€Š€|€Ö€–€w€Ð€ž€s€Î€¥€n€É€±€k€¿€¹€l€¸€¿€l€±€È€m€¥€Ï€s€œ€Ñ€x€–€Õ€|€‹€×€†€€Ö€€}€Ó€–€x€Ó€€p€Í€¨€n€Æ€¯€l€Â€·€i€¹€Ã€l€®€È€o€§€Ì€q€Ÿ€Ó€v€“€Õ€€€‹€Õ€…€…€Ö€€z€Õ€™€u€Ð€ €~€Û€ê€Ø€Ù€€q€Ì€¢€t€Ë€Ÿ€w€Ë€Ÿ€v€Ê€¡€y€É€ž€{€Ë€™€y€Í€œ€w€Í€œ€x€Ï€š€v€Ð€œ€r€Ð€¢€s€Ë€¡€v€Ê€Ÿ€x€Ì€ €v€É€ž€|€Ê€™€~€Î€—€z€Ï€š€y€Ï€™€y€Ð€—€w€Ó€œ€t€Ï€Ÿ€v€Ì€ž€y€Í€œ€w€Ë€Ÿ€y€Ê€œ€|€Ë€–€z€Ð€ß€è€ß€‹€´€¤€ˆ€È€ƒ€«€­€~€Æ€Œ€ž€¸€z€¾€–€“€Ã€z€µ€£€‰€Ç€‚€«€®€€Ç€€ž€·€z€¿€–€’€Â€z€µ€ €‡€Ð€Ü€è€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€ë€æ€Þ€×€Ö€Ø€Þ€å€é€é€ä€Ý€×€Ö€Ø€Þ€å€é€è€ä€Ý€×€Ö€Ù€Þ€å€é€è€ä€Ý€Ø€Ö€Ø€Þ€å€é€è€ä€Ý€Ø€Ö€Ü€ç€ë€ë€ç€Ü€Ö€Ü€ç€é€à€Ö€Ø€ã€é€ä€Ú€Ö€Þ€è€è€Ý€Ö€Ú€å€é€â€Ø€×€á€è€ç€Ü€Ö€Ü€ç€é€à€×€Ø€â€é€ä€Ú€Ö€ß€è€è€Ý€Ö€Û€æ€é€â€Ø€×€á€é€æ€Ü€Ö€Ü€ç€è€à€Ö€Ø€ã€é€ä€Ù€Ö€Þ€è€è€Ý€Ö€Û€å€é€â€Ø€×€á€é€æ€Û€Ö€á€ê€ë€ã€Ü€å€æ€Ù€Ù€è€å€Ø€Ü€è€ã€×€Ý€è€á€Ö€à€é€ß€Ö€â€è€Ü€×€ä€è€Û€Ø€æ€ç€Ù€Ú€ç€ä€×€Ü€è€â€Ö€Ý€é€á€×€à€è€Þ€×€â€è€Ü€×€ã€è€Û€Ù€æ€æ€Ù€Ú€è€å€Ø€Ü€è€â€Ö€Þ€è€à€Ö€à€é€ß€Ö€â€è€Ü€Ø€ä€è€Û€Ø€å€æ€á€é€ë€â€Ý€è€Ü€Û€è€Þ€Ù€è€ß€Ø€æ€à€×€æ€â€×€ä€ä€Ø€ã€ä€×€â€æ€Ø€à€ç€Ù€ß€è€Ù€Þ€è€Ú€Ü€è€Ü€Û€è€Ý€Ú€è€Þ€Ú€ç€ß€Ø€ç€â€Ø€å€â€Ø€å€ã€×€ã€å€×€â€å€Ø€á€ç€Ø€ß€è€Ú€Ý€è€Û€Ü€è€Ü€Û€è€Ü€Ú€è€Þ€Ù€ç€à€Û€è€ê€è€è€ß€Ù€ç€à€Ù€ç€ß€Ù€æ€à€Ú€æ€à€Ú€å€à€Ú€æ€Þ€Ú€ç€ß€Ù€æ€ß€Ù€ç€ß€Ù€ç€ß€Ù€ç€à€Ù€æ€à€Ù€æ€à€Ú€ç€à€Ù€æ€ß€Ú€æ€Þ€Ú€ç€Þ€Ú€ç€Þ€Ú€ç€ß€Ú€ç€Þ€Ú€ç€ß€Ù€ç€à€Ù€ç€ß€Ú€æ€ß€Ù€æ€à€Ú€æ€ß€Ú€æ€Þ€Û€è€é€ê€è€Ü€â€á€Ü€å€Û€á€â€Ú€å€Ü€ß€ã€Ú€ä€Þ€Þ€å€Ú€â€à€Ü€æ€Û€â€â€Û€æ€Ü€ß€ã€Ú€ä€Þ€Þ€å€Ú€â€à€Ü€ç€è€ê€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€.€]€“€Â€Ý€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€å€ê€é€ã€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€æ€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€ç€ë€è€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€ç€â€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€â€è€ë€æ€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€ã€é€ê€å€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€á€ä€ê€ê€ä€á€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€à€Ý€Â€“€]€.€€€%€F€k€Œ€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€Â€å€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¨€Ç€è€á€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€«€Í€ê€Ü€¶€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€®€Ò€ë€×€±€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€²€Ø€ë€Ñ€­€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€·€Ý€ê€Ì€ª€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€â€è€Æ€§€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€ä€À€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€§€Æ€è€â€»€£€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€ª€Ì€ê€Ý€·€¡€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€­€Ñ€ë€Ø€²€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€ €Ÿ€±€×€ë€Ò€®€Ÿ€ €¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¡€¶€Ü€ê€Í€«€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€£€»€á€è€Ç€¨€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€¥€À€ä€å€Â€¥€Ÿ€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€¡€Ÿ€Œ€k€F€%€€€ €:€V€p€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€¯€ã€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€‰€·€è€Ü€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€€¿€ë€Ö€€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€’€È€ë€Ï€–€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€˜€Ð€ë€Æ€‘€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€Ÿ€×€ê€½€Œ€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ý€ç€µ€ˆ€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€â€­€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€ˆ€µ€ç€Ý€¥€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€|€Œ€½€ê€×€Ÿ€€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€|€‘€Æ€ë€Ð€˜€}€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€}€–€Ï€ë€È€’€|€~€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€€Ö€ë€¿€€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€€¥€Ü€è€·€‰€|€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€}€…€­€â€ã€¯€…€}€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€~€p€V€:€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ €€€ €9€T€m€{€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€„€­€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€¶€ç€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€Œ€¾€ê€Õ€œ€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Ç€ë€Î€•€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€–€Ð€ë€Å€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€ž€Ö€é€½€‹€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€æ€´€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€«€ƒ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‡€´€æ€Ü€¤€€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€‹€½€é€Ö€ž€~€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€|€€Å€ë€Ð€–€}€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€}€•€Î€ë€Ç€€|€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€~€œ€Õ€ê€¾€Œ€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€€¤€Ü€ç€¶€‡€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€|€ƒ€«€â€â€­€„€|€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€}€{€m€T€9€ € \ No newline at end of file diff --git a/examples/video-sync/Makefile b/examples/video-sync/Makefile new file mode 100644 index 0000000..cba823d --- /dev/null +++ b/examples/video-sync/Makefile @@ -0,0 +1,6 @@ +TARGET = video-sync.img + +APP_SOURCES = main.c screen.png.data.o + +LIB_DIR = ../../lib +include $(LIB_DIR)/Makefile.rules diff --git a/examples/video-sync/main.c b/examples/video-sync/main.c new file mode 100644 index 0000000..4f1ceeb --- /dev/null +++ b/examples/video-sync/main.c @@ -0,0 +1,147 @@ +/* + * video-sync -- Test video DMA synchronization, by displaying a + * sequence of animated frames with flow control and multi-frame + * buffering. + * + * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT + * License, please see the README.txt. All rights reserved. + */ + + +#include "svga.h" +#include "png.h" +#include "intr.h" +#include "datafile.h" + +/* + * Our background image, in PNG format. + */ + +DECLARE_DATAFILE(screenPNGFile, screen_png); + +/* + * generateFrame -- + * + * Generate one frame of video, in UYVY format. + */ + +static void +generateFrame(uint8 *buffer, // OUT + uint32 width, // IN + uint32 height, // IN + uint32 frame) // IN +{ + uint32 wordPitch = width / 2; + uint32 numWords = wordPitch * height; + int x = frame % width; + uint32 *linePtr = (uint32*)buffer + (x >> 1); + uint32 lineWord; + + /* + * Clear it multiple times, so it will be obvious if the + * host reads a frame that we're still writing to. + */ + + // Y1VVY0UU + memset32(buffer, 0xFFFFFFFF, numWords); + memset32(buffer, 0x40804080, numWords); + + /* + * Draw a vertical line that moves right on each frame. This is + * the easiest way to make it obvious when the image tears. + * + * This test will also show when the luminance bytes in the + * packed-pixel decoder are out of order. + */ + + if (x & 1) { + lineWord = 0xFF804080; + } else { + lineWord = 0x4080FF80; + } + + while (height--) { + *linePtr = lineWord; + linePtr += wordPitch; + } +} + + +/* + * main -- + * + * Initialization and main loop. + */ + +int +main(void) +{ + PNGChunkIHDR *screenPNG = PNG_Header(screenPNGFile->ptr); + uint32 width = bswap32(screenPNG->width); + uint32 height = bswap32(screenPNG->height); + + Intr_Init(); + Intr_SetFaultHandlers(SVGA_DefaultFaultHandler); + SVGA_Init(); + SVGA_SetMode(width, height, 32); + + /* + * Draw the background image + */ + + PNG_DecompressBGRX(screenPNG, (uint32*) gSVGA.fbMem, gSVGA.pitch); + SVGA_Update(0, 0, width, height); + + /* + * Initialize the video overlay unit. We're displaying DVD-resolution + * letterboxed 16:9 video, in UYVY (packed-pixel) format. + */ + + SVGAOverlayUnit overlay = { + .enabled = TRUE, + .format = VMWARE_FOURCC_UYVY, + .width = 720, + .height = 480, + .srcWidth = 720, + .srcHeight = 480, + .dstX = 1, + .dstY = 92, + .dstWidth = 1022, + .dstHeight = 574, + .pitches[0] = 1440, + }; + + SVGA_VideoSetAllRegs(0, &overlay, SVGA_VIDEO_PITCH_3); + + /* + * Main loop. Loop over each frame in the ring buffer repeatedly. + * We wait for the DMA buffer to become available, fill it with the + * next frame, then program the overlay unit to display that frame. + */ + + uint32 frameCounter = 0; + + uint32 baseOffset = width * height * 4; + uint32 frameSize = overlay.pitches[0] * overlay.height; + static uint32 fences[16]; + + while (1) { + uint32 bufferId; + + for (bufferId = 0; bufferId < arraysize(fences); bufferId++) { + uint32 bufferOffset = baseOffset + bufferId * frameSize; + uint8 *bufferPtr = gSVGA.fbMem + bufferOffset; + + SVGA_SyncToFence(fences[bufferId]); + + generateFrame(bufferPtr, overlay.width, overlay.height, frameCounter++); + + SVGA_VideoSetReg(0, SVGA_VIDEO_DATA_OFFSET, bufferOffset); + SVGA_VideoFlush(0); + + fences[bufferId] = SVGA_InsertFence(); + } + } + + return 0; +} diff --git a/examples/video-sync/screen.png b/examples/video-sync/screen.png new file mode 100644 index 0000000..1406818 Binary files /dev/null and b/examples/video-sync/screen.png differ diff --git a/lib/Makefile.rules b/lib/Makefile.rules new file mode 100644 index 0000000..a296bd5 --- /dev/null +++ b/lib/Makefile.rules @@ -0,0 +1,132 @@ +# +# Common GNU Make rules for the VMware SVGA examples. +# +# To build your own apps, you just need a makefile which +# defines a few variables and includes this one. For example: +# +# LIB_DIR = path/to/lib +# TARGET = myapp.img +# APP_MODULES = main +# include $(LIB_DIR)/Makefile.rules +# +# All examples get compiled with all library code, and we let +# GCC garbage collect modules that aren't being used. +# + +# Basic options necessary to produce our standalone binary. +# Produce 32-bit code, even on 64-bit machines. Don't use +# the standard library at all. Begin the text segment at 1MB. + +CFLAGS := -m32 -ffreestanding -nostdinc -fno-stack-protector +LDFLAGS := -nostdlib -Wl,-T,$(LIB_DIR)/metalkit/image.ld + +# Extra warnings +CFLAGS += -Wall -Werror + +# Size Optimizations. +CFLAGS += -Os -Wl,--gc-sections -ffunction-sections -fdata-sections + +# This enables extra gcc builtins for floating point math. +CFLAGS += -march=i686 -ffast-math + +# Generate debug symbols. These only show up in the .elf file, not the +# final image. Recent versions of VMware have a gdb debug stub that +# you can use along with these symbols for source-level debugging of +# Metalkit apps. +CFLAGS += -g + +# Most of the examples only need 4MB of memory. Some examples +# override this, so only set it if it isn't already defined. +ifeq ($(VMX_MEMSIZE),) + VMX_MEMSIZE = 4 +endif + +CFLAGS += \ + -I$(LIB_DIR)/metalkit \ + -I$(LIB_DIR)/util \ + -I$(LIB_DIR)/refdriver \ + -I$(LIB_DIR)/vmware \ + +SOURCES := \ + $(LIB_DIR)/metalkit/boot.S \ + $(LIB_DIR)/metalkit/pci.c \ + $(LIB_DIR)/metalkit/intr.c \ + $(LIB_DIR)/metalkit/console.c \ + $(LIB_DIR)/metalkit/console_vga.c \ + $(LIB_DIR)/metalkit/puff.c \ + $(LIB_DIR)/metalkit/timer.c \ + $(LIB_DIR)/metalkit/keyboard.c \ + $(LIB_DIR)/metalkit/bios.c \ + $(LIB_DIR)/metalkit/apm.c \ + $(LIB_DIR)/metalkit/gcc_support.c \ + $(LIB_DIR)/util/matrix.c \ + $(LIB_DIR)/util/svga3dutil.c \ + $(LIB_DIR)/util/svga3dtext.c \ + $(LIB_DIR)/util/vmbackdoor.c \ + $(LIB_DIR)/util/mt19937ar.c \ + $(LIB_DIR)/util/png.c \ + $(LIB_DIR)/refdriver/svga.c \ + $(LIB_DIR)/refdriver/svga3d.c \ + $(LIB_DIR)/refdriver/gmr.c \ + $(APP_SOURCES) + +ELF_TARGET := $(subst .img,.elf,$(TARGET)) +LST_TARGET := $(subst .img,.lst,$(TARGET)) +VMX_TARGET := $(subst .img,.vmx,$(TARGET)) +PLAIN_TARGET := $(subst .img,,$(TARGET)) + + +.PHONY: all target clean sizeprof listing + +target: $(TARGET) $(VMX_TARGET) + +%.lst: %.elf + objdump -d $< > $@ + +%.img: %.elf + objcopy -O binary $< $@ + +# Stackable rules for processing data files + +%.data.o: % + objcopy -I binary -O elf32-i386 -B i386 $< $@ + +%.z: % + python $(LIB_DIR)/metalkit/deflate.py < $< > $@ + +# To optimize size, we compile all input files in one step. This +# lets GCC use information available from all files during its +# optimization phase. + +$(ELF_TARGET): $(SOURCES) + $(CC) $(LDFLAGS) $(CFLAGS) -o $@ $(SOURCES) + +clean: + rm -f $(TARGET) $(ELF_TARGET) $(LST_TARGET) $(VMX_TARGET) *.o + +# This is a phony target which prints a list of symbols, sorted by +# size, and excluding the BSS segment. This is a quick way to see +# which functions and initialized data are taking the most space in +# the final binary. + +sizeprof: $(ELF_TARGET) + @nm --size-sort -S $< | egrep -v " [bBsS] " + +# Another phony target, for convenience, which dumps an assembly +# listing to stdout. + +listing: $(ELF_TARGET) + objdump -d $< + +# Generate a .vmx config file for VMware + +$(VMX_TARGET): + @echo config.version = 8 > $(VMX_TARGET) + @echo virtualHW.version = 7 >> $(VMX_TARGET) + @echo memsize = $(VMX_MEMSIZE) >> $(VMX_TARGET) + @echo displayname = $(PLAIN_TARGET) >> $(VMX_TARGET) + @echo guestOS = other >> $(VMX_TARGET) + @echo mks.enable3d = TRUE >> $(VMX_TARGET) + @echo floppy0.startConnected = TRUE >> $(VMX_TARGET) + @echo floppy0.fileType = file >> $(VMX_TARGET) + @echo floppy0.fileName = $(TARGET) >> $(VMX_TARGET) diff --git a/lib/README b/lib/README new file mode 100644 index 0000000..924948f --- /dev/null +++ b/lib/README @@ -0,0 +1,25 @@ +Library Code +------------ + +metalkit - + Open source (MIT-licensed) library code for writing programs + that run on the IA32 architecture on the "bare metal", without + an operating system. + +refdriver - + Source code for the VMware SVGA reference driver. + +util - + Utility code used by the accompanying examples. Includes higher + level APIs built on top of the reference driver, as well as + miscellaneous code such as text rendering and matrix math. + +vmware - + VMware-provided header files, including the headers which define + registers and FIFO commands used by the VMware SVGA device. + +win32 - + A Win32 port of the VMWare SVGA reference driver. This driver runs + in userspace, using the kernel mode interface provided by VMware's + proprietary kernel-mode graphics driver for Windows XP. + diff --git a/lib/metalkit/apm.c b/lib/metalkit/apm.c new file mode 100644 index 0000000..06c7a0b --- /dev/null +++ b/lib/metalkit/apm.c @@ -0,0 +1,164 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * apm.c - Support for the legacy Advanced Power Management (APM) BIOS + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2009 Micah Dowty + * + * 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. + */ + +#include "apm.h" +#include "bios.h" +#include "intr.h" + +APMState gAPM; + +/* + * APM_Init -- + * + * Probe for APM support. If APM is available, this connects to APM. + * + * It would be easier to use the 16-bit real mode interface via + * Metalkit's BIOS module, but that wouldn't work very well for us + * because we can't handle interrupts during a real-mode BIOS call. + * So, any APM_Idle() call would hang! + * + * Instead, we need to use 16-bit BIOS calls to bootstrap APM, then + * we do our real work via the 32-bit APM interface that is present + * in all APM 1.2 BIOSes. + * + * On exit, gAPM will have a valid 'connected' flag, APM version, + * and flags. + */ + +fastcall void +APM_Init() +{ + APMState *self = &gAPM; + Regs reg = {}; + + /* Real mode "APM Installation Check" call */ + reg.ax = 0x5300; + reg.bx = 0x0000; + BIOS_Call(0x15, ®); + if (reg.bx == SIGNATURE_APM && reg.cf == 0) { + self->version = reg.ax; + self->flags = reg.cx; + } else { + return; + } + + /* Real-mode interface connect */ + reg.ax = 0x5303; + reg.bx = 0x0000; + BIOS_Call(0x15, ®); + if (reg.cf != 0) { + return; + } + + /* Indicate that we want APM v1.2 */ + reg.ax = 0x530e; + reg.bx = 0x0000; + reg.cx = 0x0102; + BIOS_Call(0x15, ®); + if (reg.cf != 0) { + return; + } + + /* Success! */ + self->connected = TRUE; +} + + +/* + * APM_Idle -- + * + * If we're connected to APM, issue a "CPU Idle" call. The BIOS may + * halt the CPU until the next interrupt and/or slow or stop the + * CPU clock. + * + * If we aren't connected to APM or the APM call is unsuccessful, + * this issue a CPU HLT instruction. + */ + +fastcall void +APM_Idle() +{ + /* + * XXX: This doesn't actually work, because BIOS_Call disables + * interrupts! To get idle calls working, we'll need to use + * the real 32-bit APM interface. + */ +#if 0 + + APMState *self = &gAPM; + + if (self->connected) { + Regs reg = {}; + + /* Real mode "CPU Idle" call */ + reg.ax = 0x5305; + BIOS_Call(0x15, ®); + if (reg.cf == 0) { + /* Success */ + return; + } + } + +#endif + + /* Fall back to CPU HLT */ + Intr_Halt(); +} + + +/* + * APM_SetPowerState -- + * + * Set the power state of all APM-managed devices. + * If we aren't connected to APM, always fails. + * + * Returns TRUE on success, FALSE on error. + */ + +fastcall Bool +APM_SetPowerState(uint16 state) +{ + APMState *self = &gAPM; + + if (self->connected) { + Regs reg = {}; + + reg.ax = 0x5307; // APM Set Power State + reg.bx = 0x0001; // All devices + reg.cx = state; + BIOS_Call(0x15, ®); + + return reg.cf == 0; + } + + return FALSE; +} diff --git a/lib/metalkit/apm.h b/lib/metalkit/apm.h new file mode 100644 index 0000000..1840bf4 --- /dev/null +++ b/lib/metalkit/apm.h @@ -0,0 +1,65 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * apm.c - Support for the legacy Advanced Power Management (APM) BIOS + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __APM_H__ +#define __APM_H__ + +#include "types.h" +#include "bios.h" + +#define SIGNATURE_APM 0x504d // "PM" + +#define APM_FLAG_16BIT (1 << 0) +#define APM_FLAG_32BIT (1 << 1) +#define APM_FLAG_SLOW_CPU_ON_IDLE (1 << 2) +#define APM_FLAG_DISABLED (1 << 3) +#define APM_FLAG_DISENGAGED (1 << 4) + +/* APM power states */ +#define POWER_ON 0 +#define POWER_STANDBY 1 +#define POWER_SUSPEND 2 +#define POWER_OFF 3 + +typedef struct { + Bool connected; // Are we successfully connected to APM? + uint16 version; // Supported APM version in BCD, 0 if not supported + uint16 flags; +} APMState; + +extern APMState gAPM; + +fastcall void APM_Init(); +fastcall void APM_Idle(); +fastcall Bool APM_SetPowerState(uint16 state); + +#endif /* __APM_H_ */ diff --git a/lib/metalkit/bios.c b/lib/metalkit/bios.c new file mode 100644 index 0000000..b736850 --- /dev/null +++ b/lib/metalkit/bios.c @@ -0,0 +1,247 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * bios.c - Make real-mode BIOS calls from protected mode. + * For simplicity and small size, this implementation + * switches back to real-mode rather than using virtual 8086 + * mode. A v86 mode implementation may be more robust. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#include "bios.h" +#include "boot.h" +#include "intr.h" + + +/* + * BIOSCallInternal -- + * + * Internal implementation of BIOS_Call. This is a C function which + * wraps the assembly-language internal implementation. The only + * reason to use C here, really, is so we can easily calculate + * offsets into our shared C structures. + * + * This function must not make any function calls, since we need to + * be able to trust the value of %esp. This is also why it must not + * be inlined into BIOS_Call itself. + */ + +static __attribute__((noinline)) void +BIOSCallInternal(void) +{ + /* + * Save registers and stack in a safe place. + */ + asm volatile ("pusha"); + asm volatile ("mov %%esp, %0" :"=m" (BIOS_SHARED->esp)); + + /* + * Jump the the relocated 16-bit trampoline (source code below). + */ + asm volatile ("ljmp %0, %1" + :: "i" (BOOT_CODE16_SEG), "i" (BIOS_SHARED->trampoline)); + + /* + * This is where we return from the relocated trampoline. + * We're back in protected mode, but the data segments + * are still 16-bit. Restore them. + */ + + asm volatile ("BIOSReturn32: \n" + "mov %0, %%ax \n" + "mov %%ax, %%ss \n" + "mov %%ax, %%ds \n" + "mov %%ax, %%es \n" + "mov %%ax, %%fs \n" + "mov %%ax, %%gs \n" + :: "i" (BOOT_DATA_SEG)); + + /* + * Restore our stack and saved registers. + * Now we can safely execute C code again. + */ + + asm volatile("mov %0, %%esp" ::"m" (BIOS_SHARED->esp)); + asm volatile ("popa"); + + /* + * Return here. The rest of this code is never run directly, + * but we need to prevent GCC from optimizing it out. + */ + asm volatile("jmp BIOSTrampolineEnd\n"); + + /* + * This is a 16-bit assembly-language trampoline, relocated at + * runtime to low memory, which actually makes the BIOS call. It + * handles saving/restoring registers, and it switches in and out + * of real mode. + * + * This code is never run directly. + */ + + asm volatile("BIOSTrampoline: .code16"); + + /* + * Switch to our 16-bit data segment. + */ + asm volatile("movw %0, %%ax \n" + "movw %%ax, %%ds \n" + "movw %%ax, %%es \n" + "movw %%ax, %%ss \n" + :: "i" (BOOT_DATA16_SEG)); + + /* + * Disable protected mode. + */ + asm volatile("movl %cr0, %eax \n" + "andl $(~1), %eax \n" + "movl %eax, %cr0 \n"); + + /* + * Do another long jump to reset the real-mode %cs + * register to a valid paragraph number. Right now + * it's still a protected-mode-style selector index. + * + * XXX: I'm not sure how to do this address calculation cleanly. + * Currently I'm hardcoding the address of the relocated trampoline. + */ + asm volatile("ljmp $0, $(BIOSTrampolineCS16 - BIOSTrampoline + 0x7C00)\n" + "BIOSTrampolineCS16: \n"); + + /* + * Set up the real-mode stack and %cs register. + */ + asm volatile("xorw %%ax, %%ax \n" + "mov %%ax, %%ss \n" + "mov %0, %%esp \n" + :: "i" (&BIOS_SHARED->stackTop[-sizeof(Regs)])); + + /* + * Pop Regs off the stack. + */ + asm volatile("pop %ds \n" + "pop %es \n" + "pop %eax \n" // Ignore EFLAGS value. + "popal \n"); + + /* + * This interrupt instruction is a placeholder that gets + * patched at runtime (after relocation) to point to the + * right interrupt vector. + */ + asm volatile("BIOSTrampolineVector: \n" + "int $0xFF"); + + /* + * Push Regs back onto the stack. + */ + asm volatile("pushal \n" + "pushfl \n" + "push %es \n" + "push %ds \n"); + + /* + * Enable protected mode. + */ + asm volatile("movl %cr0, %eax \n" + "orl $1, %eax \n" + "movl %eax, %cr0 \n"); + + /* + * Return via a long 16-to-32 bit jump. + */ + asm volatile("data32 ljmp %0, $BIOSReturn32 \n" + :: "i" (BOOT_CODE_SEG)); + + asm volatile("BIOSTrampolineEnd: .code32 \n"); +} + +extern struct { + uint16 limit; + uint32 base; +} PACKED IDTDesc; + +/* + * BIOS_Call -- + * + * Make BIOS calls after boot, by temporarily switching + * back into real mode. + * + * This function relocates the trampoline and stack into + * real-mode-addressable low memory, then makes a 32-to-16-bit jump + * into the trampoline. + */ + +fastcall void +BIOS_Call(uint8 vector, Regs *regs) +{ + extern uint8 BIOSTrampoline[]; + extern uint8 BIOSTrampolineVector[]; + extern uint8 BIOSTrampolineEnd[]; + const uint32 trampSize = (uint8*)BIOSTrampolineEnd - (uint8*)BIOSTrampoline; + const uint32 vectorOffset = (uint8*)BIOSTrampolineVector - (uint8*)BIOSTrampoline + 1; + + Bool iFlag = Intr_Save(); + Intr_Disable(); + + /* + * Relocate the trampoline code itself. + */ + memcpy(BIOS_SHARED->trampoline, BIOSTrampoline, trampSize); + + /* + * Save the 32-bit IDT descriptor, and set up a legacy 256-entry + * 16-bit IDT descriptor. + */ + asm volatile("sidt %0" : "=m" (BIOS_SHARED->idtr32)); + BIOS_SHARED->idtr16.base = 0; + BIOS_SHARED->idtr16.limit = 0x3ff; + asm volatile("lidt %0" :: "m" (BIOS_SHARED->idtr16)); + + /* + * Binary-patch the trampoline code with the right interrupt vector. + */ + BIOS_SHARED->trampoline[vectorOffset] = vector; + + /* + * Copy Regs onto the top of the 16-bit stack. + */ + memcpy(&BIOS_SHARED->stackTop[-sizeof *regs], regs, sizeof *regs); + + BIOSCallInternal(); + + /* Copy Regs back */ + memcpy(regs, &BIOS_SHARED->stackTop[-sizeof *regs], sizeof *regs); + + /* + * Back to 32-bit IDT. + */ + asm volatile("lidt %0" :: "m" (BIOS_SHARED->idtr32)); + + Intr_Restore(iFlag); +} diff --git a/lib/metalkit/bios.h b/lib/metalkit/bios.h new file mode 100644 index 0000000..27f6fb8 --- /dev/null +++ b/lib/metalkit/bios.h @@ -0,0 +1,176 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * bios.h - Make real-mode BIOS calls from protected mode. + * For simplicity and small size, this implementation + * switches back to real-mode rather than using virtual 8086 + * mode. A v86 mode implementation may be more robust. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __BIOS_H__ +#define __BIOS_H__ + +#include "types.h" +#include "boot.h" + +typedef struct Regs { + /* + * Subset of segment registers + */ + + uint16 ds; + uint16 es; + + /* + * CPU flags (Saved on BIOS exit, ignored on entry) + */ + + union { + uint16 flags; + uint32 eflags; + struct { + uint32 cf : 1; + uint32 reserved_0 : 1; + uint32 pf : 1; + uint32 reserved_1 : 1; + uint32 af : 1; + uint32 reserved_2 : 1; + uint32 zf : 1; + uint32 sf : 1; + uint32 tp : 1; + uint32 intf : 1; + uint32 df : 1; + uint32 of : 1; + uint32 iopl : 2; + uint32 nt : 1; + uint32 reserved_3 : 1; + uint32 rf : 1; + uint32 vm : 1; + uint32 vif : 1; + uint32 vip : 1; + uint32 id : 1; + uint32 reserved_4 : 10; + }; + }; + + /* + * General purpose 32-bit registers, in the order expected by + * pushad/popad. Note that while most BIOS routines need only the + * 16-bit portions of these registers, some 32-bit-aware routines + * use them even in real mode. + */ + + union { + uint32 edi; + uint16 di; + }; + union { + uint32 esi; + uint16 si; + }; + union { + uint32 ebp; + uint16 bp; + }; + union { // Saved on BIOS exit, ignored on entry + uint32 esp; + uint16 sp; + }; + + union { + uint32 ebx; + uint16 bx; + struct { + uint8 bl; + uint8 bh; + }; + }; + union { + uint32 edx; + uint16 dx; + struct { + uint8 dl; + uint8 dh; + }; + }; + union { + uint32 ecx; + uint16 cx; + struct { + uint8 cl; + uint8 ch; + }; + }; + union { + uint32 eax; + uint16 ax; + struct { + uint8 al; + uint8 ah; + }; + }; +} PACKED Regs; + +/* + * This is the communication area between the real-mode BIOS + * and protected mode. Parts of it are used internally by this + * module, but the 'userdata' area is available to the caller. + */ + +struct BIOSShared { + uint8 trampoline[512]; + uint8 stack[4096]; + uint8 stackTop[0]; + uint32 esp; + struct { + uint16 limit; + uint32 base; + } PACKED idtr16, idtr32; + uint8 userdata[1024]; +} PACKED; + +#define BIOS_SHARED ((struct BIOSShared*) BOOT_REALMODE_SCRATCH) + +/* + * Macros for converting between 32-bit and 16-bit near/far pointers. + */ + +typedef uint32 far_ptr_t; + +#define PTR_32_TO_NEAR(p, seg) ((uint16)((uint32)(p) - ((seg) << 4))) +#define PTR_NEAR_TO_32(seg, off) ((void*)((((uint32)(seg)) << 4) + ((uint32)(off)))) +#define PTR_FAR_TO_32(p) PTR_NEAR_TO_32(p >> 16, p & 0xFFFF) + +/* + * Public entry point. + */ + +fastcall void BIOS_Call(uint8 vector, Regs *regs); + +#endif /* __BIOS_H__ */ diff --git a/lib/metalkit/boot.S b/lib/metalkit/boot.S new file mode 100644 index 0000000..f431180 --- /dev/null +++ b/lib/metalkit/boot.S @@ -0,0 +1,586 @@ +/* + * boot.S -- + * + * This is a tiny but relatively featureful bootloader for + * 32-bit standalone apps and kernels. It compiles into one + * binary that can be used either stand-alone (loaded directly + * by the BIOS, from a floppy or USB disk image) or as a GNU + * Multiboot image, loaded by GRUB. + * + * This bootloader loads itself and the attached main program + * at 1MB, with the available portions of the first megabyte of + * RAM set up as stack space by default. + * + * This loader is capable of loading an arbitrarily big binary + * image from the boot device into high memory. If you're booting + * from a floppy, it can load the whole 1.44MB disk. If you're + * booting from USB, it can load any amount of data from the USB + * disk. + * + * This loader works by using the BIOS's disk services, so we + * should be able to read the whole binary image off of any device + * the BIOS knows how to boot from. Since we have only a tiny + * amount of buffer space, and we need to store the resulting image + * above the 1MB boundary, we have to keep switching back and forth + * between real mode and protected mode. + * + * To avoid device-specific CHS addressing madness, we require LBA + * mode to boot off of anything other than a 1.44MB floppy or a + * Multiboot loader. We try to use the INT 13h AH=42h "Extended Read + * Sectors From Drive" command, which uses LBA addressing. If this + * doesn't work, we fall back to floppy-disk-style CHS addressing. + * + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#define ASM +#include "boot.h" + +/* + * Constants that affect our early boot memory map. + */ +#define BIOS_START_ADDRESS 0x7C00 // Defined by the BIOS +#define EARLY_STACK_ADDRESS 0x2000 // In low DOS memory +#define SECTORS_AT_A_TIME 18 // Must equal CHS sectors per head +#define SECTOR_SIZE 512 +#define DISK_BUFFER 0x2800 +#define DISK_BUFFER_SIZE (SECTORS_AT_A_TIME * SECTOR_SIZE) + +#define BIOS_PTR(x) (x - _start + BIOS_START_ADDRESS) + + .section .boot + + .global _start + + /* + * External symbols. main() is self-explanatory, but these + * other symbols must be provided by the linker script. See + * "image.ld" for the actual partition size and LDT calculations. + */ + .extern main + .extern _end + .extern _edata + .extern _bss_size + .extern _stack + .extern _partition_chs_head + .extern _partition_chs_sector_byte + .extern _partition_chs_cylinder_byte + .extern _partition_blocks + .extern _ldt_byte0 + .extern _ldt_byte1 + .extern _ldt_byte2 + .extern _ldt_byte3 + + /* + * Other modules can optionally define an LDT in uninitialized + * memory. By default this LDT will be all zeroes, but this + * is a simple and code-size-efficient way of letting other + * Metalkit modules allocate segment descriptors when they + * need to. + * + * Note that we page-align the LDT. This isn't strictly + * necessary, but it might be useful for performance in + * some environments. + */ + .comm LDT, BOOT_LDT_SIZE, 4096 + + /* + * This begins our 16-bit DOS MBR boot sector segment. This + * sits in the first 512 bytes of our floppy image, and it + * gets loaded by the BIOS at START_ADDRESS. + * + * Until we've loaded the memory image off of disk into + * its final location, this code is running at a different + * address than the linker is expecting. Any absolute + * addresses must be fixed up by the BIOS_PTR() macro. + */ + + .code16 +_start: + ljmp $0, $BIOS_PTR(bios_main) + + + /* + * gnu_multiboot -- + * + * GNU Multiboot header. This can come anywhere in the + * first 8192 bytes of the image file. + */ + + .p2align 2 + .code32 +gnu_multiboot: + +#define MULTIBOOT_MAGIC 0x1BADB002 +#define MULTIBOOT_FLAGS 0x00010000 + + .long MULTIBOOT_MAGIC + .long MULTIBOOT_FLAGS + .long -(MULTIBOOT_MAGIC + MULTIBOOT_FLAGS) + .long gnu_multiboot + .long _start + .long _edata + .long _end + .long entry32 + + + /* + * String table, located in the boot sector. + */ + +loading_str: .string "\r\nMETALKIT " +disk_error_str: .string " err!" + + /* + * bios_main -- + * + * Main routine for our BIOS MBR based loader. We set up the + * stack, display some welcome text, then load the rest of + * the boot image from disk. We have to use real mode to + * call the BIOS's floppy driver, then protected mode to + * copy each disk block to its final location above the 1MB + * barrier. + */ + + .code16 +bios_main: + + /* + * Early init: setup our stack and data segments, make sure + * interrupts are off. + */ + cli + xorw %ax, %ax + movw %ax, %ss + movw %ax, %ds + movw %ax, %es + movw $EARLY_STACK_ADDRESS, %sp + + /* + * Save parameters that the BIOS gave us via registers. + */ + mov %dl, BIOS_PTR(disk_drive) + + /* + * Switch on the A20 gate, so we can access more than 1MB + * of memory. There are multiple ways to do this: The + * original way was to write to bit 1 of the keyboard + * controller's output port. There's also a bit on PS2 + * System Control port A to enable A20. + * + * The keyboard controller method should always work, but + * it's kind of slow and it takes a lot of code space in + * our already-cramped bootloader. Instead, we ask the BIOS + * to enable A20. + * + * If your computer doesn't support this BIOS interface, + * you'll see our "err!" message before "METAL" appears. + * + * References: + * http://www.win.tue.nl/~aeb/linux/kbd/A20.html + */ + + mov $0x2401, %ax // Enable A20 + int $0x15 + jc fatal_error + + /* + * Load our image, starting at the beginning of whatever disk + * the BIOS told us we booted from. The Disk Address Packet + * (DAP) has already been initialized statically. + */ + + mov $BIOS_PTR(loading_str), %si + call print_str + + /* + * Fill our DISK_BUFFER, reading SECTORS_AT_A_TIME sectors. + * + * First, try to use LBA addressing. This is required in + * order to boot off of non-floppy devices, like USB drives. + */ + +disk_copy_loop: + mov $0x42, %ah + mov BIOS_PTR(disk_drive), %dl + mov $BIOS_PTR(dap_buffer), %si + int $0x13 + jnc disk_success + + /* + * If LBA fails, fall back to old fashioned CHS addressing. + * This works everywhere, but only if we're on a 1.44MB floppy. + */ + + mov $(0x0200 | SECTORS_AT_A_TIME), %ax + mov BIOS_PTR(chs_sector), %cx // Sector and cylinder + mov BIOS_PTR(disk_drive), %dx // Drive and head + mov $DISK_BUFFER, %bx + int $0x13 + jnc disk_success + + /* + * If both CHS and LBA fail, the error is fatal. + */ + +fatal_error: + mov $BIOS_PTR(disk_error_str), %si + call print_str + cli + hlt + +disk_success: + mov $'.', %al + call print_char + + /* + * Enter protected mode, so we can copy this sector to + * memory above the 1MB boundary. + * + * Note that we reset CS, DS, and ES, but we don't + * modify the stack at all. + */ + + cli + lgdt BIOS_PTR(bios_gdt_desc) + movl %cr0, %eax + orl $1, %eax + movl %eax, %cr0 + ljmp $BOOT_CODE_SEG, $BIOS_PTR(copy_enter32) + .code32 +copy_enter32: + movw $BOOT_DATA_SEG, %ax + movw %ax, %ds + movw %ax, %es + + /* + * Copy the buffer to high memory. + */ + + mov $DISK_BUFFER, %esi + mov BIOS_PTR(dest_address), %edi + mov $(DISK_BUFFER_SIZE / 4), %ecx + rep movsl + + /* + * Next... + * + * Even though the CHS and LBA addresses are mutually exclusive, + * there's no harm in incrementing them both. The LBA increment + * is pretty straightforward, but CHS is of course less so. + * We only support CHS on 1.44MB floppies. We always copy one + * head at a time (SECTORS_AT_A_TIME must equal 18), so we have + * to hop between disk head 0 and 1, and increment the cylinder + * on every other head. + * + * When we're done copying, branch to entry32 while we're + * still in protected mode. Also note that we do a long branch + * to its final address, not it's temporary BIOS_PTR() address. + */ + + addl $DISK_BUFFER_SIZE, BIOS_PTR(dest_address) + addl $SECTORS_AT_A_TIME, BIOS_PTR(dap_sector) + + xorb $1, BIOS_PTR(chs_head) + jnz same_cylinder + incb BIOS_PTR(chs_cylinder) +same_cylinder: + + cmpl $_edata, BIOS_PTR(dest_address) + jl not_done_copying + ljmp $BOOT_CODE_SEG, $entry32 +not_done_copying: + + /* + * Back to 16-bit mode for the next copy. + * + * To understand this code, it's important to know the difference + * between how segment registers are treated in protected-mode and + * in real-mode. Loading a segment register in PM is actually a + * request for the processor to fill the hidden portion of that + * segment register with data from the GDT. When we switch to + * real-mode, the segment registers change meaning (now they're + * paragraph offsets again) but that hidden portion of the + * register remains set. + */ + + /* 1. Load protected-mode segment registers (CS, DS, ES) */ + + movw $BOOT_DATA16_SEG, %ax + movw %ax, %ds + movw %ax, %es + ljmp $BOOT_CODE16_SEG, $BIOS_PTR(copy_enter16) + + /* (We're entering a 16-bit code segment now) */ + .code16 +copy_enter16: + + /* 2. Disable protected mode */ + + movl %cr0, %eax + andl $(~1), %eax + movl %eax, %cr0 + + /* + * 3. Load real-mode segment registers. (CS, DS, ES) + */ + + xorw %ax, %ax + movw %ax, %ds + movw %ax, %es + ljmp $0, $BIOS_PTR(disk_copy_loop) + + + /* + * print_char -- + * + * Use the BIOS's TTY emulation to output one character, from %al. + */ + + .code16 +print_char: + mov $0x0E, %ah + mov $0x0001, %bx + int $0x10 +ret_label: + ret + + /* + * print_str -- + * + * Print a NUL-terminated string, starting at %si. + */ + + .code16 +print_str: + lodsb + test %al, %al + jz ret_label + call print_char + jmp print_str + + + /* + * entry32 -- + * + * Main 32-bit entry point. To be here, we require that: + * + * - We're running in protected mode + * - The A20 gate is enabled + * - The entire image is loaded at _start + * + * We jump directly here from GNU Multiboot loaders (like + * GRUB), and this is where we jump directly from our + * protected mode disk block copy routine after we've copied + * the lask block. + * + * We still need to set up our final stack and GDT. + */ + + .code32 +entry32: + + cli + + lgdt boot_gdt_desc + movl %cr0, %eax + orl $1, %eax + movl %eax, %cr0 + ljmp $BOOT_CODE_SEG, $entry32_gdt_done +entry32_gdt_done: + + movw $BOOT_DATA_SEG, %ax + movw %ax, %ds + movw %ax, %ss + movw %ax, %es + movw %ax, %fs + movw %ax, %gs + mov $_stack, %esp + + /* + * Zero out the BSS segment. + */ + + xor %eax, %eax + mov $_bss_size, %ecx + mov $_edata, %edi + rep stosb + + /* + * Set our LDT segment as the current LDT. + */ + mov $BOOT_LDT_SEG, %ax + lldt %ax + + /* + * Call main(). + * + * If it returns, put the machine in a halt loop. We don't + * disable interrupts: if the main program is in fact done + * with, but the application is still doing useful work in its + * interrupt handlers, no reason to stop them. + */ + + call main +halt_loop: + hlt + jmp halt_loop + + /* + * boot_gdt -- + * + * This is a Global Descriptor Table that gives us a + * code and data segment, with a flat memory model. + * + * See section 3.4.5 of the Intel IA32 software developer's manual. + */ + + .code32 + .p2align 3 +boot_gdt: + + /* + * This is BOOT_NULL_SEG, the unusable segment zero. + * Reuse this memory as bios_gdt_desc, a GDT descriptor + * which uses our pre-relocation (BIOS_PTR) GDT address. + */ +bios_gdt_desc: + .word (boot_gdt_end - boot_gdt - 1) + .long BIOS_PTR(boot_gdt) + .word 0 // Unused + + .word 0xFFFF, 0x0000 // BOOT_CODE_SEG + .byte 0x00, 0x9A, 0xCF, 0x00 + + .word 0xFFFF, 0x0000 // BOOT_DATA_SEG + .byte 0x00, 0x92, 0xCF, 0x00 + + .word 0xFFFF, 0x0000 // BOOT_CODE16_SEG + .byte 0x00, 0x9A, 0x00, 0x00 + + .word 0xFFFF, 0x0000 // BOOT_DATA16_SEG + .byte 0x00, 0x92, 0x00, 0x00 + + .word 0xFFFF // BOOT_LDT_SEG + .byte _ldt_byte0 + .byte _ldt_byte1 + .byte _ldt_byte2 + .byte 0x82, 0x40 + .byte _ldt_byte3 +boot_gdt_end: + +boot_gdt_desc: // Uses final address + .word (boot_gdt_end - boot_gdt - 1) + .long boot_gdt + + + /* + * dap_buffer -- + * + * The Disk Address Packet buffer holds the current LBA + * disk address. We pass this to BIOS INT 13h, and we + * statically initialize it here. + * + * Note that the DAP is only used in LBA mode, not CHS mode. + * + * References: + * http://en.wikipedia.org/wiki/INT_13 + * #INT_13h_AH.3D42h:_Extended_Read_Sectors_From_Drive + */ + +dap_buffer: + .byte 0x10 // DAP structure size + .byte 0x00 // (Unused) + .byte SECTORS_AT_A_TIME // Number of sectors to read + .byte 0x00 // (Unused) + .word DISK_BUFFER // Buffer offset + .word 0x00 // Buffer segment +dap_sector: + .long 0x00000000 // Disk sector number + .long 0x00000000 + + /* + * Statically initialized disk addressing variables. The CHS + * address here is only used in CHS mode, not LBA mode, but + * the disk drive number and dest address are always used. + */ +chs_sector: // Order matters. Cylinder/sector and head/drive + .byte 0x01 // are packed into words together. +chs_cylinder: + .byte 0x00 +disk_drive: + .byte 0x00 +chs_head: + .byte 0x00 +dest_address: + .long _start // Initial dest address for 16-to-32-bit copy. + + + /* + * Partition table and Boot Signature -- + * + * This must be at the end of the first 512-byte disk + * sector. The partition table marks the end of the + * portion of this binary which is loaded by the BIOS. + * + * Each partition record is 16 bytes. + * + * After installing Metalkit, a disk can be partitioned as + * long as the space used by the Metalkit binary itself is + * reserved. By default, we create a single "Non-FS data" + * partition which holds the Metalkit binary. Note that + * this default partition starts at sector 1 (the first + * sector) so it covers the entire Metalkit image including + * bootloader. + * + * Partitions 2 through 4 are unused, and must be all zero + * or fdisk will complain. + * + * References: + * http://en.wikipedia.org/wiki/Master_boot_record + */ + + .org 0x1BE // Partition 1 +boot_partition_table: + .byte 0x80 // Status (Bootable) + .byte 0x00 // First block (head, sector/cylinder, cylinder) + .byte 0x01 + .byte 0x00 + .byte 0xda // Partition type ("Non-FS data" in fdisk) + .byte _partition_chs_head // Last block (head, sector/cylinder, cylinder) + .byte _partition_chs_sector_byte + .byte _partition_chs_cylinder_byte + .long 0 // LBA of first sector + .long _partition_blocks // Number of blocks in partition + + .org 0x1CE // Partition 2 (Unused) + .org 0x1DE // Partition 3 (Unused) + .org 0x1EE // Partition 4 (Unused) + .org 0x1FE // Boot signature + .byte 0x55, 0xAA // This marks the end of the 512-byte MBR. diff --git a/lib/metalkit/boot.h b/lib/metalkit/boot.h new file mode 100644 index 0000000..d815f03 --- /dev/null +++ b/lib/metalkit/boot.h @@ -0,0 +1,59 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * boot.h - Definitions used by both the bootloader and + * the rest of the library. This file must be valid + * C and assembly. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __BOOT_H__ +#define __BOOT_H__ + +#define BOOT_NULL_SEG 0x00 +#define BOOT_CODE_SEG 0x08 +#define BOOT_DATA_SEG 0x10 +#define BOOT_CODE16_SEG 0x18 +#define BOOT_DATA16_SEG 0x20 +#define BOOT_LDT_SEG 0x28 + +#define BOOT_LDT_ENTRIES 1024 +#define BOOT_LDT_SIZE (BOOT_LDT_ENTRIES * 8) + +/* Unused real-mode-accessable scratch memory. */ +#define BOOT_REALMODE_SCRATCH 0x7C00 + +/* + * The bootloader defines an LDT table which can be modified + * by C code, for loading segments dynamically. + */ +#ifndef ASM +extern unsigned char LDT[BOOT_LDT_SIZE]; +#endif + +#endif /* __BOOT_H__ */ diff --git a/lib/metalkit/console.c b/lib/metalkit/console.c new file mode 100644 index 0000000..1c2857c --- /dev/null +++ b/lib/metalkit/console.c @@ -0,0 +1,291 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * console.c - Abstract text console + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#include "types.h" +#include "console.h" +#include "intr.h" + +ConsoleInterface gConsole; + + +/* + * Console_WriteString -- + * + * Write a NUL-terminated string. + */ + +fastcall void +Console_WriteString(const char *str) +{ + char c; + while ((c = *(str++))) { + Console_WriteChar(c); + } +} + + +/* + * Console_WriteUInt32 -- + * + * Write a positive 32-bit integer with arbitrary base from 2 to + * 16, up to 'digits' characters long. If 'padding' is non-NUL, + * this character is used for leading digits that would be zero. + * If padding is NUL, leading digits are suppressed entierly. + */ + +fastcall void +Console_WriteUInt32(uint32 num, int digits, char padding, int base, Bool suppressZero) +{ + if (digits == 0) { + return; + } + + Console_WriteUInt32(num / base, digits - 1, padding, base, TRUE); + + if (num == 0 && suppressZero) { + if (padding) { + Console_WriteChar(padding); + } + } else { + uint8 digit = num % base; + Console_WriteChar(digit >= 10 ? digit - 10 + 'A' : digit + '0'); + } +} + + +/* + * Console_Format -- + * Console_FormatV -- + * + * Write a formatted string. This is for the most part a tiny + * subset of printf(). Supports the standard %c, %s, %d, %u, + * and %X specifiers. + * + * Deviates from a standard printf() in a few ways, in the interest + * of low-level utility and small code size: + * + * - Adds a nonstandard %b specifier, for binary numbers. + * - Width specifiers set an exact width, not a minimum width. + * - %x is treated as %X. + */ + +void +Console_Format(const char *fmt, ...) +{ + Console_FormatV(&fmt); +} + +fastcall void +Console_FormatV(const char **args) +{ + char c; + const char *fmt = *(args++); + + while ((c = *(fmt++))) { + int width = 0; + Bool isSigned = FALSE; + char padding = '\0'; + + if (c != '%') { + Console_WriteChar(c); + continue; + } + + while ((c = *(fmt++))) { + if (c == '0' && width == 0) { + /* If we get a leading 0 in the width specifier, turn on zero-padding */ + padding = '0'; + continue; + } + if (c >= '0' && c <= '9') { + /* Add another digit to the width specifier */ + width = (width * 10) + (c - '0'); + if (padding == '\0') { + padding = ' '; + } + continue; + } + + /* + * Any other character means the width specifier has + * ended. If it's still zero, set the defaults. + */ + if (width == 0) { + width = 32; + } + + /* + * Non-integer format specifiers + */ + + if (c == 's') { + Console_WriteString((char*) *(args++)); + break; + } + if (c == 'c') { + Console_WriteChar((char)(uint32) *(args++)); + break; + } + + /* + * Integers of different bases + */ + int base = 0; + + if (c == 'X' || c == 'x') { + base = 16; + } else if (c == 'd') { + base = 10; + isSigned = TRUE; + } else if (c == 'u') { + base = 10; + } else if (c == 'b') { + base = 2; + } + + if (base) { + uint32 value = (uint32)*(args++); + + /* + * Print the sign for negative numbers. + */ + if (isSigned && 0 > (int32)value) { + Console_WriteChar('-'); + width--; + value = -value; + } + + Console_WriteUInt32(value, width, padding, base, FALSE); + break; + } + + /* Unrecognized */ + Console_WriteChar(c); + break; + } + } +} + + +/* + * Console_HexDump -- + * + * Write a 32-bit hex dump to the console, labelling each + * line with addresses starting at 'startAddr'. + */ + +fastcall void +Console_HexDump(uint32 *data, uint32 startAddr, uint32 numWords) +{ + while (numWords) { + int32 lineWords = 4; + Console_Format("%08x:", startAddr); + while (numWords && lineWords) { + Console_Format(" %08x", *data); + data++; + startAddr += 4; + numWords--; + lineWords--; + } + Console_WriteChar('\n'); + } +} + + +/* + * Console_UnhandledFault -- + * + * Display a fatal error message with register and stack trace when + * an unhandled fault occurs. This fault handler must be installed + * using the Intr module. + */ + +void +Console_UnhandledFault(int vector) +{ + IntrContext *ctx = Intr_GetContext(vector); + + /* + * Using a regular inline string constant, the linker can't + * optimize out this string when the function isn't used. + */ + static const char faultFmt[] = + "Fatal error:\n" + "Unhandled fault %d at %04x:%08x\n" + "\n" + "eax=%08x ebx=%08x ecx=%08x edx=%08x\n" + "esi=%08x edi=%08x esp=%08x ebp=%08x\n" + "eflags=%032b\n" + "\n"; + + Console_BeginPanic(); + + /* + * IntrContext's stack pointer includes the three values that were + * pushed by the hardware interrupt. Advance past these, so the + * stack trace shows the state of execution at the time of the + * fault rather than at the time our interrupt trampoline was + * invoked. + */ + ctx->esp += 3 * sizeof(int); + + Console_Format(faultFmt, + vector, ctx->cs, ctx->eip, + ctx->eax, ctx->ebx, ctx->ecx, ctx->edx, + ctx->esi, ctx->edi, ctx->esp, ctx->ebp, + ctx->eflags); + + Console_HexDump((void*)ctx->esp, ctx->esp, 64); + + Console_Flush(); + Intr_Disable(); + Intr_Halt(); +} + + +/* + * Console_Panic -- + * + * Default panic handler. Prints a caller-defined message, and + * halts the machine. + */ + +void +Console_Panic(const char *fmt, ...) +{ + Console_BeginPanic(); + Console_WriteString("Panic:\n"); + Console_FormatV(&fmt); + Console_Flush(); + Intr_Disable(); + Intr_Halt(); +} diff --git a/lib/metalkit/console.h b/lib/metalkit/console.h new file mode 100644 index 0000000..a0292c1 --- /dev/null +++ b/lib/metalkit/console.h @@ -0,0 +1,63 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * console.h - Abstract text console + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __CONSOLE_H__ +#define __CONSOLE_H__ + +#include "types.h" + +typedef struct { + fastcall void (*beginPanic)(void); // Initialize the console for a Panic message + fastcall void (*clear)(void); // Clear the screen, home the cursor + fastcall void (*moveTo)(int x, int y); // Move the cursor + fastcall void (*writeChar)(char c); // Write one character, with support for control codes + fastcall void (*flush)(void); // Finish writing a string of characters +} ConsoleInterface; + +extern ConsoleInterface gConsole; + +#define Console_BeginPanic() gConsole.beginPanic() +#define Console_Clear() gConsole.clear() +#define Console_MoveTo(x, y) gConsole.moveTo(x, y) +#define Console_WriteChar(c) gConsole.writeChar(c) +#define Console_Flush() gConsole.flush() + +fastcall void Console_WriteString(const char *str); +fastcall void Console_WriteUInt32(uint32 num, int digits, char padding, int base, Bool suppressZero); +fastcall void Console_FormatV(const char **args); +fastcall void Console_HexDump(uint32 *data, uint32 startAddr, uint32 numWords); + +void Console_Format(const char *fmt, ...); +void Console_Panic(const char *str, ...); +void Console_UnhandledFault(int number); + +#endif /* __CONSOLE_H__ */ diff --git a/lib/metalkit/console_vga.c b/lib/metalkit/console_vga.c new file mode 100644 index 0000000..c461903 --- /dev/null +++ b/lib/metalkit/console_vga.c @@ -0,0 +1,269 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * console_vga.c - Console driver for VGA text mode. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#include "types.h" +#include "console_vga.h" +#include "io.h" +#include "intr.h" + +#define VGA_TEXT_FRAMEBUFFER ((uint8*)0xB8000) + +#define VGA_CRTCREG_CURSOR_LOC_HIGH 0x0E +#define VGA_CRTCREG_CURSOR_LOC_LOW 0x0F + +typedef struct { + uint16 crtc_iobase; + struct { + int8 x, y; + } cursor; + int8 attr; +} ConsoleVGAObject; + +ConsoleVGAObject gConsoleVGA[1]; + + +/* + * ConsoleVGAWriteCRTC -- + * + * Write to a VGA CRT Control register. + */ + +static fastcall void +ConsoleVGAWriteCRTC(uint8 addr, uint8 value) +{ + ConsoleVGAObject *self = gConsoleVGA; + IO_Out8(self->crtc_iobase, addr); + IO_Out8(self->crtc_iobase + 1, value); +} + + +/* + * ConsoleVGAMoveHardwareCursor -- + * + * Set the hardware cursor to the current cursor position. + */ + +static fastcall void +ConsoleVGAMoveHardwareCursor(void) +{ + ConsoleVGAObject *self = gConsoleVGA; + uint16 loc = self->cursor.x + self->cursor.y * VGA_TEXT_WIDTH; + + ConsoleVGAWriteCRTC(VGA_CRTCREG_CURSOR_LOC_LOW, loc & 0xFF); + ConsoleVGAWriteCRTC(VGA_CRTCREG_CURSOR_LOC_HIGH, loc >> 8); +} + + +/* + * ConsoleVGAMoveTo -- + * + * Set the text insertion point. This will move the hardware cursor + * at the next Console_Flush(). + */ + +static fastcall void +ConsoleVGAMoveTo(int x, int y) +{ + ConsoleVGAObject *self = gConsoleVGA; + + self->cursor.x = x; + self->cursor.y = y; +} + + +/* + * ConsoleVGA_Clear -- + * + * Clear the screen and move the cursor to the home position. + */ + +static fastcall void +ConsoleVGAClear(void) +{ + ConsoleVGAObject *self = gConsoleVGA; + uint8 *fb = VGA_TEXT_FRAMEBUFFER; + int i, j; + + ConsoleVGAMoveTo(0, 0); + + for (j = 0; j < VGA_TEXT_HEIGHT; j++) { + for (i = 0; i < VGA_TEXT_WIDTH; i++) { + fb[0] = ' '; + fb[1] = self->attr; + fb += 2; + } + } +} + + +/* + * ConsoleVGA_SetColor -- + * + * Set the text foreground color. + */ + +fastcall void +ConsoleVGA_SetColor(int8 fgColor) +{ + ConsoleVGAObject *self = gConsoleVGA; + + self->attr &= 0xF0; + self->attr |= fgColor; +} + + +/* + * ConsoleVGA_SetColor -- + * + * Set the text background color. + */ + +fastcall void +ConsoleVGA_SetBgColor(int8 bgColor) +{ + ConsoleVGAObject *self = gConsoleVGA; + + self->attr &= 0x0F; + self->attr |= bgColor << 4; +} + + +/* + * ConsoleVGAWriteChar -- + * + * Write one character, TTY-style. Interprets \n characters. + */ + +static fastcall void +ConsoleVGAWriteChar(char c) +{ + ConsoleVGAObject *self = gConsoleVGA; + uint8 *fb = VGA_TEXT_FRAMEBUFFER; + + if (c == '\n') { + self->cursor.y++; + self->cursor.x = 0; + + } else if (c == '\t') { + while (self->cursor.x & 7) { + ConsoleVGAWriteChar(' '); + } + + } else if (c == '\b') { + if (self->cursor.x > 0) { + self->cursor.x--; + ConsoleVGAWriteChar(' '); + self->cursor.x--; + } + + } else { + fb += self->cursor.x * 2 + self->cursor.y * VGA_TEXT_WIDTH * 2; + fb[0] = c; + fb[1] = self->attr; + self->cursor.x++; + } + + if (self->cursor.x >= VGA_TEXT_WIDTH) { + self->cursor.x = 0; + self->cursor.y++; + } + + if (self->cursor.y >= VGA_TEXT_HEIGHT) { + int i; + uint8 *fb = VGA_TEXT_FRAMEBUFFER; + const uint32 scrollSize = VGA_TEXT_WIDTH * 2 * (VGA_TEXT_HEIGHT - 1); + + self->cursor.y = VGA_TEXT_HEIGHT - 1; + + memcpy(fb, fb + VGA_TEXT_WIDTH * 2, scrollSize); + fb += scrollSize; + for (i = 0; i < VGA_TEXT_WIDTH; i++) { + fb[0] = ' '; + fb[1] = self->attr; + fb += 2; + } + } +} + + +/* + * ConsoleVGABeginPanic -- + * + * Prepare for a panic in VGA mode: Set up the panic colors, + * and clear the screen. + */ + +static fastcall void +ConsoleVGABeginPanic(void) +{ + ConsoleVGA_SetColor(VGA_COLOR_WHITE); + ConsoleVGA_SetBgColor(VGA_COLOR_RED); + ConsoleVGAClear(); + ConsoleVGAMoveHardwareCursor(); +} + + +/* + * ConsoleVGA_Init -- + * + * Perform first-time initialization for VGA text mode, + * set VGA as the current console driver, and clear the + * screen with a default color. + */ + +fastcall void +ConsoleVGA_Init(void) +{ + ConsoleVGAObject *self = gConsoleVGA; + + /* + * Read the I/O address select bit, to determine where the CRTC + * registers are. + */ + if (IO_In8(0x3CC) & 1) { + self->crtc_iobase = 0x3D4; + } else { + self->crtc_iobase = 0x3B4; + } + + gConsole.beginPanic = ConsoleVGABeginPanic; + gConsole.clear = ConsoleVGAClear; + gConsole.moveTo = ConsoleVGAMoveTo; + gConsole.writeChar = ConsoleVGAWriteChar; + gConsole.flush = ConsoleVGAMoveHardwareCursor; + + ConsoleVGA_SetColor(VGA_COLOR_WHITE); + ConsoleVGA_SetBgColor(VGA_COLOR_BLUE); + + ConsoleVGAClear(); + ConsoleVGAMoveHardwareCursor(); +} diff --git a/lib/metalkit/console_vga.h b/lib/metalkit/console_vga.h new file mode 100644 index 0000000..b7fca0c --- /dev/null +++ b/lib/metalkit/console_vga.h @@ -0,0 +1,63 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * console_vga.h - Console driver for VGA text mode. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __CONSOLE_VGA_H__ +#define __CONSOLE_VGA_H__ + +#include "types.h" +#include "console.h" + +#define VGA_COLOR_BLACK 0 +#define VGA_COLOR_BLUE 1 +#define VGA_COLOR_GREEN 2 +#define VGA_COLOR_CYAN 3 +#define VGA_COLOR_RED 4 +#define VGA_COLOR_MAGENTA 5 +#define VGA_COLOR_BROWN 6 +#define VGA_COLOR_LIGHT_GRAY 7 +#define VGA_COLOR_DARK_GRAY 8 +#define VGA_COLOR_LIGHT_BLUE 9 +#define VGA_COLOR_LIGHT_GREEN 10 +#define VGA_COLOR_LIGHT_CYAN 11 +#define VGA_COLOR_LIGHT_RED 12 +#define VGA_COLOR_LIGHT_MAGENTA 13 +#define VGA_COLOR_YELLOW 14 +#define VGA_COLOR_WHITE 15 + +#define VGA_TEXT_WIDTH 80 +#define VGA_TEXT_HEIGHT 25 + +fastcall void ConsoleVGA_Init(void); +fastcall void ConsoleVGA_SetColor(int8 fgColor); +fastcall void ConsoleVGA_SetBgColor(int8 bgColor); + +#endif /* __CONSOLE_VGA_H__ */ diff --git a/lib/metalkit/datafile.h b/lib/metalkit/datafile.h new file mode 100644 index 0000000..74c3e49 --- /dev/null +++ b/lib/metalkit/datafile.h @@ -0,0 +1,71 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * datafile.h - Macros for using raw data files included via objcopy. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __DATAFILE_H__ +#define __DATAFILE_H__ + +#include "types.h" +#include "puff.h" + +typedef struct DataFile { + uint8 *ptr; + uint32 size; +} DataFile; + +#define DECLARE_DATAFILE(symbol, filename) \ + extern uint8 _binary_ ## filename ## _start[]; \ + extern uint8 _binary_ ## filename ## _size[]; \ + static const DataFile symbol[1] = {{ \ + (uint8*) _binary_ ## filename ## _start, \ + (uint32) _binary_ ## filename ## _size, \ + }} + +static inline uint32 +DataFile_Decompress(const DataFile *f, void *buffer, uint32 bufferSize) +{ + unsigned long sourcelen = f->size; + unsigned long destlen = bufferSize; + + if (puff(buffer, &destlen, f->ptr, &sourcelen)) { + asm volatile ("int3"); + } + + return destlen; +} + +static inline uint32 +DataFile_GetDecompressedSize(const DataFile *f) +{ + return DataFile_Decompress(f, NULL, 0); +} + +#endif /* __DATAFILE_H_ */ diff --git a/lib/metalkit/deflate.py b/lib/metalkit/deflate.py new file mode 100644 index 0000000..530b5df --- /dev/null +++ b/lib/metalkit/deflate.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python +# +# A simple Python script to compress data +# with zlib's DEFLATE algorithm at build time. +# + +import zlib, sys + +level = 9 + +input = sys.stdin.read() +zData = zlib.compress(input, level) + +# Strip off the zlib header, and return the raw DEFLATE data stream. +# See the zlib RFC: http://www.gzip.org/zlib/rfc-zlib.html + +cmf = ord(zData[0]) +flg = ord(zData[1]) +assert (cmf & 0x0F) == 8 # DEFLATE algorithm +assert (flg & 0x20) == 0 # No preset dictionary + +# Strip off 2-byte header and 4-byte checksum +rawData = zData[2:len(zData)-4] + +sys.stdout.write(rawData) diff --git a/lib/metalkit/gcc_support.c b/lib/metalkit/gcc_support.c new file mode 100644 index 0000000..ea4a843 --- /dev/null +++ b/lib/metalkit/gcc_support.c @@ -0,0 +1,48 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * gcc_support.c - Older versions of GCC will call functions for + * common operations like memcpy/memset instead of + * using compiler intrinsics. This file provides + * non-inlined memcpy/memset functions for this + * purpose, and it's a good place to put any other + * compiler-specific functionality. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +void +memcpy(void *dest, const void *src, unsigned long size) +{ + asm volatile ("cld; rep movsb" : "+c" (size), "+S" (src), "+D" (dest) :: "memory"); +} + +void +memset(void *dest, unsigned char value, unsigned long size) +{ + asm volatile ("cld; rep stosb" : "+c" (size), "+D" (dest) : "a" (value) : "memory"); +} diff --git a/lib/metalkit/image.ld b/lib/metalkit/image.ld new file mode 100644 index 0000000..d52e963 --- /dev/null +++ b/lib/metalkit/image.ld @@ -0,0 +1,110 @@ +/* + * GNU Linker script for assembling a Metalkit binary image. + * + * Notable changes from ld's default behaviour: + * + * - Load address is at the 1MB boundary. + * + * - Our binary begins with a .boot section. + * + * - The end of the data section is padded to a + * 512-byte boundary, to make sure that our disk + * image ends on a sector boundary. (Required by QEMU) + * + * - We calculate a few auxiliary values used by the + * bootloader, which depend on knowing the size of + * the entire binary. + */ + +OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386") +OUTPUT_ARCH(i386) +ENTRY(_start) + +/* + * Stack starts at the top of the usable portion of the first 1MB, and + * grows downward. + */ +_stack = 0x9fffc; + +SECTIONS +{ + . = 0x100000; + + .text : { + _file_origin = .; + *(.boot); + *(.text .text.*); + } + + .data : { + *(.rodata .rodata.* .data .data.*) + _edata = .; + + _sector_padding = .; + . = ALIGN(512); + _sector_padding_end = .; + } + + .bss : { + __bss_start = .; + *(.bss .bss.*); + } + + _end = .; + + /DISCARD/ : { + *(.note .note.* .comment .comment.*); + } +} + +_bss_size = _end - _edata; +_image_size = _edata - _file_origin; + +/* + * Disk geometry. CHS geometry is mostly irrelevant these days, so we + * just pick something that will make fdisk happy. It tries to + * autodetect the disk size by looking at the disk's existing + * partitions, so the easiest way to keep it happy is to align the + * partition to a cylinder boundary. + * + * We'd like to use a floppy-disk-compatible geometry for images that + * are small enough to fit on a 1.44 MB disk, but for larger images we + * need to use a bigger geometry so that our cylinder numbers can fit + * in 10 bits. This larger geometry has 1 megabyte cylinders, so we + * can address 1 GB without breaking the 10 bit boundary. + */ + +_geom_large_disk = _image_size >= (2880 * 512); +_geom_sectors_per_head = _geom_large_disk ? 32 : 18; +_geom_heads_per_cylinder = _geom_large_disk ? 64 : 2; +_geom_sectors_per_cylinder = _geom_sectors_per_head * _geom_heads_per_cylinder; + +/* + * Partition is just big enough to hold our initialized data, rounded + * up to the nearest cylinder. The "_partition_chs_cylinder" is the + * number of the last cylinder in the partition. Also note that + * sector numbers are 1-based. + */ +_image_sectors = (_image_size + 511) / 512; +_partition_chs_cylinder = _image_sectors / _geom_sectors_per_cylinder; +_partition_blocks = (_partition_chs_cylinder + 1) * _geom_sectors_per_cylinder; +_partition_chs_head = _geom_heads_per_cylinder - 1; +_partition_chs_sector = _geom_sectors_per_head; + +/* + * Encode the sector and cylinder bytes in the format expected by MBR + * partition tables. + */ +_partition_chs_cylinder_byte = _partition_chs_cylinder & 0xff; +_partition_chs_sector_byte = _partition_chs_sector | + ((_partition_chs_cylinder - _partition_chs_cylinder_byte) >> 2); + +/* + * Split up the LDT address into byte-wide chunks, so we can write it + * into the GDT at link time. We can't do this entirely in boot.S, + * because the LDT address isn't contiguous in the GDT. + */ +_ldt_byte0 = (LDT >> 0) & 0xff; +_ldt_byte1 = (LDT >> 8) & 0xff; +_ldt_byte2 = (LDT >> 16) & 0xff; +_ldt_byte3 = (LDT >> 24) & 0xff; diff --git a/lib/metalkit/intr.c b/lib/metalkit/intr.c new file mode 100644 index 0000000..7f70d26 --- /dev/null +++ b/lib/metalkit/intr.c @@ -0,0 +1,419 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * intr.c - Interrupt vector management, interrupt routing, + * and low-level building blocks for multithreading. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#include "intr.h" +#include "boot.h" +#include "io.h" + +/* + * Definitions for the two PIC chips. + */ + +#define PIC1_COMMAND_PORT 0x20 +#define PIC1_DATA_PORT 0x21 +#define PIC2_COMMAND_PORT 0xA0 +#define PIC2_DATA_PORT 0xA1 + + +/* + * IDT table and IDT table descriptor. The table itself lives in the + * BSS segment, the descriptor lives in the data segment. + */ + +typedef union { + struct { + uint16 offsetLow; + uint16 segment; + uint16 flags; + uint16 offsetHigh; + }; + struct { + uint32 offsetLowSeg; + uint32 flagsOffsetHigh; + }; +} PACKED IDTType; + +/* + * Note the IDT is page-aligned. Only 8-byte alignment is actually + * necessary, though page alignment may help performance in some + * environments. + */ +static IDTType ALIGNED(4096) IDT[NUM_INTR_VECTORS]; + +const struct { + uint16 limit; + void *address; +} PACKED IDTDesc = { + .limit = NUM_INTR_VECTORS * 8 - 1, + .address = IDT, +}; + +/* + * To save space, we don't include assembly-language trampolines for + * each interrupt vector. Instead, we allocate a table in the BSS + * segment which we can fill in at runtime with simple trampoline + * functions. This structure actually describes executable 32-bit + * code. + */ + +typedef struct { + uint16 code1; + uint32 arg; + uint8 code2; + IntrHandler handler; + uint32 code3; + uint32 code4; + uint32 code5; + uint32 code6; + uint32 code7; + uint32 code8; +} PACKED IntrTrampolineType; + +static IntrTrampolineType ALIGNED(4) IntrTrampoline[NUM_INTR_VECTORS]; + + +/* + * IntrDefaultHandler -- + * + * Default no-op interrupt handler. + */ + +static void +IntrDefaultHandler(int vector) +{ + /* Do nothing. */ +} + + +/* + * Intr_Init -- + * + * Initialize the interrupt descriptor table and the programmable + * interrupt controller (PIC). On return, interrupts are enabled + * but all handlers are no-ops. + */ + +fastcall void +Intr_Init(void) +{ + int i; + + Intr_Disable(); + + IDTType *idt = IDT; + IntrTrampolineType *tramp = IntrTrampoline; + + for (i = 0; i < NUM_INTR_VECTORS; i++) { + uint32 trampolineAddr = (uint32) tramp; + + /* + * Set up the IDT entry as a 32-bit interrupt gate, pointing at + * our trampoline for this vector. Fill in the IDT with two 32-bit + * writes, since GCC generates significantly smaller code for this + * than when writing four 16-bit fields separately. + */ + + idt->offsetLowSeg = (trampolineAddr & 0x0000FFFF) | (BOOT_CODE_SEG << 16); + idt->flagsOffsetHigh = (trampolineAddr & 0xFFFF0000) | 0x00008E00; + + /* + * Set up the trampoline, pointing it at the default handler. + * The trampoline function wraps our C interrupt handler, and + * handles placing a vector number onto the stack. It also allows + * interrupt handlers to switch stacks upon return by writing + * to the saved 'esp' register. + * + * Note that the old stack and new stack may actually be different + * stack frames on the same stack. We require that the new stack + * is in a higher or equal stack frame, but the two stacks may + * overlap. This is why the trampoline does its copy in reverse. + * + * Keep the trampoline function consistent with the definition + * of IntrContext in intr.h. + * + * Stack layout: + * + * 8 eflags + * 4 cs + * 0 eip <- esp on entry to IRQ handler + * -4 eax + * -8 ecx + * -12 edx + * -16 ebx + * -20 esp + * -24 ebp + * -28 esi + * -32 edi + * -36 <- esp on entry to handler function + * + * Our trampolines each look like: + * + * 60 pusha // Save general-purpose regs + * 68 <32-bit arg> push // Call handler(arg) + * b8 <32-bit addr> mov , %eax + * ff d0 call *%eax + * 58 pop %eax // Remove arg from stack + * 8b 7c 24 0c mov 12(%esp), %edi // Load new stack address + * 8d 74 24 28 lea 40(%esp), %esi // Addr of eflags on old stack + * 83 c7 08 add $8, %edi // Addr of eflags on new stack + * fd std // Copy backwards + * a5 movsl // Copy eflags + * a5 movsl // Copy cs + * a5 movsl // Copy eip + * 61 popa // Restore general-purpose regs + * 8b 64 24 ec mov -20(%esp), %esp // Switch stacks + * cf iret // Restore eip, cs, eflags + * + * Note: Surprisingly enough, it's actually more size-efficient to initialize + * the structure in code like this than it is to memcpy() the trampoline from + * a template in the data segment. + */ + + tramp->code1 = 0x6860; + tramp->code2 = 0xb8; + tramp->code3 = 0x8b58d0ff; + tramp->code4 = 0x8d0c247c; + tramp->code5 = 0x83282474; + tramp->code6 = 0xa5fd08c7; + tramp->code7 = 0x8b61a5a5; + tramp->code8 = 0xcfec2464; + + tramp->handler = IntrDefaultHandler; + tramp->arg = i; + + idt++; + tramp++; + } + + asm volatile ("lidt IDTDesc"); + + typedef struct { + uint8 port, data; + } PortData8; + + static const PortData8 pitInit[] = { + /* + * Program the PIT to map all IRQs linearly starting at + * IRQ_VECTOR_BASE. + */ + + { PIC1_COMMAND_PORT, 0x11 }, // Begin init, use 4 command words + { PIC2_COMMAND_PORT, 0x11 }, + { PIC1_DATA_PORT, IRQ_VECTOR_BASE }, + { PIC2_DATA_PORT, IRQ_VECTOR_BASE + 8 }, + { PIC1_DATA_PORT, 0x04 }, + { PIC2_DATA_PORT, 0x02 }, + { PIC1_DATA_PORT, 0x03 }, // 8086 mode, auto-end-of-interrupt. + { PIC2_DATA_PORT, 0x03 }, + + /* + * All IRQs start out masked, except for the cascade IRQs 2 and 4. + */ + { PIC1_DATA_PORT, 0xEB }, + { PIC2_DATA_PORT, 0xFF }, + }; + + const PortData8 *p = pitInit; + + for (i = arraysize(pitInit); i; i--, p++) { + IO_Out8(p->port, p->data); + } + + Intr_Enable(); +} + + +/* + * Intr_SetHandler -- + * + * Set a C-language interrupt handler for a particular vector. + * Note that the argument is a vector number, not an IRQ. + */ + +fastcall void +Intr_SetHandler(int vector, IntrHandler handler) +{ + IntrTrampoline[vector].handler = handler; +} + + +/* + * Intr_SetMask -- + * + * (Un)mask a particular IRQ. + */ + +fastcall void +Intr_SetMask(int irq, Bool enable) +{ + uint8 port, bit, mask; + + if (irq >= 8) { + bit = 1 << (irq - 8); + port = PIC2_DATA_PORT; + } else { + bit = 1 << irq; + port = PIC1_DATA_PORT; + } + + mask = IO_In8(port); + + /* A '1' bit in the mask inhibits the interrupt. */ + if (enable) { + mask &= ~bit; + } else { + mask |= bit; + } + + IO_Out8(port, mask); +} + + +/* + * Intr_SetFaultHandlers -- + * + * Set all processor fault handlers to the provided function. + */ + +fastcall void +Intr_SetFaultHandlers(IntrHandler handler) +{ + int vector; + + for (vector = 0; vector < NUM_FAULT_VECTORS; vector++) { + Intr_SetHandler(vector, handler); + } +} + + +/* + * Intr_InitContext -- + * + * Create an IntrContext representing a brand new thread of + * execution. This can be used as a primitive to implement + * light-weight cooperative or pre-emptive multithreading. + * + * 'Stack' points to the initial value of the stack pointer. + * Stacks grow downward, so this should point to the top word of + * the allocated stack memory. + */ + +fastcall void +Intr_InitContext(IntrContext *ctx, uint32 *stack, IntrContextFn main) +{ + Intr_SaveContext(ctx); + ctx->esp = (uint32) stack; + ctx->eip = (uint32) main; +} + + +/* + * Intr_SaveContext -- + * + * This is a C-callable function which constructs an + * IntrContext representing the current execution + * context. This is nearly equivalent to invoking + * software interrupt and saving the interrupt's + * IntrContext, but this implementation doesn't have the + * overhead of an actual interrupt invocation. + */ + +asm (".global Intr_SaveContext \n Intr_SaveContext:" + + "pusha \n" + + /* + * Adjust the saved stack pointer. IntrContexts always + * store an %esp which has three words on the stack + * prior to the general-purpose regs, but since we don't + * use cs or eflags we only have 1. + */ + + "sub $8, 12(%esp) \n" + + /* + * The stack now matches the layout of the first 9 words + * of IntrContext. Copy these, then manually save CS and + * eflags. + */ + + "mov %esp, %esi \n" + "mov 36(%esp), %edi \n" + "mov $9, %ecx \n" + "rep movsl \n" + "xor %eax, %eax \n" + "mov %cs, %ax \n" + "stosl \n" + "pushf \n" + "pop %eax \n" + "stosl \n" + + /* Return 0 when this function is called directly. */ + + "popa \n" + "xor %eax, %eax \n" + "ret" ); + + +/* + * Intr_RestoreContext -- + * + * This is the inverse of Intr_SaveContext: copy the + * IntrContext onto the target context's stack frame, + * switch stacks, then restore the rest of the context's + * saved state. + */ + +asm(".global Intr_RestoreContext \n Intr_RestoreContext:" + + "mov 4(%esp), %esi \n" // Load pointer to IntrContext + "mov 12(%esi), %esp \n" // Switch stacks + + /* + * esp was saved with 3 words on the stack (eip, cs, cflags). + * Position esp so we have 9 words instead. (General purpose + * regs plus eip, but no cs/eflags.) + */ + + "sub $24, %esp \n" + + // Copy the first 9 words of Intrcontext back onto the stack. + + "mov %esp, %edi \n" + "mov $9, %ecx \n" + "rep movsl \n" + + // Restore the general purpose regs and eip + + "popa \n" + "ret" ); diff --git a/lib/metalkit/intr.h b/lib/metalkit/intr.h new file mode 100644 index 0000000..0ad30e5 --- /dev/null +++ b/lib/metalkit/intr.h @@ -0,0 +1,176 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * intr.h - Interrupt vector management and interrupt routing. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __INTR_H__ +#define __INTR_H__ + +#include "types.h" + +#define NUM_INTR_VECTORS 256 +#define NUM_FAULT_VECTORS 0x20 +#define NUM_IRQ_VECTORS 0x10 +#define IRQ_VECTOR_BASE NUM_FAULT_VECTORS +#define IRQ_VECTOR(irq) ((irq) + IRQ_VECTOR_BASE) +#define USER_VECTOR_BASE (IRQ_VECTOR_BASE + NUM_IRQ_VECTORS) +#define USER_VECTOR(n) ((n) + USER_VECTOR_BASE) + +#define IRQ_TIMER 0 +#define IRQ_KEYBOARD 1 + +#define FAULT_DE 0x00 // Divide error +#define FAULT_NMI 0x02 // Non-maskable interrupt +#define FAULT_BP 0x03 // Breakpoint +#define FAULT_OF 0x04 // Overflow +#define FAULT_BR 0x05 // Bound range +#define FAULT_UD 0x06 // Undefined opcode +#define FAULT_NM 0x07 // No FPU +#define FAULT_DF 0x08 // Double Fault +#define FAULT_TS 0x0A // Invalid TSS +#define FAULT_NP 0x0B // Segment not present +#define FAULT_SS 0x0C // Stack-segment fault +#define FAULT_GP 0x0D // General Protection Fault +#define FAULT_PF 0x0E // Page fault +#define FAULT_MF 0x10 // Math fault +#define FAULT_AC 0x11 // Alignment check +#define FAULT_MC 0x12 // Machine check +#define FAULT_XM 0x13 // SIMD floating point exception + +typedef void (*IntrHandler)(int vector); +typedef void (*IntrContextFn)(void); + +fastcall void Intr_Init(void); +fastcall void Intr_SetFaultHandlers(IntrHandler handler); +fastcall void Intr_SetHandler(int vector, IntrHandler handler); +fastcall void Intr_SetMask(int irq, Bool enable); + +static inline void +Intr_Enable(void) { + asm volatile ("sti"); +} + +static inline void +Intr_Disable(void) { + asm volatile ("cli"); +} + +static inline Bool +Intr_Save(void) { + uint32 eflags; + asm volatile ("pushf; pop %0" : "=r" (eflags)); + return (eflags & 0x200) != 0; +} + +static inline void +Intr_Restore(Bool flag) { + if (flag) { + Intr_Enable(); + } else { + Intr_Disable(); + } +} + +static inline void +Intr_Halt(void) { + asm volatile ("hlt"); +} + +static inline void +Intr_Break(void) { + asm volatile ("int3"); +} + +/* + * This structure describes all execution state that's saved when an + * interrupt or a setjmp occurs. In the case of an interrupt, this + * structure actually describes the stack frame of the interrupt + * trampoline. + * + * An interrupt handler can get a pointer to its IntrContext by + * passing its first argument to the Intr_GetContext macro. This + * allows an interrupt handler to examine the execution context in + * which the interrupt occurred, to modify the interrupt's return + * address, or even to implement input and output for OS traps. + * + * This module also provides functions for directly saving and + * restoring IntrContext structures. This can be used much like + * setjmp/longjmp, or it can even be used for simple cooperative or + * preemptive multithreading. An interrupt handler can perform a + * context switch by overwriting its IntrContext with a saved context. + * + * The definition of this structure must be kept in sync with the + * machine code in our interrupt trampolines, and with the + * assembly-language implementation of SaveContext and RestoreContext. + */ + +typedef struct IntrContext { + /* + * General purpose registers. These are all saved after the value + * of %esp is captured. + */ + + uint32 edi; + uint32 esi; + uint32 ebp; + uint32 esp; + uint32 ebx; + uint32 edx; + uint32 ecx; + uint32 eax; + + /* + * These values are save by the CPU during an interrupt. By + * convention, these values are at the top of the stack when %esp + * was saved. + * + * The values of cs and eflags are ignored by Intr_SaveContext + * and Intr_RestoreContext. + */ + + uint32 eip; + uint32 cs; + uint32 eflags; +} IntrContext; + +/* + * Always use the 'volatile' keyword when storing the result + * of Intr_GetContext. GCC can erroneously decide to optimize + * out any copies to this pointer, because it doesn't know the + * values will be used by our trampoline. + */ + +#define Intr_GetContext(arg) ((IntrContext*) &(&arg)[1]) + +uint32 Intr_SaveContext(IntrContext *ctx); +void Intr_RestoreContext(IntrContext *ctx); +fastcall void Intr_InitContext(IntrContext *ctx, uint32 *stack, IntrContextFn main); + +#endif /* __INTR_H__ */ diff --git a/lib/metalkit/io.h b/lib/metalkit/io.h new file mode 100644 index 0000000..cf7940b --- /dev/null +++ b/lib/metalkit/io.h @@ -0,0 +1,80 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * io.h - Simple IA32 I/O macros + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __IO_H__ +#define __IO_H__ + +#include "types.h" + +static __inline__ void +IO_Out8(uint16 port, uint8 value) +{ + __asm__ __volatile__ ("outb %0, %1" : :"a" (value), "d" (port)); +} + +static __inline__ void +IO_Out16(uint16 port, uint16 value) +{ + __asm__ __volatile__ ("outw %0, %1" : :"a" (value), "d" (port)); +} + +static __inline__ void +IO_Out32(uint16 port, uint32 value) +{ + __asm__ __volatile__ ("outl %0, %1" : :"a" (value), "d" (port)); +} + +static __inline__ uint8 +IO_In8(uint16 port) +{ + uint8 value; + __asm__ __volatile__ ("inb %1, %0" :"=a" (value) :"d" (port)); + return value; +} + +static __inline__ uint16 +IO_In16(uint16 port) +{ + uint16 value; + __asm__ __volatile__ ("inw %1, %0" :"=a" (value) :"d" (port)); + return value; +} + +static __inline__ uint32 +IO_In32(uint16 port) +{ + uint32 value; + __asm__ __volatile__ ("inl %1, %0" :"=a" (value) :"d" (port)); + return value; +} + +#endif /* __IO_H__ */ diff --git a/lib/metalkit/keyboard.c b/lib/metalkit/keyboard.c new file mode 100644 index 0000000..dd1f6ac --- /dev/null +++ b/lib/metalkit/keyboard.c @@ -0,0 +1,372 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * keyboard.c - Simple PC keyboard driver. Translates scancodes + * to a superset of ASCII. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#include "keyboard.h" +#include "io.h" +#include "intr.h" + +/* + * Keyboard hardware definitions + */ + +#define KB_IRQ 1 +#define KB_BUFFER_PORT 0x60 +#define KB_CMD_PORT 0x64 // Write for command +#define KB_STATUS_PORT 0x64 // Read for status +#define KB_STATUS_IBF (1 << 0) // Input buffer full +#define KB_STATUS_OBF (1 << 1) // Output buffer full +#define KB_CMD_RCB 0x20 // Read command byte +#define KB_CMD_WCB 0x60 // Write command byte +#define KB_CB_INT (1 << 0) // IBF Interrupt enabled + +/* + * Global keyboard state + */ + +static struct { + Bool escape; + KeyboardIRQHandler handler; + uint32 keyDown[roundup(KEY_MAX, 32)]; +} gKeyboard; + + +/* + * KeyboardWrite -- + * + * Blocking write to the keyboard controller's buffer. + * This can be used to send data to the keyboard itself, + * or to send a command parameter. + */ + +static void +KeyboardWrite(uint8 byte) +{ + while (IO_In8(KB_STATUS_PORT) & KB_STATUS_OBF); + IO_Out8(KB_BUFFER_PORT, byte); +} + + +/* + * KeyboardRead -- + * + * Blocking read from the keyboard controller's buffer. + * This can be used to read data from the keyboard itself, + * or to read a command parameter. + */ + +static uint8 +KeyboardRead(void) +{ + while (!(IO_In8(KB_STATUS_PORT) & KB_STATUS_IBF)); + return IO_In8(KB_BUFFER_PORT); +} + + +/* + * KeyboardWriteCB -- + * + * Blocking write to the keyboard controller's command byte. + */ + +static void +KeyboardWriteCB(uint8 byte) +{ + while (IO_In8(KB_STATUS_PORT) & KB_STATUS_OBF); + IO_Out8(KB_CMD_PORT, KB_CMD_WCB); + KeyboardWrite(byte); +} + + +/* + * KeyboardReadCB -- + * + * Blocking read from the keyboard controller's command byte. + */ + +static uint8 +KeyboardReadCB(void) +{ + while (IO_In8(KB_STATUS_PORT) & KB_STATUS_OBF); + IO_Out8(KB_CMD_PORT, KB_CMD_RCB); + return KeyboardRead(); +} + + +/* + * KeyboardSetKeyPressed -- + * + * Set a key's up/down state. + */ + +static void +KeyboardSetKeyPressed(Keycode k, Bool down) +{ + uint32 mask = 1 << (k & 0x1F); + if (down) { + gKeyboard.keyDown[k >> 5] |= mask; + } else { + gKeyboard.keyDown[k >> 5] &= ~mask; + } +} + + +/* + * KeyboardTranslate -- + * + * Translate scancodes to keycodes when possible, and update + * internal state: the scancode state machine, and the up/down + * state of all keys. + */ + +static void +KeyboardTranslate(KeyEvent *event) +{ + enum { + S_NORMAL = 0, + S_SHIFTED, + S_ESCAPED, + }; + + /* + * XXX: We hardcode a US-Ascii QWERTY layout. + */ + static const Keycode kbmap[][3] = { + /* S_NORMAL S_SHIFTED S_ESCAPED */ + /* 00 */ { KEY_NONE, KEY_NONE, KEY_NONE }, + /* 01 */ { KEY_ESCAPE, KEY_ESCAPE, KEY_NONE }, + /* 02 */ { '1', '!', KEY_NONE }, + /* 03 */ { '2', '@', KEY_NONE }, + /* 04 */ { '3', '#', KEY_NONE }, + /* 05 */ { '4', '$', KEY_NONE }, + /* 06 */ { '5', '%', KEY_NONE }, + /* 07 */ { '6', '^', KEY_NONE }, + /* 08 */ { '7', '&', KEY_NONE }, + /* 09 */ { '8', '*', KEY_NONE }, + /* 0a */ { '9', '(', KEY_NONE }, + /* 0b */ { '0', ')', KEY_NONE }, + /* 0c */ { '-', '_', KEY_NONE }, + /* 0d */ { '=', '+', KEY_NONE }, + /* 0e */ { KEY_BACKSPACE, KEY_BACKSPACE, KEY_NONE }, + /* 0f */ { KEY_TAB, KEY_TAB, KEY_NONE }, + /* 10 */ { 'q', 'Q', KEY_NONE }, + /* 11 */ { 'w', 'W', KEY_NONE }, + /* 12 */ { 'e', 'E', KEY_NONE }, + /* 13 */ { 'r', 'R', KEY_NONE }, + /* 14 */ { 't', 'T', KEY_NONE }, + /* 15 */ { 'y', 'Y', KEY_NONE }, + /* 16 */ { 'u', 'U', KEY_NONE }, + /* 17 */ { 'i', 'I', KEY_NONE }, + /* 18 */ { 'o', 'O', KEY_NONE }, + /* 19 */ { 'p', 'P', KEY_NONE }, + /* 1a */ { '[', '{', KEY_NONE }, + /* 1b */ { ']', '}', KEY_NONE }, + /* 1c */ { KEY_ENTER, KEY_ENTER, KEY_ENTER }, + /* 1d */ { KEY_LCTRL, KEY_LCTRL, KEY_RCTRL }, + /* 1e */ { 'a', 'A', KEY_NONE }, + /* 1f */ { 's', 'S', KEY_NONE }, + /* 20 */ { 'd', 'D', KEY_NONE }, + /* 21 */ { 'f', 'F', KEY_NONE }, + /* 22 */ { 'g', 'G', KEY_NONE }, + /* 23 */ { 'h', 'H', KEY_NONE }, + /* 24 */ { 'j', 'J', KEY_NONE }, + /* 25 */ { 'k', 'K', KEY_NONE }, + /* 26 */ { 'l', 'L', KEY_NONE }, + /* 27 */ { ';', ':', KEY_NONE }, + /* 28 */ { '\'', '"', KEY_NONE }, + /* 29 */ { '`', '~', KEY_NONE }, + /* 2a */ { KEY_LSHIFT, KEY_LSHIFT, KEY_NONE }, + /* 2b */ { '\\', '|', KEY_NONE }, + /* 2c */ { 'z', 'Z', KEY_NONE }, + /* 2d */ { 'x', 'X', KEY_NONE }, + /* 2e */ { 'c', 'C', KEY_NONE }, + /* 2f */ { 'v', 'V', KEY_NONE }, + /* 30 */ { 'b', 'B', KEY_NONE }, + /* 31 */ { 'n', 'N', KEY_NONE }, + /* 32 */ { 'm', 'M', KEY_NONE }, + /* 33 */ { ',', '<', KEY_NONE }, + /* 34 */ { '.', '>', KEY_NONE }, + /* 35 */ { '/', '?', '/' }, + /* 36 */ { KEY_RSHIFT, KEY_RSHIFT, KEY_NONE }, + /* 37 */ { '*', '*', KEY_CTRL_PRTSCN }, + /* 38 */ { KEY_LALT, KEY_LALT, KEY_RALT }, + /* 39 */ { ' ', ' ', KEY_NONE }, + /* 3a */ { KEY_CAPSLOCK, KEY_CAPSLOCK, KEY_NONE }, + /* 3b */ { KEY_F1, KEY_F1, KEY_NONE }, + /* 3c */ { KEY_F2, KEY_F2, KEY_NONE }, + /* 3d */ { KEY_F3, KEY_F3, KEY_NONE }, + /* 3e */ { KEY_F4, KEY_F4, KEY_NONE }, + /* 3f */ { KEY_F5, KEY_F5, KEY_NONE }, + /* 40 */ { KEY_F6, KEY_F6, KEY_NONE }, + /* 41 */ { KEY_F7, KEY_F6, KEY_NONE }, + /* 42 */ { KEY_F8, KEY_F7, KEY_NONE }, + /* 43 */ { KEY_F9, KEY_F8, KEY_NONE }, + /* 44 */ { KEY_F10, KEY_F9, KEY_NONE }, + /* 45 */ { KEY_NUMLOCK, KEY_NUMLOCK, KEY_NONE }, + /* 46 */ { KEY_SCROLLLOCK, KEY_SCROLLLOCK, KEY_CTRL_BREAK }, + /* 47 */ { '7', '7', KEY_HOME }, + /* 48 */ { '8', '8', KEY_UP }, + /* 49 */ { '9', '9', KEY_PGUP }, + /* 4a */ { '-', '-', KEY_NONE }, + /* 4b */ { '4', '4', KEY_LEFT }, + /* 4c */ { '5', '5', KEY_NONE }, + /* 4d */ { '6', '6', KEY_RIGHT }, + /* 4e */ { '+', '+', KEY_NONE }, + /* 4f */ { '1', '1', KEY_END }, + /* 50 */ { '2', '2', KEY_DOWN }, + /* 51 */ { '3', '3', KEY_PGDOWN }, + /* 52 */ { '0', '0', KEY_INSERT }, + /* 53 */ { '.', '.', KEY_DELETE }, + }; + + uint8 scancode = event->scancode & 0x7F; + event->pressed = (event->scancode & 0x80) == 0; + + if (event->scancode == 0xe0) { + /* + * Begin an escape sequence. + */ + + gKeyboard.escape = TRUE; + + } else if (scancode >= KEY_MAX) { + /* + * Unsupported scancode. + */ + + } else if (gKeyboard.escape) { + /* + * Escaped key. + */ + gKeyboard.escape = FALSE; + event->rawKey = kbmap[scancode][S_ESCAPED]; + event->key = event->rawKey; + + } else { + /* + * Non-escaped key. + */ + + event->rawKey = kbmap[scancode][S_NORMAL]; + + if (Keyboard_IsKeyPressed(KEY_LSHIFT) || + Keyboard_IsKeyPressed(KEY_RSHIFT)) { + + event->key = kbmap[scancode][S_SHIFTED]; + } else { + event->key = event->rawKey; + } + } + + KeyboardSetKeyPressed(event->rawKey, event->pressed); +} + + +/* + * KeyboardHandlerInternal -- + * + * This is the low-level keyboard interrupt handler. We convert + * the incoming key into a Keycode, modify our key state table, and + * pass it on to any registered KeyboardIRQHandler. + */ + +static void +KeyboardHandlerInternal(int vector) +{ + KeyEvent event = { KeyboardRead() }; + + KeyboardTranslate(&event); + + if (gKeyboard.handler) { + gKeyboard.handler(&event); + } +} + + +/* + * Keyboard_Init -- + * + * Set up the keyboard driver. This installs our default IRQ + * handler, and initializes the key table. The IRQ module must be + * initialized before this is called. + * + * As a side-effect, this will unmask the keyboard IRQ and install + * a handler. + */ + +fastcall void +Keyboard_Init(void) +{ + /* + * Enable the keyboard IRQ + */ + KeyboardWriteCB(KeyboardReadCB() | KB_CB_INT); + + Intr_SetMask(KB_IRQ, TRUE); + Intr_SetHandler(IRQ_VECTOR(KB_IRQ), KeyboardHandlerInternal); +} + + +/* + * Keyboard_IsKeyPressed -- + * + * Check whether a key, identified by Keycode, is down. + */ + +fastcall Bool +Keyboard_IsKeyPressed(Keycode k) +{ + if (k < KEY_MAX) { + return (gKeyboard.keyDown[k >> 5] >> (k & 0x1F)) & 1; + } + return FALSE; +} + + +/* + * Keyboard_SetHandler -- + * + * Set a handler that will receive translated keys and scancodes. + * This handler is run within the IRQ handler, so it must complete + * quickly and use minimal stack space. + * + * The handler will be called once per scancode byte, regardless of + * whether that byte ended a key event or not. If event->key is + * zero, the event can be ignored unless you're interested in + * seeing the raw scancodes. + */ + +fastcall void +Keyboard_SetHandler(KeyboardIRQHandler handler) +{ + gKeyboard.handler = handler; +} diff --git a/lib/metalkit/keyboard.h b/lib/metalkit/keyboard.h new file mode 100644 index 0000000..73d2841 --- /dev/null +++ b/lib/metalkit/keyboard.h @@ -0,0 +1,98 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * keyboard.h - Simple PC keyboard driver. Translates scancodes + * to a superset of ASCII. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __KEYBOARD_H__ +#define __KEYBOARD_H__ + +#include "types.h" + +/* + * Symbols for all keys that don't map directly to ASCII + */ + +#define KEY_NONE 0x00 +#define KEY_ESCAPE 0x1B +#define KEY_BACKSPACE '\b' +#define KEY_ENTER '\n' +#define KEY_TAB '\t' +#define KEY_LCTRL 0x80 +#define KEY_LSHIFT 0x81 +#define KEY_RCTRL 0x82 +#define KEY_RSHIFT 0x83 +#define KEY_CAPSLOCK 0x84 +#define KEY_NUMLOCK 0x85 +#define KEY_SCROLLLOCK 0x86 +#define KEY_F1 0x87 +#define KEY_F2 0x88 +#define KEY_F3 0x89 +#define KEY_F4 0x8A +#define KEY_F5 0x8B +#define KEY_F6 0x8C +#define KEY_F7 0x8D +#define KEY_F8 0x8E +#define KEY_F9 0x8F +#define KEY_F10 0x90 +#define KEY_F11 0x91 +#define KEY_F12 0x92 +#define KEY_HOME 0x93 +#define KEY_END 0x94 +#define KEY_PGUP 0x95 +#define KEY_PGDOWN 0x96 +#define KEY_UP 0x97 +#define KEY_DOWN 0x98 +#define KEY_LEFT 0x99 +#define KEY_RIGHT 0x9A +#define KEY_INSERT 0x9B +#define KEY_DELETE 0x9C +#define KEY_LALT 0x9D +#define KEY_RALT 0x9E +#define KEY_CTRL_PRTSCN 0x9F +#define KEY_CTRL_BREAK 0xA0 +#define KEY_MAX 0xA1 // Number of keycodes + +typedef uint8 Keycode; + +typedef struct KeyEvent { + uint8 scancode; // Raw i8042 scancode + Keycode rawKey; // Not affected by modifiers + Keycode key; // Superset of ASCII + Bool pressed; +} KeyEvent; + +typedef fastcall void (*KeyboardIRQHandler)(KeyEvent *event); + +fastcall void Keyboard_Init(void); +fastcall Bool Keyboard_IsKeyPressed(Keycode key); +fastcall void Keyboard_SetHandler(KeyboardIRQHandler handler); + +#endif /* __VGA_TEXT_H__ */ diff --git a/lib/metalkit/math.h b/lib/metalkit/math.h new file mode 100644 index 0000000..bf525cf --- /dev/null +++ b/lib/metalkit/math.h @@ -0,0 +1,46 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * math.h - A random subset of math definitions, which work without + * a C standard library or math library. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __MATH_H__ +#define __MATH_H__ + +#include "types.h" + +#define sinf(t) __builtin_sinf(t) +#define cosf(t) __builtin_cosf(t) +#define tanf(t) __builtin_tanf(t) + +#define M_PI 3.14159265359 +#define PI_OVER_180 0.017453292519943295 + +#endif /* __MATH_H_ */ diff --git a/lib/metalkit/pci.c b/lib/metalkit/pci.c new file mode 100644 index 0000000..a2e660d --- /dev/null +++ b/lib/metalkit/pci.c @@ -0,0 +1,243 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * pci.c - Simple PCI configuration interface. This implementation + * only supports type 1 accesses to configuration space, + * and it ignores the PCI BIOS. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#include "pci.h" +#include "io.h" + +/* + * There can be up to 256 PCI busses, but it takes a noticeable + * amount of time to scan that whole space. Limit the number of + * supported busses to something more reasonable... + */ +#define PCI_MAX_BUSSES 0x20 + +#define PCI_REG_CONFIG_ADDRESS 0xCF8 +#define PCI_REG_CONFIG_DATA 0xCFC + + +/* + * PCIConfigPackAddress -- + * + * Pack a 32-bit CONFIG_ADDRESS value. + */ + +static fastcall uint32 +PCIConfigPackAddress(const PCIAddress *addr, uint16 offset) +{ + const uint32 enableBit = 0x80000000UL; + + return (((uint32)addr->bus << 16) | + ((uint32)addr->device << 11) | + ((uint32)addr->function << 8) | + offset | enableBit); +} + + +/* + * PCI_ConfigRead32 -- + * PCI_ConfigRead16 -- + * PCI_ConfigRead8 -- + * PCI_ConfigWrite32 -- + * PCI_ConfigWrite16 -- + * PCI_ConfigWrite8 -- + * + * Access a device's PCI configuration space, using configuration + * mechanism #1. All new machines should use method #1, method #2 + * is for legacy compatibility. + * + * See http://www.osdev.org/wiki/PCI + */ + +fastcall uint32 +PCI_ConfigRead32(const PCIAddress *addr, uint16 offset) +{ + IO_Out32(PCI_REG_CONFIG_ADDRESS, PCIConfigPackAddress(addr, offset)); + return IO_In32(PCI_REG_CONFIG_DATA); +} + +fastcall uint16 +PCI_ConfigRead16(const PCIAddress *addr, uint16 offset) +{ + IO_Out32(PCI_REG_CONFIG_ADDRESS, PCIConfigPackAddress(addr, offset)); + return IO_In16(PCI_REG_CONFIG_DATA); +} + +fastcall uint8 +PCI_ConfigRead8(const PCIAddress *addr, uint16 offset) +{ + IO_Out32(PCI_REG_CONFIG_ADDRESS, PCIConfigPackAddress(addr, offset)); + return IO_In8(PCI_REG_CONFIG_DATA); +} + +fastcall void +PCI_ConfigWrite32(const PCIAddress *addr, uint16 offset, uint32 data) +{ + IO_Out32(PCI_REG_CONFIG_ADDRESS, PCIConfigPackAddress(addr, offset)); + IO_Out32(PCI_REG_CONFIG_DATA, data); +} + +fastcall void +PCI_ConfigWrite16(const PCIAddress *addr, uint16 offset, uint16 data) +{ + IO_Out32(PCI_REG_CONFIG_ADDRESS, PCIConfigPackAddress(addr, offset)); + IO_Out16(PCI_REG_CONFIG_DATA, data); +} + +fastcall void +PCI_ConfigWrite8(const PCIAddress *addr, uint16 offset, uint8 data) +{ + IO_Out32(PCI_REG_CONFIG_ADDRESS, PCIConfigPackAddress(addr, offset)); + IO_Out8(PCI_REG_CONFIG_DATA, data); +} + + +/* + * PCI_ScanBus -- + * + * Scan the PCI bus for devices. Before starting a scan, + * the caller should zero the PCIScanState structure. + * Every time this function is called, it returns the next + * device in sequence. + * + * Returns TRUE if a device was found, leaving that device's + * vendorId, productId, and address in 'state'. + * + * Returns FALSE if there are no more devices. + */ + +fastcall Bool +PCI_ScanBus(PCIScanState *state) +{ + PCIConfigSpace config; + + for (;;) { + config.words[0] = PCI_ConfigRead32(&state->nextAddr, 0); + + state->addr = state->nextAddr; + + if (++state->nextAddr.function == 0x8) { + state->nextAddr.function = 0; + if (++state->nextAddr.device == 0x20) { + state->nextAddr.device = 0; + if (++state->nextAddr.bus == PCI_MAX_BUSSES) { + return FALSE; + } + } + } + + if (config.words[0] != 0xFFFFFFFFUL) { + state->vendorId = config.vendorId; + state->deviceId = config.deviceId; + return TRUE; + } + } +} + + +/* + * PCI_FindDevice -- + * + * Scan the PCI bus for a device with a specific vendor and device ID. + * + * On success, returns TRUE and puts the device address into 'addrOut'. + * If the device was not found, returns FALSE. + */ + +fastcall Bool +PCI_FindDevice(uint16 vendorId, uint16 deviceId, PCIAddress *addrOut) +{ + PCIScanState busScan = {}; + + while (PCI_ScanBus(&busScan)) { + if (busScan.vendorId == vendorId && busScan.deviceId == deviceId) { + *addrOut = busScan.addr; + return TRUE; + } + } + + return FALSE; +} + + +/* + * PCI_SetBAR -- + * + * Set one of a device's Base Address Registers to the provided value. + */ + +fastcall void +PCI_SetBAR(const PCIAddress *addr, int index, uint32 value) +{ + PCI_ConfigWrite32(addr, offsetof(PCIConfigSpace, BAR[index]), value); +} + + +/* + * PCI_GetBARAddr -- + * + * Get the current address set in one of the device's Base Address Registers. + * (We mask off the lower 2 bits, which hold memory type flags.) + */ + +fastcall uint32 +PCI_GetBARAddr(const PCIAddress *addr, int index) +{ + return PCI_ConfigRead32(addr, offsetof(PCIConfigSpace, BAR[index])) & ~3; +} + + +/* + * PCI_SetMemEnable -- + * + * Enable or disable a device's memory and IO space. This must be + * called to enable a device's resources after setting all + * applicable BARs. Also enables/disables bus mastering. + */ + +fastcall void +PCI_SetMemEnable(const PCIAddress *addr, Bool enable) +{ + uint16 command = PCI_ConfigRead16(addr, offsetof(PCIConfigSpace, command)); + + /* Mem space enable, IO space enable, bus mastering. */ + const uint16 flags = 0x0007; + + if (enable) { + command |= flags; + } else { + command &= ~flags; + } + + PCI_ConfigWrite16(addr, offsetof(PCIConfigSpace, command), command); +} diff --git a/lib/metalkit/pci.h b/lib/metalkit/pci.h new file mode 100644 index 0000000..a36f74a --- /dev/null +++ b/lib/metalkit/pci.h @@ -0,0 +1,92 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * pci.h - Simple PCI configuration interface. This implementation + * only supports type 1 accesses to configuration space, + * and it ignores the PCI BIOS. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __PCI_H__ +#define __PCI_H__ + +#include "types.h" + +typedef union PCIConfigSpace { + uint32 words[16]; + struct { + uint16 vendorId; + uint16 deviceId; + uint16 command; + uint16 status; + uint16 revisionId; + uint8 subclass; + uint8 classCode; + uint8 cacheLineSize; + uint8 latTimer; + uint8 headerType; + uint8 BIST; + uint32 BAR[6]; + uint32 cardbusCIS; + uint16 subsysVendorId; + uint16 subsysId; + uint32 expansionRomAddr; + uint32 reserved0; + uint32 reserved1; + uint8 intrLine; + uint8 intrPin; + uint8 minGrant; + uint8 maxLatency; + }; +} __attribute__ ((__packed__)) PCIConfigSpace; + +typedef struct PCIAddress { + uint8 bus, device, function; +} PCIAddress; + +typedef struct PCIScanState { + uint16 vendorId; + uint16 deviceId; + PCIAddress nextAddr; + PCIAddress addr; +} PCIScanState; + +fastcall uint32 PCI_ConfigRead32(const PCIAddress *addr, uint16 offset); +fastcall uint16 PCI_ConfigRead16(const PCIAddress *addr, uint16 offset); +fastcall uint8 PCI_ConfigRead8(const PCIAddress *addr, uint16 offset); +fastcall void PCI_ConfigWrite32(const PCIAddress *addr, uint16 offset, uint32 data); +fastcall void PCI_ConfigWrite16(const PCIAddress *addr, uint16 offset, uint16 data); +fastcall void PCI_ConfigWrite8(const PCIAddress *addr, uint16 offset, uint8 data); + +fastcall Bool PCI_ScanBus(PCIScanState *state); +fastcall Bool PCI_FindDevice(uint16 vendorId, uint16 deviceId, PCIAddress *addrOut); +fastcall void PCI_SetBAR(const PCIAddress *addr, int index, uint32 value); +fastcall uint32 PCI_GetBARAddr(const PCIAddress *addr, int index); +fastcall void PCI_SetMemEnable(const PCIAddress *addr, Bool enable); + +#endif /* __PCI_H__ */ diff --git a/lib/metalkit/puff.c b/lib/metalkit/puff.c new file mode 100644 index 0000000..ce0cc40 --- /dev/null +++ b/lib/metalkit/puff.c @@ -0,0 +1,837 @@ +/* + * puff.c + * Copyright (C) 2002-2004 Mark Adler + * For conditions of distribution and use, see copyright notice in puff.h + * version 1.8, 9 Jan 2004 + * + * puff.c is a simple inflate written to be an unambiguous way to specify the + * deflate format. It is not written for speed but rather simplicity. As a + * side benefit, this code might actually be useful when small code is more + * important than speed, such as bootstrap applications. For typical deflate + * data, zlib's inflate() is about four times as fast as puff(). zlib's + * inflate compiles to around 20K on my machine, whereas puff.c compiles to + * around 4K on my machine (a PowerPC using GNU cc). If the faster decode() + * function here is used, then puff() is only twice as slow as zlib's + * inflate(). + * + * All dynamically allocated memory comes from the stack. The stack required + * is less than 2K bytes. This code is compatible with 16-bit int's and + * assumes that long's are at least 32 bits. puff.c uses the short data type, + * assumed to be 16 bits, for arrays in order to to conserve memory. The code + * works whether integers are stored big endian or little endian. + * + * In the comments below are "Format notes" that describe the inflate process + * and document some of the less obvious aspects of the format. This source + * code is meant to supplement RFC 1951, which formally describes the deflate + * format: + * + * http://www.zlib.org/rfc-deflate.html + */ + +/* + * Change history: + * + * 1.0 10 Feb 2002 - First version + * 1.1 17 Feb 2002 - Clarifications of some comments and notes + * - Update puff() dest and source pointers on negative + * errors to facilitate debugging deflators + * - Remove longest from struct huffman -- not needed + * - Simplify offs[] index in construct() + * - Add input size and checking, using longjmp() to + * maintain easy readability + * - Use short data type for large arrays + * - Use pointers instead of long to specify source and + * destination sizes to avoid arbitrary 4 GB limits + * 1.2 17 Mar 2002 - Add faster version of decode(), doubles speed (!), + * but leave simple version for readabilty + * - Make sure invalid distances detected if pointers + * are 16 bits + * - Fix fixed codes table error + * - Provide a scanning mode for determining size of + * uncompressed data + * 1.3 20 Mar 2002 - Go back to lengths for puff() parameters [Jean-loup] + * - Add a puff.h file for the interface + * - Add braces in puff() for else do [Jean-loup] + * - Use indexes instead of pointers for readability + * 1.4 31 Mar 2002 - Simplify construct() code set check + * - Fix some comments + * - Add FIXLCODES #define + * 1.5 6 Apr 2002 - Minor comment fixes + * 1.6 7 Aug 2002 - Minor format changes + * 1.7 3 Mar 2003 - Added test code for distribution + * - Added zlib-like license + * 1.8 9 Jan 2004 - Added some comments on no distance codes case + */ + +#include /* for setjmp(), longjmp(), and jmp_buf */ +#include "puff.h" /* prototype for puff() */ + +#define local static /* for local function definitions */ +#define NIL ((unsigned char *)0) /* for no output option */ + +/* + * Maximums for allocations and loops. It is not useful to change these -- + * they are fixed by the deflate format. + */ +#define MAXBITS 15 /* maximum bits in a code */ +#define MAXLCODES 286 /* maximum number of literal/length codes */ +#define MAXDCODES 30 /* maximum number of distance codes */ +#define MAXCODES (MAXLCODES+MAXDCODES) /* maximum codes lengths to read */ +#define FIXLCODES 288 /* number of fixed literal/length codes */ + +/* input and output state */ +struct state { + /* output state */ + unsigned char *out; /* output buffer */ + unsigned long outlen; /* available space at out */ + unsigned long outcnt; /* bytes written to out so far */ + + /* input state */ + unsigned char *in; /* input buffer */ + unsigned long inlen; /* available input at in */ + unsigned long incnt; /* bytes read so far */ + int bitbuf; /* bit buffer */ + int bitcnt; /* number of bits in bit buffer */ + + /* input limit error return state for bits() and decode() */ + jmp_buf env; +}; + +/* + * Return need bits from the input stream. This always leaves less than + * eight bits in the buffer. bits() works properly for need == 0. + * + * Format notes: + * + * - Bits are stored in bytes from the least significant bit to the most + * significant bit. Therefore bits are dropped from the bottom of the bit + * buffer, using shift right, and new bytes are appended to the top of the + * bit buffer, using shift left. + */ +local int bits(struct state *s, int need) +{ + long val; /* bit accumulator (can use up to 20 bits) */ + + /* load at least need bits into val */ + val = s->bitbuf; + while (s->bitcnt < need) { + if (s->incnt == s->inlen) longjmp(s->env, 1); /* out of input */ + val |= (long)(s->in[s->incnt++]) << s->bitcnt; /* load eight bits */ + s->bitcnt += 8; + } + + /* drop need bits and update buffer, always zero to seven bits left */ + s->bitbuf = (int)(val >> need); + s->bitcnt -= need; + + /* return need bits, zeroing the bits above that */ + return (int)(val & ((1L << need) - 1)); +} + +/* + * Process a stored block. + * + * Format notes: + * + * - After the two-bit stored block type (00), the stored block length and + * stored bytes are byte-aligned for fast copying. Therefore any leftover + * bits in the byte that has the last bit of the type, as many as seven, are + * discarded. The value of the discarded bits are not defined and should not + * be checked against any expectation. + * + * - The second inverted copy of the stored block length does not have to be + * checked, but it's probably a good idea to do so anyway. + * + * - A stored block can have zero length. This is sometimes used to byte-align + * subsets of the compressed data for random access or partial recovery. + */ +local int stored(struct state *s) +{ + unsigned len; /* length of stored block */ + + /* discard leftover bits from current byte (assumes s->bitcnt < 8) */ + s->bitbuf = 0; + s->bitcnt = 0; + + /* get length and check against its one's complement */ + if (s->incnt + 4 > s->inlen) return 2; /* not enough input */ + len = s->in[s->incnt++]; + len |= s->in[s->incnt++] << 8; + if (s->in[s->incnt++] != (~len & 0xff) || + s->in[s->incnt++] != ((~len >> 8) & 0xff)) + return -2; /* didn't match complement! */ + + /* copy len bytes from in to out */ + if (s->incnt + len > s->inlen) return 2; /* not enough input */ + if (s->out != NIL) { + if (s->outcnt + len > s->outlen) + return 1; /* not enough output space */ + while (len--) + s->out[s->outcnt++] = s->in[s->incnt++]; + } + else { /* just scanning */ + s->outcnt += len; + s->incnt += len; + } + + /* done with a valid stored block */ + return 0; +} + +/* + * Huffman code decoding tables. count[1..MAXBITS] is the number of symbols of + * each length, which for a canonical code are stepped through in order. + * symbol[] are the symbol values in canonical order, where the number of + * entries is the sum of the counts in count[]. The decoding process can be + * seen in the function decode() below. + */ +struct huffman { + short *count; /* number of symbols of each length */ + short *symbol; /* canonically ordered symbols */ +}; + +/* + * Decode a code from the stream s using huffman table h. Return the symbol or + * a negative value if there is an error. If all of the lengths are zero, i.e. + * an empty code, or if the code is incomplete and an invalid code is received, + * then -9 is returned after reading MAXBITS bits. + * + * Format notes: + * + * - The codes as stored in the compressed data are bit-reversed relative to + * a simple integer ordering of codes of the same lengths. Hence below the + * bits are pulled from the compressed data one at a time and used to + * build the code value reversed from what is in the stream in order to + * permit simple integer comparisons for decoding. A table-based decoding + * scheme (as used in zlib) does not need to do this reversal. + * + * - The first code for the shortest length is all zeros. Subsequent codes of + * the same length are simply integer increments of the previous code. When + * moving up a length, a zero bit is appended to the code. For a complete + * code, the last code of the longest length will be all ones. + * + * - Incomplete codes are handled by this decoder, since they are permitted + * in the deflate format. See the format notes for fixed() and dynamic(). + */ +#ifdef SLOW +local int decode(struct state *s, struct huffman *h) +{ + int len; /* current number of bits in code */ + int code; /* len bits being decoded */ + int first; /* first code of length len */ + int count; /* number of codes of length len */ + int index; /* index of first code of length len in symbol table */ + + code = first = index = 0; + for (len = 1; len <= MAXBITS; len++) { + code |= bits(s, 1); /* get next bit */ + count = h->count[len]; + if (code < first + count) /* if length len, return symbol */ + return h->symbol[index + (code - first)]; + index += count; /* else update for next length */ + first += count; + first <<= 1; + code <<= 1; + } + return -9; /* ran out of codes */ +} + +/* + * A faster version of decode() for real applications of this code. It's not + * as readable, but it makes puff() twice as fast. And it only makes the code + * a few percent larger. + */ +#else /* !SLOW */ +local int decode(struct state *s, struct huffman *h) +{ + int len; /* current number of bits in code */ + int code; /* len bits being decoded */ + int first; /* first code of length len */ + int count; /* number of codes of length len */ + int index; /* index of first code of length len in symbol table */ + int bitbuf; /* bits from stream */ + int left; /* bits left in next or left to process */ + short *next; /* next number of codes */ + + bitbuf = s->bitbuf; + left = s->bitcnt; + code = first = index = 0; + len = 1; + next = h->count + 1; + while (1) { + while (left--) { + code |= bitbuf & 1; + bitbuf >>= 1; + count = *next++; + if (code < first + count) { /* if length len, return symbol */ + s->bitbuf = bitbuf; + s->bitcnt = (s->bitcnt - len) & 7; + return h->symbol[index + (code - first)]; + } + index += count; /* else update for next length */ + first += count; + first <<= 1; + code <<= 1; + len++; + } + left = (MAXBITS+1) - len; + if (left == 0) break; + if (s->incnt == s->inlen) longjmp(s->env, 1); /* out of input */ + bitbuf = s->in[s->incnt++]; + if (left > 8) left = 8; + } + return -9; /* ran out of codes */ +} +#endif /* SLOW */ + +/* + * Given the list of code lengths length[0..n-1] representing a canonical + * Huffman code for n symbols, construct the tables required to decode those + * codes. Those tables are the number of codes of each length, and the symbols + * sorted by length, retaining their original order within each length. The + * return value is zero for a complete code set, negative for an over- + * subscribed code set, and positive for an incomplete code set. The tables + * can be used if the return value is zero or positive, but they cannot be used + * if the return value is negative. If the return value is zero, it is not + * possible for decode() using that table to return an error--any stream of + * enough bits will resolve to a symbol. If the return value is positive, then + * it is possible for decode() using that table to return an error for received + * codes past the end of the incomplete lengths. + * + * Not used by decode(), but used for error checking, h->count[0] is the number + * of the n symbols not in the code. So n - h->count[0] is the number of + * codes. This is useful for checking for incomplete codes that have more than + * one symbol, which is an error in a dynamic block. + * + * Assumption: for all i in 0..n-1, 0 <= length[i] <= MAXBITS + * This is assured by the construction of the length arrays in dynamic() and + * fixed() and is not verified by construct(). + * + * Format notes: + * + * - Permitted and expected examples of incomplete codes are one of the fixed + * codes and any code with a single symbol which in deflate is coded as one + * bit instead of zero bits. See the format notes for fixed() and dynamic(). + * + * - Within a given code length, the symbols are kept in ascending order for + * the code bits definition. + */ +local int construct(struct huffman *h, short *length, int n) +{ + int symbol; /* current symbol when stepping through length[] */ + int len; /* current length when stepping through h->count[] */ + int left; /* number of possible codes left of current length */ + short offs[MAXBITS+1]; /* offsets in symbol table for each length */ + + /* count number of codes of each length */ + for (len = 0; len <= MAXBITS; len++) + h->count[len] = 0; + for (symbol = 0; symbol < n; symbol++) + (h->count[length[symbol]])++; /* assumes lengths are within bounds */ + if (h->count[0] == n) /* no codes! */ + return 0; /* complete, but decode() will fail */ + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; /* one possible code of zero length */ + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; /* one more bit, double codes left */ + left -= h->count[len]; /* deduct count from possible codes */ + if (left < 0) return left; /* over-subscribed--return negative */ + } /* left > 0 means incomplete */ + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) + offs[len + 1] = offs[len] + h->count[len]; + + /* + * put symbols in table sorted by length, by symbol order within each + * length + */ + for (symbol = 0; symbol < n; symbol++) + if (length[symbol] != 0) + h->symbol[offs[length[symbol]]++] = symbol; + + /* return zero for complete set, positive for incomplete set */ + return left; +} + +/* + * Decode literal/length and distance codes until an end-of-block code. + * + * Format notes: + * + * - Compressed data that is after the block type if fixed or after the code + * description if dynamic is a combination of literals and length/distance + * pairs terminated by and end-of-block code. Literals are simply Huffman + * coded bytes. A length/distance pair is a coded length followed by a + * coded distance to represent a string that occurs earlier in the + * uncompressed data that occurs again at the current location. + * + * - Literals, lengths, and the end-of-block code are combined into a single + * code of up to 286 symbols. They are 256 literals (0..255), 29 length + * symbols (257..285), and the end-of-block symbol (256). + * + * - There are 256 possible lengths (3..258), and so 29 symbols are not enough + * to represent all of those. Lengths 3..10 and 258 are in fact represented + * by just a length symbol. Lengths 11..257 are represented as a symbol and + * some number of extra bits that are added as an integer to the base length + * of the length symbol. The number of extra bits is determined by the base + * length symbol. These are in the static arrays below, lens[] for the base + * lengths and lext[] for the corresponding number of extra bits. + * + * - The reason that 258 gets its own symbol is that the longest length is used + * often in highly redundant files. Note that 258 can also be coded as the + * base value 227 plus the maximum extra value of 31. While a good deflate + * should never do this, it is not an error, and should be decoded properly. + * + * - If a length is decoded, including its extra bits if any, then it is + * followed a distance code. There are up to 30 distance symbols. Again + * there are many more possible distances (1..32768), so extra bits are added + * to a base value represented by the symbol. The distances 1..4 get their + * own symbol, but the rest require extra bits. The base distances and + * corresponding number of extra bits are below in the static arrays dist[] + * and dext[]. + * + * - Literal bytes are simply written to the output. A length/distance pair is + * an instruction to copy previously uncompressed bytes to the output. The + * copy is from distance bytes back in the output stream, copying for length + * bytes. + * + * - Distances pointing before the beginning of the output data are not + * permitted. + * + * - Overlapped copies, where the length is greater than the distance, are + * allowed and common. For example, a distance of one and a length of 258 + * simply copies the last byte 258 times. A distance of four and a length of + * twelve copies the last four bytes three times. A simple forward copy + * ignoring whether the length is greater than the distance or not implements + * this correctly. You should not use memcpy() since its behavior is not + * defined for overlapped arrays. You should not use memmove() or bcopy() + * since though their behavior -is- defined for overlapping arrays, it is + * defined to do the wrong thing in this case. + */ +local int codes(struct state *s, + struct huffman *lencode, + struct huffman *distcode) +{ + int symbol; /* decoded symbol */ + int len; /* length for copy */ + unsigned dist; /* distance for copy */ + static const short lens[29] = { /* Size base for length codes 257..285 */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258}; + static const short lext[29] = { /* Extra bits for length codes 257..285 */ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, + 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0}; + static const short dists[30] = { /* Offset base for distance codes 0..29 */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577}; + static const short dext[30] = { /* Extra bits for distance codes 0..29 */ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, + 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, + 12, 12, 13, 13}; + + /* decode literals and length/distance pairs */ + do { + symbol = decode(s, lencode); + if (symbol < 0) return symbol; /* invalid symbol */ + if (symbol < 256) { /* literal: symbol is the byte */ + /* write out the literal */ + if (s->out != NIL) { + if (s->outcnt == s->outlen) return 1; + s->out[s->outcnt] = symbol; + } + s->outcnt++; + } + else if (symbol > 256) { /* length */ + /* get and compute length */ + symbol -= 257; + if (symbol >= 29) return -9; /* invalid fixed code */ + len = lens[symbol] + bits(s, lext[symbol]); + + /* get and check distance */ + symbol = decode(s, distcode); + if (symbol < 0) return symbol; /* invalid symbol */ + dist = dists[symbol] + bits(s, dext[symbol]); + if (dist > s->outcnt) + return -10; /* distance too far back */ + + /* copy length bytes from distance bytes back */ + if (s->out != NIL) { + if (s->outcnt + len > s->outlen) return 1; + while (len--) { + s->out[s->outcnt] = s->out[s->outcnt - dist]; + s->outcnt++; + } + } + else + s->outcnt += len; + } + } while (symbol != 256); /* end of block symbol */ + + /* done with a valid fixed or dynamic block */ + return 0; +} + +/* + * Process a fixed codes block. + * + * Format notes: + * + * - This block type can be useful for compressing small amounts of data for + * which the size of the code descriptions in a dynamic block exceeds the + * benefit of custom codes for that block. For fixed codes, no bits are + * spent on code descriptions. Instead the code lengths for literal/length + * codes and distance codes are fixed. The specific lengths for each symbol + * can be seen in the "for" loops below. + * + * - The literal/length code is complete, but has two symbols that are invalid + * and should result in an error if received. This cannot be implemented + * simply as an incomplete code since those two symbols are in the "middle" + * of the code. They are eight bits long and the longest literal/length\ + * code is nine bits. Therefore the code must be constructed with those + * symbols, and the invalid symbols must be detected after decoding. + * + * - The fixed distance codes also have two invalid symbols that should result + * in an error if received. Since all of the distance codes are the same + * length, this can be implemented as an incomplete code. Then the invalid + * codes are detected while decoding. + */ +local int fixed(struct state *s) +{ + static int virgin = 1; + static short lencnt[MAXBITS+1], lensym[FIXLCODES]; + static short distcnt[MAXBITS+1], distsym[MAXDCODES]; + static struct huffman lencode = {lencnt, lensym}; + static struct huffman distcode = {distcnt, distsym}; + + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + int symbol; + short lengths[FIXLCODES]; + + /* literal/length table */ + for (symbol = 0; symbol < 144; symbol++) + lengths[symbol] = 8; + for (; symbol < 256; symbol++) + lengths[symbol] = 9; + for (; symbol < 280; symbol++) + lengths[symbol] = 7; + for (; symbol < FIXLCODES; symbol++) + lengths[symbol] = 8; + construct(&lencode, lengths, FIXLCODES); + + /* distance table */ + for (symbol = 0; symbol < MAXDCODES; symbol++) + lengths[symbol] = 5; + construct(&distcode, lengths, MAXDCODES); + + /* do this just once */ + virgin = 0; + } + + /* decode data until end-of-block code */ + return codes(s, &lencode, &distcode); +} + +/* + * Process a dynamic codes block. + * + * Format notes: + * + * - A dynamic block starts with a description of the literal/length and + * distance codes for that block. New dynamic blocks allow the compressor to + * rapidly adapt to changing data with new codes optimized for that data. + * + * - The codes used by the deflate format are "canonical", which means that + * the actual bits of the codes are generated in an unambiguous way simply + * from the number of bits in each code. Therefore the code descriptions + * are simply a list of code lengths for each symbol. + * + * - The code lengths are stored in order for the symbols, so lengths are + * provided for each of the literal/length symbols, and for each of the + * distance symbols. + * + * - If a symbol is not used in the block, this is represented by a zero as + * as the code length. This does not mean a zero-length code, but rather + * that no code should be created for this symbol. There is no way in the + * deflate format to represent a zero-length code. + * + * - The maximum number of bits in a code is 15, so the possible lengths for + * any code are 1..15. + * + * - The fact that a length of zero is not permitted for a code has an + * interesting consequence. Normally if only one symbol is used for a given + * code, then in fact that code could be represented with zero bits. However + * in deflate, that code has to be at least one bit. So for example, if + * only a single distance base symbol appears in a block, then it will be + * represented by a single code of length one, in particular one 0 bit. This + * is an incomplete code, since if a 1 bit is received, it has no meaning, + * and should result in an error. So incomplete distance codes of one symbol + * should be permitted, and the receipt of invalid codes should be handled. + * + * - It is also possible to have a single literal/length code, but that code + * must be the end-of-block code, since every dynamic block has one. This + * is not the most efficient way to create an empty block (an empty fixed + * block is fewer bits), but it is allowed by the format. So incomplete + * literal/length codes of one symbol should also be permitted. + * + * - If there are only literal codes and no lengths, then there are no distance + * codes. This is represented by one distance code with zero bits. + * + * - The list of up to 286 length/literal lengths and up to 30 distance lengths + * are themselves compressed using Huffman codes and run-length encoding. In + * the list of code lengths, a 0 symbol means no code, a 1..15 symbol means + * that length, and the symbols 16, 17, and 18 are run-length instructions. + * Each of 16, 17, and 18 are follwed by extra bits to define the length of + * the run. 16 copies the last length 3 to 6 times. 17 represents 3 to 10 + * zero lengths, and 18 represents 11 to 138 zero lengths. Unused symbols + * are common, hence the special coding for zero lengths. + * + * - The symbols for 0..18 are Huffman coded, and so that code must be + * described first. This is simply a sequence of up to 19 three-bit values + * representing no code (0) or the code length for that symbol (1..7). + * + * - A dynamic block starts with three fixed-size counts from which is computed + * the number of literal/length code lengths, the number of distance code + * lengths, and the number of code length code lengths (ok, you come up with + * a better name!) in the code descriptions. For the literal/length and + * distance codes, lengths after those provided are considered zero, i.e. no + * code. The code length code lengths are received in a permuted order (see + * the order[] array below) to make a short code length code length list more + * likely. As it turns out, very short and very long codes are less likely + * to be seen in a dynamic code description, hence what may appear initially + * to be a peculiar ordering. + * + * - Given the number of literal/length code lengths (nlen) and distance code + * lengths (ndist), then they are treated as one long list of nlen + ndist + * code lengths. Therefore run-length coding can and often does cross the + * boundary between the two sets of lengths. + * + * - So to summarize, the code description at the start of a dynamic block is + * three counts for the number of code lengths for the literal/length codes, + * the distance codes, and the code length codes. This is followed by the + * code length code lengths, three bits each. This is used to construct the + * code length code which is used to read the remainder of the lengths. Then + * the literal/length code lengths and distance lengths are read as a single + * set of lengths using the code length codes. Codes are constructed from + * the resulting two sets of lengths, and then finally you can start + * decoding actual compressed data in the block. + * + * - For reference, a "typical" size for the code description in a dynamic + * block is around 80 bytes. + */ +local int dynamic(struct state *s) +{ + int nlen, ndist, ncode; /* number of lengths in descriptor */ + int index; /* index of lengths[] */ + int err; /* construct() return value */ + short lengths[MAXCODES]; /* descriptor code lengths */ + short lencnt[MAXBITS+1], lensym[MAXLCODES]; /* lencode memory */ + short distcnt[MAXBITS+1], distsym[MAXDCODES]; /* distcode memory */ + struct huffman lencode = {lencnt, lensym}; /* length code */ + struct huffman distcode = {distcnt, distsym}; /* distance code */ + static const short order[19] = /* permutation of code length codes */ + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + + /* get number of lengths in each table, check lengths */ + nlen = bits(s, 5) + 257; + ndist = bits(s, 5) + 1; + ncode = bits(s, 4) + 4; + if (nlen > MAXLCODES || ndist > MAXDCODES) + return -3; /* bad counts */ + + /* read code length code lengths (really), missing lengths are zero */ + for (index = 0; index < ncode; index++) + lengths[order[index]] = bits(s, 3); + for (; index < 19; index++) + lengths[order[index]] = 0; + + /* build huffman table for code lengths codes (use lencode temporarily) */ + err = construct(&lencode, lengths, 19); + if (err != 0) return -4; /* require complete code set here */ + + /* read length/literal and distance code length tables */ + index = 0; + while (index < nlen + ndist) { + int symbol; /* decoded value */ + int len; /* last length to repeat */ + + symbol = decode(s, &lencode); + if (symbol < 16) /* length in 0..15 */ + lengths[index++] = symbol; + else { /* repeat instruction */ + len = 0; /* assume repeating zeros */ + if (symbol == 16) { /* repeat last length 3..6 times */ + if (index == 0) return -5; /* no last length! */ + len = lengths[index - 1]; /* last length */ + symbol = 3 + bits(s, 2); + } + else if (symbol == 17) /* repeat zero 3..10 times */ + symbol = 3 + bits(s, 3); + else /* == 18, repeat zero 11..138 times */ + symbol = 11 + bits(s, 7); + if (index + symbol > nlen + ndist) + return -6; /* too many lengths! */ + while (symbol--) /* repeat last or zero symbol times */ + lengths[index++] = len; + } + } + + /* build huffman table for literal/length codes */ + err = construct(&lencode, lengths, nlen); + if (err < 0 || (err > 0 && nlen - lencode.count[0] != 1)) + return -7; /* only allow incomplete codes if just one code */ + + /* build huffman table for distance codes */ + err = construct(&distcode, lengths + nlen, ndist); + if (err < 0 || (err > 0 && ndist - distcode.count[0] != 1)) + return -8; /* only allow incomplete codes if just one code */ + + /* decode data until end-of-block code */ + return codes(s, &lencode, &distcode); +} + +/* + * Inflate source to dest. On return, destlen and sourcelen are updated to the + * size of the uncompressed data and the size of the deflate data respectively. + * On success, the return value of puff() is zero. If there is an error in the + * source data, i.e. it is not in the deflate format, then a negative value is + * returned. If there is not enough input available or there is not enough + * output space, then a positive error is returned. In that case, destlen and + * sourcelen are not updated to facilitate retrying from the beginning with the + * provision of more input data or more output space. In the case of invalid + * inflate data (a negative error), the dest and source pointers are updated to + * facilitate the debugging of deflators. + * + * puff() also has a mode to determine the size of the uncompressed output with + * no output written. For this dest must be (unsigned char *)0. In this case, + * the input value of *destlen is ignored, and on return *destlen is set to the + * size of the uncompressed output. + * + * The return codes are: + * + * 2: available inflate data did not terminate + * 1: output space exhausted before completing inflate + * 0: successful inflate + * -1: invalid block type (type == 3) + * -2: stored block length did not match one's complement + * -3: dynamic block code description: too many length or distance codes + * -4: dynamic block code description: code lengths codes incomplete + * -5: dynamic block code description: repeat lengths with no first length + * -6: dynamic block code description: repeat more than specified lengths + * -7: dynamic block code description: invalid literal/length code lengths + * -8: dynamic block code description: invalid distance code lengths + * -9: invalid literal/length or distance code in fixed or dynamic block + * -10: distance is too far back in fixed or dynamic block + * + * Format notes: + * + * - Three bits are read for each block to determine the kind of block and + * whether or not it is the last block. Then the block is decoded and the + * process repeated if it was not the last block. + * + * - The leftover bits in the last byte of the deflate data after the last + * block (if it was a fixed or dynamic block) are undefined and have no + * expected values to check. + */ +int puff(unsigned char *dest, /* pointer to destination pointer */ + unsigned long *destlen, /* amount of output space */ + unsigned char *source, /* pointer to source data pointer */ + unsigned long *sourcelen) /* amount of input available */ +{ + struct state s; /* input/output state */ + int last, type; /* block information */ + int err; /* return value */ + + /* initialize output state */ + s.out = dest; + s.outlen = *destlen; /* ignored if dest is NIL */ + s.outcnt = 0; + + /* initialize input state */ + s.in = source; + s.inlen = *sourcelen; + s.incnt = 0; + s.bitbuf = 0; + s.bitcnt = 0; + + /* return if bits() or decode() tries to read past available input */ + if (setjmp(s.env) != 0) /* if came back here via longjmp() */ + err = 2; /* then skip do-loop, return error */ + else { + /* process blocks until last block or error */ + do { + last = bits(&s, 1); /* one if last block */ + type = bits(&s, 2); /* block type 0..3 */ + err = type == 0 ? stored(&s) : + (type == 1 ? fixed(&s) : + (type == 2 ? dynamic(&s) : + -1)); /* type == 3, invalid */ + if (err != 0) break; /* return with error */ + } while (!last); + } + + /* update the lengths and return */ + if (err <= 0) { + *destlen = s.outcnt; + *sourcelen = s.incnt; + } + return err; +} + +#ifdef TEST +/* Example of how to use puff() */ +#include +#include +#include +#include + +local unsigned char *yank(char *name, unsigned long *len) +{ + unsigned long size; + unsigned char *buf; + FILE *in; + struct stat s; + + *len = 0; + if (stat(name, &s)) return NULL; + if ((s.st_mode & S_IFMT) != S_IFREG) return NULL; + size = (unsigned long)(s.st_size); + if (size == 0 || (off_t)size != s.st_size) return NULL; + in = fopen(name, "r"); + if (in == NULL) return NULL; + buf = malloc(size); + if (buf != NULL && fread(buf, 1, size, in) != size) { + free(buf); + buf = NULL; + } + fclose(in); + *len = size; + return buf; +} + +int main(int argc, char **argv) +{ + int ret; + unsigned char *source; + unsigned long len, sourcelen, destlen; + + if (argc < 2) return 2; + source = yank(argv[1], &len); + if (source == NULL) return 2; + sourcelen = len; + ret = puff(NIL, &destlen, source, &sourcelen); + if (ret) + printf("puff() failed with return code %d\n", ret); + else { + printf("puff() succeeded uncompressing %lu bytes\n", destlen); + if (sourcelen < len) printf("%lu compressed bytes unused\n", + len - sourcelen); + } + free(source); + return ret; +} +#endif diff --git a/lib/metalkit/puff.h b/lib/metalkit/puff.h new file mode 100644 index 0000000..ef61252 --- /dev/null +++ b/lib/metalkit/puff.h @@ -0,0 +1,31 @@ +/* puff.h + Copyright (C) 2002, 2003 Mark Adler, all rights reserved + version 1.7, 3 Mar 2002 + + This software is provided 'as-is', without any express or implied + warranty. In no event will the author be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Mark Adler madler@alumni.caltech.edu + */ + + +/* + * See puff.c for purpose and usage. + */ +int puff(unsigned char *dest, /* pointer to destination pointer */ + unsigned long *destlen, /* amount of output space */ + unsigned char *source, /* pointer to source data pointer */ + unsigned long *sourcelen); /* amount of input available */ diff --git a/lib/metalkit/setjmp.h b/lib/metalkit/setjmp.h new file mode 100644 index 0000000..7411af8 --- /dev/null +++ b/lib/metalkit/setjmp.h @@ -0,0 +1,21 @@ +/* + * setjmp.h - A simple setjmp/longjmp wrapper around IntrContext. + */ + +#ifndef __SETJMP_H__ +#define __SETJMP_H__ + +#include "intr.h" + +typedef IntrContext jmp_buf; + +#define setjmp(buf) ((int)Intr_SaveContext(&(buf))) +#define longjmp(buf,val) _longjmp(&(buf), (val)) + +static inline void _longjmp(jmp_buf *env, int val) +{ + env->eax = val; + Intr_RestoreContext(env); +} + +#endif /* __SETJMP_H__ */ diff --git a/lib/metalkit/timer.c b/lib/metalkit/timer.c new file mode 100644 index 0000000..db6bac6 --- /dev/null +++ b/lib/metalkit/timer.c @@ -0,0 +1,49 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * timer.c - Interfaces for the various timers available on PC hardware. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#include "timer.h" +#include "io.h" + +/* + * Timer_InitPIT -- + * + * Set up PIT channel 0 in rate timer mode, with the provided + * divisor. It will trigger IRQ 0 at (PIT_HZ / divisor) Hz. + */ + +fastcall void +Timer_InitPIT(uint16 divisor) +{ + IO_Out8(0x43, 0x34); + IO_Out8(0x40, divisor & 0xFF); + IO_Out8(0x40, divisor >> 8); +} diff --git a/lib/metalkit/timer.h b/lib/metalkit/timer.h new file mode 100644 index 0000000..dd4d22c --- /dev/null +++ b/lib/metalkit/timer.h @@ -0,0 +1,43 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * timer.h - Interfaces for the various timers available on PC hardware. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __TIMER_H__ +#define __TIMER_H__ + +#include "types.h" + +#define PIT_HZ 1193182 +#define PIT_IRQ 0 + +fastcall void Timer_InitPIT(uint16 divisor); + +#endif /* __TIMER_H__ */ diff --git a/lib/metalkit/types.h b/lib/metalkit/types.h new file mode 100644 index 0000000..b3b450b --- /dev/null +++ b/lib/metalkit/types.h @@ -0,0 +1,112 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * types.h - Low-level type, macro, and inline definitions. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __TYPES_H__ +#define __TYPES_H__ + +typedef long long int64; +typedef unsigned long long uint64; + +typedef int int32; +typedef unsigned int uint32; + +typedef short int16; +typedef unsigned short uint16; + +typedef char int8; +typedef unsigned char uint8; + +typedef uint8 Bool; + +typedef struct { + int x, y; +} IVec2; + +#define NULL ((void*)0) +#define TRUE 1 +#define FALSE 0 + +#define offsetof(type, member) ((uint32)(&((type*)NULL)->member)) +#define arraysize(var) (sizeof(var) / sizeof((var)[0])) +#define roundup(x, y) (((x) + ((y) - 1)) / (y)) + +#define PACKED __attribute__ ((__packed__)) +#define ALIGNED(n) __attribute__ ((aligned(n))) +#define fastcall __attribute__ ((fastcall)) + +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#define MAX(a, b) ((a) > (b) ? (a) : (b)) + +static inline void +memcpy(void *dest, const void *src, uint32 size) +{ + asm volatile ("cld; rep movsb" : "+c" (size), "+S" (src), "+D" (dest) :: "memory"); +} + +static inline void +memset(void *dest, uint8 value, uint32 size) +{ + asm volatile ("cld; rep stosb" : "+c" (size), "+D" (dest) : "a" (value) : "memory"); +} + +static inline void +memcpy16(void *dest, const void *src, uint32 size) +{ + asm volatile ("cld; rep movsw" : "+c" (size), "+S" (src), "+D" (dest) :: "memory"); +} + +static inline void +memset16(void *dest, uint16 value, uint32 size) +{ + asm volatile ("cld; rep stosw" : "+c" (size), "+D" (dest) : "a" (value) : "memory"); +} + +static inline void +memcpy32(void *dest, const void *src, uint32 size) +{ + asm volatile ("cld; rep movsl" : "+c" (size), "+S" (src), "+D" (dest) :: "memory"); +} + +static inline void +memset32(void *dest, uint32 value, uint32 size) +{ + asm volatile ("cld; rep stosl" : "+c" (size), "+D" (dest) : "a" (value) : "memory"); +} + +#define Atomic_Exchange(mem, reg) \ + asm volatile ("xchgl %0, %1" : "+r" (reg), "+m" (mem) :) + +#define Atomic_Or(mem, reg) \ + asm volatile ("lock orl %1, %0" :"+m" (mem) :"r" (reg)) + +#endif /* __TYPES_H__ */ + diff --git a/lib/metalkit/vbe.c b/lib/metalkit/vbe.c new file mode 100644 index 0000000..9c84526 --- /dev/null +++ b/lib/metalkit/vbe.c @@ -0,0 +1,233 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * vbe.c - Support for the VESA BIOS Extension (VBE) video interface. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#include "vbe.h" +#include "console.h" + +VBEState gVBE; + +/* + * VBE_Init -- + * + * Probe for VBE support, and retrieve information + * about the video adapter and its supported modes. + * + * On success, returns TRUE and initializes gVBE. + * Returns FALSE if VBE is unsupported. + */ + +fastcall Bool +VBE_Init() +{ + VBEState *self = &gVBE; + Regs reg = {}; + VBEControllerInfo *cInfo = (void*) BIOS_SHARED->userdata; + uint16 *modes; + + /* Let the BIOS know we support VBE2 */ + cInfo->signature = SIGNATURE_VBE2; + + Console_WriteString("Foo\n"); + + /* "Get SuperVGA Information" command */ + reg.ax = 0x4f00; + reg.di = PTR_32_TO_NEAR(cInfo, 0); + BIOS_Call(0x10, ®); + if (reg.ax != 0x004F) { + return FALSE; + } + Console_WriteString("Bar\n"); + + /* + * Make a copy of the VBEControllerInfo struct itself, and of the + * mode list. Some VBE implementations place the mode list in + * temporary memory (the reserved area after cInfo) so we may need + * to copy it before making the next VBE call. + */ + + memcpy(&self->cInfo, cInfo, sizeof *cInfo); + modes = PTR_FAR_TO_32(self->cInfo.videoModes); + self->numModes = 0; + while (*modes != 0xFFFF) { + self->modes[self->numModes] = *modes; + modes++; + self->numModes++; + } + + return TRUE; +} + + +/* + * VBE_GetModeInfo -- + * + * Get information about a particular VBE video mode. + * Fills in the provided VBEModeInfo structure. + */ + +fastcall void +VBE_GetModeInfo(uint16 mode, VBEModeInfo *info) +{ + Regs reg = {}; + VBEModeInfo *tempInfo = (void*) BIOS_SHARED->userdata; + + memset(tempInfo, 0, sizeof *info); + + reg.ax = 0x4f01; + reg.cx = mode; + reg.di = PTR_32_TO_NEAR(tempInfo, 0); + BIOS_Call(0x10, ®); + + memcpy(info, tempInfo, sizeof *info); +} + + +/* + * VBE_SetMode -- + * + * Switch to a VESA BIOS SuperVGA mode. + * On return, the gVBE structure will have + * information about the new current mode. + */ + +fastcall void +VBE_SetMode(uint16 mode, uint16 modeFlags) +{ + VBEState *self = &gVBE; + + self->current.mode = mode; + self->current.flags = modeFlags; + VBE_GetModeInfo(mode, &self->current.info); + + Regs reg = {}; + reg.ax = 0x4f02; + reg.bx = mode | modeFlags; + BIOS_Call(0x10, ®); +} + + +/* + * VBE_SetStartAddress -- + * + * Synchronously change the start address at which the video + * adapter will scan out to the monitor. + */ + +fastcall void +VBE_SetStartAddress(int x, int y) +{ + Regs reg = {}; + reg.ax = 0x4f07; + reg.bx = 0x0000; + reg.cx = x; + reg.dx = y; + BIOS_Call(0x10, ®); +} + + +/* + * VBE_SetPalette -- + * + * Use the VESA BIOS (not the VGA registers) to update any number + * of palette entries. + * + * Note that the entire block of palette entries must fit in the + * BIOS_SHARED scratch area. Currently this is 1 kilobyte, which + * is exactly the size of a full VBE palette. + * + * Each palette entry is a 32-bit BGRX-format color. By default, + * each color component is 6 bits wide. + */ + +fastcall void +VBE_SetPalette(int firstColor, int numColors, uint32 *colors) +{ + Regs reg = {}; + uint32 *tempColors = (void*) BIOS_SHARED->userdata; + + memcpy32(tempColors, colors, numColors); + + reg.ax = 0x4f09; + reg.bx = 0x0000; // Set palette data + reg.cx = numColors; + reg.dx = firstColor; + reg.di = PTR_32_TO_NEAR(tempColors, 0); + + BIOS_Call(0x10, ®); +} + + +/* + * VBE_InitSimple -- + * + * Look for a linear video mode matching the requested + * size and depth and switch to it. + * + * If VBE is not supported or the requested mode can't + * be found, we panic. + * + * On return, gVBE.current will hold info about the + * new mode. In particular, gVBE.current.info.linearAddress + * will point to the beginning of framebuffer memory. + */ + +fastcall void +VBE_InitSimple(int width, int height, int bpp) +{ + VBEState *self = &gVBE; + int i; + + if (!VBE_Init()) { + Console_Panic("VESA BIOS Extensions not available."); + } + + for (i = 0; i < self->numModes; i++) { + uint16 mode = self->modes[i]; + VBEModeInfo info; + const uint32 requiredAttrs = VBE_MODEATTR_SUPPORTED | + VBE_MODEATTR_GRAPHICS | + VBE_MODEATTR_LINEAR; + + VBE_GetModeInfo(mode, &info); + + if ((info.attributes & requiredAttrs) == requiredAttrs && + info.width == width && + info.height == height && + info.bitsPerPixel == bpp) { + + VBE_SetMode(mode, VBE_MODEFLAG_LINEAR); + return; + } + } + + Console_Panic("Can't find the requested video mode."); +} diff --git a/lib/metalkit/vbe.h b/lib/metalkit/vbe.h new file mode 100644 index 0000000..785ec07 --- /dev/null +++ b/lib/metalkit/vbe.h @@ -0,0 +1,143 @@ +/* -*- Mode: C; c-basic-offset: 3 -*- + * + * vbe.h - Support for the VESA BIOS Extension (VBE) video interface. + * + * This file is part of Metalkit, a simple collection of modules for + * writing software that runs on the bare metal. Get the latest code + * at http://svn.navi.cx/misc/trunk/metalkit/ + * + * Copyright (c) 2008-2009 Micah Dowty + * + * 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. + */ + +#ifndef __VBE_H__ +#define __VBE_H__ + +#include "types.h" +#include "bios.h" + +#define SIGNATURE_VESA 0x41534556 +#define SIGNATURE_VBE2 0x32454256 +#define MAX_SUPPORTED_MODES 128 + +#define VBE_MODEATTR_SUPPORTED (1 << 0) +#define VBE_MODEATTR_VBE1_2 (1 << 1) +#define VBE_MODEATTR_BIOS_SUPPORTED (1 << 2) +#define VBE_MODEATTR_COLOR (1 << 3) +#define VBE_MODEATTR_GRAPHICS (1 << 4) +#define VBE_MODEATTR_NONVGA (1 << 5) +#define VBE_MODEATTR_NOBANKED (1 << 6) +#define VBE_MODEATTR_LINEAR (1 << 7) +#define VBE_MODEATTR_DOUBLESCAN (1 << 8) + +#define VBE_MODEFLAG_LINEAR 0x4000 + +#define VBE_MEMTYPE_TEXT 0x00 +#define VBE_MEMTYPE_CGA 0x01 +#define VBE_MEMTYPE_HGC 0x02 +#define VBE_MEMTYPE_EGA 0x03 +#define VBE_MEMTYPE_PACKED 0x04 +#define VBE_MEMTYPE_DIRECT 0x06 + + +typedef struct { + uint32 signature; + union { + uint16 version; + struct { + uint8 verMinor; + uint8 verMajor; + }; + }; + far_ptr_t oemString; + uint32 capabilities; + far_ptr_t videoModes; + uint16 totalMemory; + + /* VBE 2.0 */ + uint16 oemVersion; + far_ptr_t vendorName; + far_ptr_t productName; + far_ptr_t productRev; + uint16 vbeAFVersion; + far_ptr_t accelModes; +} PACKED VBEControllerInfo; + +typedef struct { + uint16 attributes; + uint8 winA, winB; + uint16 granularity; + uint16 winSize; + uint16 segmentA, segmentB; + far_ptr_t winFunc; + uint16 bytesPerLine; + + /* OEM mode info */ + uint16 width; + uint16 height; + uint8 cellWidth; + uint8 cellHeight; + uint8 numPlanes; + uint8 bitsPerPixel; + uint8 numBanks; + uint8 memType; + uint8 bankSizeKB; + uint8 pageFit; + uint8 reserved; + + /* VBE 1.2+ */ + struct { + uint8 maskSize; + uint8 fieldPos; + } red, green, blue, reservedChannel; + uint8 directColorInfo; + + /* VBE 2.0+ */ + void *linearAddress; + void *offscreenAddress; + uint16 offscreenSizeKB; +} PACKED VBEModeInfo; + +typedef struct { + VBEControllerInfo cInfo; + uint8 numModes; + uint16 modes[MAX_SUPPORTED_MODES]; + struct { + uint16 mode; + uint16 flags; + VBEModeInfo info; + } current; +} VBEState; + +extern VBEState gVBE; + +fastcall Bool VBE_Init(); +fastcall void VBE_GetModeInfo(uint16 mode, VBEModeInfo *info); +fastcall void VBE_SetMode(uint16 mode, uint16 modeFlags); + +fastcall void VBE_SetStartAddress(int x, int y); +fastcall void VBE_SetPalette(int firstColor, int numColors, uint32 *colors); + +fastcall void VBE_InitSimple(int width, int height, int bpp); + +#endif /* __VBE_H_ */ diff --git a/lib/refdriver/gmr.c b/lib/refdriver/gmr.c new file mode 100644 index 0000000..acdb714 --- /dev/null +++ b/lib/refdriver/gmr.c @@ -0,0 +1,384 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * gmr.c -- + * + * Utilities for creating and Guest Memory Regions (GMRs) + */ + +#include "svga.h" +#include "gmr.h" + +/* + * Global data + */ + +static uint32 heapTop; +GMRState gGMR; + + +/* + *----------------------------------------------------------------------------- + * + * Heap_Reset -- + * Heap_Alloc -- + * Heap_AllocPages -- + * Heap_Discard -- + * Heap_DiscardPages -- + * Heap_ProbeMem -- + * + * Trivial memory heap with 32-bit aligned and page-aligned + * allocation. Memory can't be freed, but the entire heap + * can be reset. + * + * On 'discard', we don't actually free memory- we just write + * over it to ensure its values aren't still being used. + * + * We insert padding pages between each individual memory + * allocation, to ensure that separate allocations are not + * accidentally contiguous. + * + *----------------------------------------------------------------------------- + */ + +void +Heap_Reset(void) +{ + extern uint8 _end[]; + heapTop = (uint32) _end; +} + +void +Heap_ProbeMem(volatile uint32 *addr, uint32 size) +{ + const uint32 probe = 0x55AA55AA; + while (size > sizeof *addr) { + *addr = probe; + if (*addr != probe) { + goto error; + } + *addr = ~probe; + if (*addr != ~probe) { + goto error; + } + size -= sizeof *addr; + addr++; + } + return; + error: + SVGA_Panic("Out of physical memory.\n\n" + "Increase the amount of memory allocated to this VM.\n" + "128MB of RAM is recommended.\n"); +} + +void * +Heap_Alloc(uint32 bytes) +{ + const uint32 padding = 16; + void *result; + + heapTop = (heapTop + 3) & ~3; + result = (void*) heapTop; + + bytes += padding; + heapTop += bytes; + Heap_ProbeMem(result, bytes); + + return result; +} + +PPN +Heap_AllocPages(uint32 numPages) +{ + const uint32 padding = 1; + PPN result; + uint32 bytes; + + heapTop = (heapTop + PAGE_MASK) & ~PAGE_MASK; + result = heapTop / PAGE_SIZE; + + numPages += padding; + bytes = numPages * PAGE_SIZE; + heapTop += bytes; + Heap_ProbeMem(PPN_POINTER(result), bytes); + + return result; +} + +void +Heap_Discard(void *data, uint32 bytes) +{ + memset(data, 0xAA, bytes); +} + +void +Heap_DiscardPages(PPN firstPage, uint32 numPages) +{ + memset(PPN_POINTER(firstPage), 0xAA, numPages * PAGE_SIZE); +} + + +/* + *----------------------------------------------------------------------------- + * + * GMR_AllocDescriptor -- + * + * Given a flat array of descriptors, allocate physical pages as + * necessary and copy the descriptors into a linked list of + * pages. The result is a PPN which is suitable to give directly to + * the SVGA device's GMR_DESCRIPTOR register. + * + * Results: + * If numDescriptors is zero, returns zero. otherwise, returns + * a physical page number. + * + * Side effects: + * Allocates (and never frees) memory for the GMR descriptor. + * + *----------------------------------------------------------------------------- + */ + +PPN +GMR_AllocDescriptor(SVGAGuestMemDescriptor *descArray, + uint32 numDescriptors) +{ + const uint32 descPerPage = PAGE_SIZE / sizeof(SVGAGuestMemDescriptor) - 1; + SVGAGuestMemDescriptor *desc = NULL; + PPN firstPage = 0; + PPN page = 0; + int i = 0; + + while (numDescriptors) { + if (!firstPage) { + firstPage = page = Heap_AllocPages(1); + } + + desc = PPN_POINTER(page); + + if (i == descPerPage) { + /* + * Terminate this page with a pointer to the next one. + */ + page = Heap_AllocPages(1); + desc[i].ppn = page; + desc[i].numPages = 0; + i = 0; + continue; + } + + desc[i] = *descArray; + i++; + descArray++; + numDescriptors--; + } + + if (desc) { + /* Terminate the end of the descriptor list. */ + desc[i].ppn = 0; + desc[i].numPages = 0; + } + + return firstPage; +} + + +/* + *----------------------------------------------------------------------------- + * + * GMR_Define -- + * + * Initialize a GMR, using a flat array of descriptors. The array + * is copied into a set of physically discontiguous pages, which we + * give the host. + * + * Results: + * None. + * + * Side effects: + * Defines or redefines a GMR in the SVGA device. + * Allocates (and never frees) memory for the GMR descriptor. + * + *----------------------------------------------------------------------------- + */ + +void +GMR_Define(uint32 gmrId, + SVGAGuestMemDescriptor *descArray, + uint32 numDescriptors) +{ + PPN desc = GMR_AllocDescriptor(descArray, numDescriptors); + + /* + * Define/undefine the GMR. Defining an empty GMR is equivalent to + * undefining a GMR. + */ + + SVGA_WriteReg(SVGA_REG_GMR_ID, gmrId); + SVGA_WriteReg(SVGA_REG_GMR_DESCRIPTOR, desc); + + if (desc) { + /* + * Clobber the first page, to verify that the device reads our + * descriptors synchronously when we write the GMR registers. + */ + Heap_DiscardPages(desc, 1); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * GMR_DefineContiguous -- + * + * Allocate and define a physically contiguous GMR, consisting of a + * single SVGAGuestMemDescriptor. + * + * Results: + * Returns the first PPN of the allocated GMR region. All of + * 'numPages' subsequent PPNs are also part of the GMR. + * + * Side effects: + * Allocates and never frees memory for the GMR descriptor and for + * the GMR contents itself. + * + *----------------------------------------------------------------------------- + */ + +PPN +GMR_DefineContiguous(uint32 gmrId, uint32 numPages) +{ + SVGAGuestMemDescriptor desc = { + .ppn = Heap_AllocPages(numPages), + .numPages = numPages, + }; + + GMR_Define(gmrId, &desc, 1); + + return desc.ppn; +} + + +/* + *----------------------------------------------------------------------------- + * + * GMR_DefineEvenPages -- + * + * Define a worst-case discontiguous GMR, in which we map only the + * even pages. This allocates twice numPages, and creates a GMR + * which skips every other page. To be extra annoying, we also + * make sure that descriptors are allocated on physically + * discontiguous pages. + * + * Results: + * Returns the first PPN of the allocated GMR region. All of + * 'numPages*2' subsequent PPNs have been allocated, but only + * the even-numbered pages in that sequence are mapped into the GMR. + * + * Side effects: + * Allocates and never frees memory for the GMR descriptor and for + * the GMR contents itself. + * + *----------------------------------------------------------------------------- + */ + +PPN +GMR_DefineEvenPages(uint32 gmrId, uint32 numPages) +{ + SVGAGuestMemDescriptor *desc; + PPN region = Heap_AllocPages(numPages * 2); + int i; + + desc = Heap_Alloc(sizeof *desc * numPages); + + for (i = 0; i < numPages; i++) { + desc[i].ppn = region + i*2; + desc[i].numPages = 1; + } + + GMR_Define(gmrId, desc, numPages); + + return region; +} + + +/* + *----------------------------------------------------------------------------- + * + * GMR_FreeAll -- + * + * Undefine all GMRs. + * + * This frees device resources, but it doesn't actually free + * any memory from our trivial heap. If you are done with the + * heap, call Heap_Reset() separately. + * + * Results: + * None. + * + * Side effects: + * Undefines GMRs. + * + *----------------------------------------------------------------------------- + */ + +void +GMR_FreeAll(void) +{ + uint32 id; + + for (id = 0; id < gGMR.maxIds; id++) { + GMR_Define(id, NULL, 0); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * GMR_Init -- + * + * Read GMR capabilities, or panic of GMRs aren't supported. + * + * Results: + * None. + * + * Side effects: + * Fills in 'gGMR'. + * + *----------------------------------------------------------------------------- + */ + +void +GMR_Init(void) +{ + if (gSVGA.capabilities & SVGA_CAP_GMR) { + gGMR.maxIds = SVGA_ReadReg(SVGA_REG_GMR_MAX_IDS); + gGMR.maxDescriptorLen = SVGA_ReadReg(SVGA_REG_GMR_MAX_DESCRIPTOR_LENGTH); + } else { + SVGA_Panic("Virtual device does not have Guest Memory Region (GMR) support."); + } +} diff --git a/lib/refdriver/gmr.h b/lib/refdriver/gmr.h new file mode 100644 index 0000000..34b4433 --- /dev/null +++ b/lib/refdriver/gmr.h @@ -0,0 +1,102 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * gmr.h -- + * + * Utilities for creating and Guest Memory Regions (GMRs) + */ + +#ifndef __GMR_H__ +#define __GMR_H__ + + +/* + * Macros for physical memory pages, in our flat memory model. + * Physical Page Numbers (PPNs) are identity-mapped to virtual + * addresses in Metalkit. + */ + +#define PAGE_SIZE 4096 +#define PAGE_MASK (PAGE_SIZE - 1) +#define PPN_POINTER(ppn) ((void*)((ppn)*PAGE_SIZE)) +typedef uint32 PPN; + + +/* + * Global GMR state, read in by GMR_Init. + */ + +typedef struct GMRState { + uint32 maxIds; + uint32 maxDescriptorLen; +} GMRState; + +extern GMRState gGMR; + + +/* + * Trivial memory heap, used as system memory backings for GMRs. We + * never actually free any memory, we just allocate starting from the + * top of the binary image and we grow upward until we hit physical + * memory which isn't present. + */ + +void Heap_Reset(void); +void *Heap_Alloc(uint32 bytes); +PPN Heap_AllocPages(uint32 numPages); +void Heap_Discard(void *data, uint32 bytes); +void Heap_DiscardPages(PPN firstPage, uint32 numPages); + + +/* + * Read GMR capabilities into gGMR, and Panic if GMRs are not + * supported. + */ + +void GMR_Init(void); + + +/* + * Creating GMR descriptors. + */ + +PPN GMR_AllocDescriptor(SVGAGuestMemDescriptor *descArray, + uint32 numDescriptors); + + +/* + * Creating/destroying GMRs + */ + +void GMR_Define(uint32 gmrId, + SVGAGuestMemDescriptor *descArray, + uint32 numDescriptors); +PPN GMR_DefineContiguous(uint32 gmrId, uint32 numPages); +PPN GMR_DefineEvenPages(uint32 gmrId, uint32 numPages); +void GMR_FreeAll(void); + + +#endif /* __GMR_H__ */ diff --git a/lib/refdriver/svga.c b/lib/refdriver/svga.c new file mode 100644 index 0000000..d332091 --- /dev/null +++ b/lib/refdriver/svga.c @@ -0,0 +1,1700 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga.c -- + * + * This is a simple example driver for the VMware SVGA device. + * It handles initialization, register accesses, low-level + * command FIFO writes, and host/guest synchronization. + */ + +#include "svga.h" +#include "pci.h" +#include "console_vga.h" +#include "io.h" +#include "intr.h" +#include "svga_reg.h" + +SVGADevice gSVGA; + +static void SVGAFIFOFull(void); +static void SVGAInterruptHandler(int vector); + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_Init -- + * + * Initialize the global SVGA device. This locates it on the PCI bus, + * negotiates device version, and maps the command FIFO and framebuffer + * memory. + * + * Intr_Init() must have already been called. If the SVGA device + * supports interrupts, this will initalize them. + * + * Does not switch video modes. + * + * Results: + * void. + * + * Side effects: + * Steals various IOspace and memory regions. + * In this example code they're constant addresses, but in reality + * you'll need to negotiate these with the operating system. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_Init(void) +{ + if (!PCI_FindDevice(PCI_VENDOR_ID_VMWARE, PCI_DEVICE_ID_VMWARE_SVGA2, + &gSVGA.pciAddr)) { + Console_Panic("No VMware SVGA device found."); + } + + /* + * Use the default base address for each memory region. + * We must map at least ioBase before using ReadReg/WriteReg. + */ + + PCI_SetMemEnable(&gSVGA.pciAddr, TRUE); + gSVGA.ioBase = PCI_GetBARAddr(&gSVGA.pciAddr, 0); + gSVGA.fbMem = (void*) PCI_GetBARAddr(&gSVGA.pciAddr, 1); + gSVGA.fifoMem = (void*) PCI_GetBARAddr(&gSVGA.pciAddr, 2); + + /* + * Version negotiation: + * + * 1. Write to SVGA_REG_ID the maximum ID supported by this driver. + * 2. Read from SVGA_REG_ID + * a. If we read back the same value, this ID is supported. We're done. + * b. If not, decrement the ID and repeat. + */ + + gSVGA.deviceVersionId = SVGA_ID_2; + do { + SVGA_WriteReg(SVGA_REG_ID, gSVGA.deviceVersionId); + if (SVGA_ReadReg(SVGA_REG_ID) == gSVGA.deviceVersionId) { + break; + } else { + gSVGA.deviceVersionId--; + } + } while (gSVGA.deviceVersionId >= SVGA_ID_0); + + if (gSVGA.deviceVersionId < SVGA_ID_0) { + Console_Panic("Error negotiating SVGA device version."); + } + + /* + * We must determine the FIFO and FB size after version + * negotiation, since the default version (SVGA_ID_0) + * does not support the FIFO buffer at all. + */ + + gSVGA.fbSize = SVGA_ReadReg(SVGA_REG_FB_SIZE); + gSVGA.fifoSize = SVGA_ReadReg(SVGA_REG_MEM_SIZE); + + /* + * Sanity-check the FIFO and framebuffer sizes. + * These are arbitrary values. + */ + + if (gSVGA.fbSize < 0x100000) { + SVGA_Panic("FB size very small, probably incorrect."); + } + if (gSVGA.fifoSize < 0x20000) { + SVGA_Panic("FIFO size very small, probably incorrect."); + } + + /* + * If the device is new enough to support capability flags, get the + * capabilities register. + */ + + if (gSVGA.deviceVersionId >= SVGA_ID_1) { + gSVGA.capabilities = SVGA_ReadReg(SVGA_REG_CAPABILITIES); + } + + /* + * Optional interrupt initialization. + * + * This uses the default IRQ that was assigned to our + * device by the BIOS. + */ + + if (gSVGA.capabilities & SVGA_CAP_IRQMASK) { + uint8 irq = PCI_ConfigRead8(&gSVGA.pciAddr, offsetof(PCIConfigSpace, intrLine)); + + /* Start out with all SVGA IRQs masked */ + SVGA_WriteReg(SVGA_REG_IRQMASK, 0); + + /* Clear all pending IRQs stored by the device */ + IO_Out32(gSVGA.ioBase + SVGA_IRQSTATUS_PORT, 0xFF); + + /* Clear all pending IRQs stored by us */ + SVGA_ClearIRQ(); + + /* Enable the IRQ */ + Intr_SetHandler(IRQ_VECTOR(irq), SVGAInterruptHandler); + Intr_SetMask(irq, TRUE); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_SetMode -- + * + * This switches to SVGA video mode, and enables the command FIFO. + * + * Results: + * void. + * + * Side effects: + * Switches modes. Disables legacy video modes (VGA, VBE). + * Clears the command FIFO, and asks the host to start processing it. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_SetMode(uint32 width, // IN + uint32 height, // IN + uint32 bpp) // IN +{ + gSVGA.width = width; + gSVGA.height = height; + gSVGA.bpp = bpp; + + SVGA_WriteReg(SVGA_REG_WIDTH, width); + SVGA_WriteReg(SVGA_REG_HEIGHT, height); + SVGA_WriteReg(SVGA_REG_BITS_PER_PIXEL, bpp); + SVGA_WriteReg(SVGA_REG_ENABLE, TRUE); + gSVGA.pitch = SVGA_ReadReg(SVGA_REG_BYTES_PER_LINE); + + /* + * Initialize the command FIFO. The beginning of FIFO memory is + * used for an additional set of registers, the "FIFO registers". + * These are higher-performance memory mapped registers which + * happen to live in the same space as the FIFO. The driver is + * responsible for allocating space for these registers, according + * to the maximum number of registers supported by this driver + * release. + */ + + gSVGA.fifoMem[SVGA_FIFO_MIN] = SVGA_FIFO_NUM_REGS * sizeof(uint32); + gSVGA.fifoMem[SVGA_FIFO_MAX] = gSVGA.fifoSize; + gSVGA.fifoMem[SVGA_FIFO_NEXT_CMD] = gSVGA.fifoMem[SVGA_FIFO_MIN]; + gSVGA.fifoMem[SVGA_FIFO_STOP] = gSVGA.fifoMem[SVGA_FIFO_MIN]; + + /* + * Prep work for 3D version negotiation. See SVGA3D_Init for + * details, but we have to give the host our 3D protocol version + * before enabling the FIFO. + */ + + if (SVGA_HasFIFOCap(SVGA_CAP_EXTENDED_FIFO) && + SVGA_IsFIFORegValid(SVGA_FIFO_GUEST_3D_HWVERSION)) { + + gSVGA.fifoMem[SVGA_FIFO_GUEST_3D_HWVERSION] = SVGA3D_HWVERSION_CURRENT; + } + + /* + * Enable the FIFO. + */ + + SVGA_WriteReg(SVGA_REG_CONFIG_DONE, TRUE); + + /* + * Now that the FIFO is initialized, we can do an IRQ sanity check. + * This makes sure that the VM's chipset and our own IRQ code + * works. Better to find out now if something's wrong, than to + * deadlock later. + * + * This inserts a FIFO fence, does a legacy sync to drain the FIFO, + * then ensures that we received all applicable interrupts. + */ + + if (gSVGA.capabilities & SVGA_CAP_IRQMASK) { + + SVGA_WriteReg(SVGA_REG_IRQMASK, SVGA_IRQFLAG_ANY_FENCE); + SVGA_ClearIRQ(); + + SVGA_InsertFence(); + + SVGA_WriteReg(SVGA_REG_SYNC, 1); + while (SVGA_ReadReg(SVGA_REG_BUSY) != FALSE); + + SVGA_WriteReg(SVGA_REG_IRQMASK, 0); + + /* Check whether the interrupt occurred without blocking. */ + if ((gSVGA.irq.pending & SVGA_IRQFLAG_ANY_FENCE) == 0) { + SVGA_Panic("SVGA IRQ appears to be present but broken."); + } + + SVGA_WaitForIRQ(); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_Disable -- + * + * Disable the SVGA portion of the video adapter, switching back + * to VGA mode. + * + * Results: + * void. + * + * Side effects: + * Switches modes. Disables the command FIFO, without flushing it. + * (Any commands still in the FIFO will be lost.) + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_Disable(void) +{ + SVGA_WriteReg(SVGA_REG_ENABLE, FALSE); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_Panic -- + * + * This is a Panic handler which works in SVGA mode. It disables SVGA, + * then executes the Console's panic handler. + * + * Results: + * Never returns. + * + * Side effects: + * Disables SVGA mode, initializes VGA text mode. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_Panic(const char *msg) // IN +{ + SVGA_Disable(); + ConsoleVGA_Init(); + Console_Panic(msg); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_DefaultFaultHandler -- + * + * This is a default fault handler which works in SVGA mode. It + * disables SVGA, then executes the Console's default fault + * handler. + * + * Results: + * Never returns. + * + * Side effects: + * Disables SVGA mode, initializes VGA text mode. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_DefaultFaultHandler(int vector) // IN +{ + SVGA_Disable(); + Console_UnhandledFault(vector); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_ReadReg -- + * + * Read an SVGA device register (SVGA_REG_*). + * This must be called after the PCI device's IOspace has been mapped. + * + * Results: + * 32-bit register value. + * + * Side effects: + * Depends on the register value. Some special registers + * like SVGA_REG_BUSY have significant side-effects. + * + *----------------------------------------------------------------------------- + */ + +uint32 +SVGA_ReadReg(uint32 index) // IN +{ + IO_Out32(gSVGA.ioBase + SVGA_INDEX_PORT, index); + return IO_In32(gSVGA.ioBase + SVGA_VALUE_PORT); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_WriteReg -- + * + * Write an SVGA device register (SVGA_REG_*). + * This must be called after the PCI device's IOspace has been mapped. + * + * Results: + * void. + * + * Side effects: + * Depends on the register value. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_WriteReg(uint32 index, // IN + uint32 value) // IN +{ + IO_Out32(gSVGA.ioBase + SVGA_INDEX_PORT, index); + IO_Out32(gSVGA.ioBase + SVGA_VALUE_PORT, value); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_IsFIFORegValid -- + * + * Check whether space has been allocated for a particular FIFO register. + * + * This isn't particularly useful for our simple examples, since the + * same binary is responsible for both allocating and using the FIFO, + * but a real driver may need to check this if the module which handles + * initialization and mode switches is separate from the module which + * actually writes to the FIFO. + * + * Results: + * TRUE if the register has been allocated, FALSE if the register + * does not exist. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +Bool +SVGA_IsFIFORegValid(int reg) +{ + return gSVGA.fifoMem[SVGA_FIFO_MIN] > (reg << 2); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_HasFIFOCap -- + * + * Check whether the SVGA device has a particular FIFO capability bit. + * + * Results: + * TRUE if the capability is present, FALSE if it's absent. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +Bool +SVGA_HasFIFOCap(int cap) +{ + return (gSVGA.fifoMem[SVGA_FIFO_CAPABILITIES] & cap) != 0; +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_FIFOReserve -- + * + * Begin writing a command to the FIFO buffer. There are several + * examples floating around which show how to write to the FIFO + * buffer, but this is the preferred method: write directly to + * FIFO memory in the common case, but if the command would not + * be contiguous, use a bounce buffer. + * + * This method is easy to use, and quite fast. The X.org driver + * does not yet use this method, but recent Windows drivers use + * it. + * + * The main principles here are: + * + * - There are multiple code paths. In the best case, we write + * directly to the FIFO. In the next-best case, we use a + * static bounce buffer. If you need to support arbitrarily + * large commands, you can have a worst case in which you use + * a dynamically sized bounce buffer. + * + * - We must tell the host that we're reserving FIFO + * space. This is important because the device doesn't + * guarantee it will preserve the contents of FIFO memory + * which hasn't been reserved. If we write to a totally + * unused portion of the FIFO and the VM is suspended, on + * resume that data will no longer exist. + * + * This function is not re-entrant. If your driver is + * multithreaded or may be used from multiple processes + * concurrently, you must make sure to serialize all FIFO + * commands. + * + * The caller must pair this command with SVGA_FIFOCommit or + * SVGA_FIFOCommitAll. + * + * Results: + * Returns a pointer to the location where the FIFO command can + * be written. There will be room for at least 'bytes' bytes of + * data. + * + * Side effects: + * Begins a FIFO command, reserves space in the FIFO. + * May block (in SVGAFIFOFull) if the FIFO is full. + * + *----------------------------------------------------------------------------- + */ + +void * +SVGA_FIFOReserve(uint32 bytes) // IN +{ + volatile uint32 *fifo = gSVGA.fifoMem; + uint32 max = fifo[SVGA_FIFO_MAX]; + uint32 min = fifo[SVGA_FIFO_MIN]; + uint32 nextCmd = fifo[SVGA_FIFO_NEXT_CMD]; + Bool reserveable = SVGA_HasFIFOCap(SVGA_FIFO_CAP_RESERVE); + + /* + * This example implementation uses only a statically allocated + * buffer. If you want to support arbitrarily large commands, + * dynamically allocate a buffer if and only if it's necessary. + */ + + if (bytes > sizeof gSVGA.fifo.bounceBuffer || + bytes > (max - min)) { + SVGA_Panic("FIFO command too large"); + } + + if (bytes % sizeof(uint32)) { + SVGA_Panic("FIFO command length not 32-bit aligned"); + } + + if (gSVGA.fifo.reservedSize != 0) { + SVGA_Panic("FIFOReserve before FIFOCommit"); + } + + gSVGA.fifo.reservedSize = bytes; + + while (1) { + uint32 stop = fifo[SVGA_FIFO_STOP]; + Bool reserveInPlace = FALSE; + Bool needBounce = FALSE; + + /* + * Find a strategy for dealing with "bytes" of data: + * - reserve in place, if there's room and the FIFO supports it + * - reserve in bounce buffer, if there's room in FIFO but not + * contiguous or FIFO can't safely handle reservations + * - otherwise, sync the FIFO and try again. + */ + + if (nextCmd >= stop) { + /* There is no valid FIFO data between nextCmd and max */ + + if (nextCmd + bytes < max || + (nextCmd + bytes == max && stop > min)) { + /* + * Fastest path 1: There is already enough contiguous space + * between nextCmd and max (the end of the buffer). + * + * Note the edge case: If the "<" path succeeds, we can + * quickly return without performing any other tests. If + * we end up on the "==" path, we're writing exactly up to + * the top of the FIFO and we still need to make sure that + * there is at least one unused DWORD at the bottom, in + * order to be sure we don't fill the FIFO entirely. + * + * If the "==" test succeeds, but stop <= min (the FIFO + * would be completely full if we were to reserve this + * much space) we'll end up hitting the FIFOFull path below. + */ + reserveInPlace = TRUE; + } else if ((max - nextCmd) + (stop - min) <= bytes) { + /* + * We have to split the FIFO command into two pieces, + * but there still isn't enough total free space in + * the FIFO to store it. + * + * Note the "<=". We need to keep at least one DWORD + * of the FIFO free at all times, or we won't be able + * to tell the difference between full and empty. + */ + SVGAFIFOFull(); + } else { + /* + * Data fits in FIFO but only if we split it. + * Need to bounce to guarantee contiguous buffer. + */ + needBounce = TRUE; + } + + } else { + /* There is FIFO data between nextCmd and max */ + + if (nextCmd + bytes < stop) { + /* + * Fastest path 2: There is already enough contiguous space + * between nextCmd and stop. + */ + reserveInPlace = TRUE; + } else { + /* + * There isn't enough room between nextCmd and stop. + * The FIFO is too full to accept this command. + */ + SVGAFIFOFull(); + } + } + + /* + * If we decided we can write directly to the FIFO, make sure + * the VMX can safely support this. + */ + if (reserveInPlace) { + if (reserveable || bytes <= sizeof(uint32)) { + gSVGA.fifo.usingBounceBuffer = FALSE; + if (reserveable) { + fifo[SVGA_FIFO_RESERVED] = bytes; + } + return nextCmd + (uint8*) fifo; + } else { + /* + * Need to bounce because we can't trust the VMX to safely + * handle uncommitted data in FIFO. + */ + needBounce = TRUE; + } + } + + /* + * If we reach here, either we found a full FIFO, called + * SVGAFIFOFull to make more room, and want to try again, or we + * decided to use a bounce buffer instead. + */ + if (needBounce) { + gSVGA.fifo.usingBounceBuffer = TRUE; + return gSVGA.fifo.bounceBuffer; + } + } /* while (1) */ +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_FIFOCommit -- + * + * Commit a block of FIFO data which was placed in the buffer + * returned by SVGA_FIFOReserve. Every Reserve must be paired + * with exactly one Commit, but the sizes don't have to match. + * The caller is free to commit less space than they + * reserved. This can be used if the command size isn't known in + * advance, but it is reasonable to make a worst-case estimate. + * + * The commit size does not have to match the size of a single + * FIFO command. This can be used to write a partial command, or + * to write multiple commands at once. + * + * Results: + * None. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_FIFOCommit(uint32 bytes) // IN +{ + volatile uint32 *fifo = gSVGA.fifoMem; + uint32 nextCmd = fifo[SVGA_FIFO_NEXT_CMD]; + uint32 max = fifo[SVGA_FIFO_MAX]; + uint32 min = fifo[SVGA_FIFO_MIN]; + Bool reserveable = SVGA_HasFIFOCap(SVGA_FIFO_CAP_RESERVE); + + if (gSVGA.fifo.reservedSize == 0) { + SVGA_Panic("FIFOCommit before FIFOReserve"); + } + gSVGA.fifo.reservedSize = 0; + + if (gSVGA.fifo.usingBounceBuffer) { + /* + * Slow paths: copy out of a bounce buffer. + */ + uint8 *buffer = gSVGA.fifo.bounceBuffer; + + if (reserveable) { + /* + * Slow path: bulk copy out of a bounce buffer in two chunks. + * + * Note that the second chunk may be zero-length if the reserved + * size was large enough to wrap around but the commit size was + * small enough that everything fit contiguously into the FIFO. + * + * Note also that we didn't need to tell the FIFO about the + * reservation in the bounce buffer, but we do need to tell it + * about the data we're bouncing from there into the FIFO. + */ + + uint32 chunkSize = MIN(bytes, max - nextCmd); + fifo[SVGA_FIFO_RESERVED] = bytes; + memcpy(nextCmd + (uint8*) fifo, buffer, chunkSize); + memcpy(min + (uint8*) fifo, buffer + chunkSize, bytes - chunkSize); + + } else { + /* + * Slowest path: copy one dword at a time, updating NEXT_CMD as + * we go, so that we bound how much data the guest has written + * and the host doesn't know to checkpoint. + */ + + uint32 *dword = (uint32 *)buffer; + + while (bytes > 0) { + fifo[nextCmd / sizeof *dword] = *dword++; + nextCmd += sizeof *dword; + if (nextCmd == max) { + nextCmd = min; + } + fifo[SVGA_FIFO_NEXT_CMD] = nextCmd; + bytes -= sizeof *dword; + } + } + } + + /* + * Atomically update NEXT_CMD, if we didn't already + */ + if (!gSVGA.fifo.usingBounceBuffer || reserveable) { + nextCmd += bytes; + if (nextCmd >= max) { + nextCmd -= max - min; + } + fifo[SVGA_FIFO_NEXT_CMD] = nextCmd; + } + + /* + * Clear the reservation in the FIFO. + */ + if (reserveable) { + fifo[SVGA_FIFO_RESERVED] = 0; + } +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_FIFOCommitAll -- + * + * This is a convenience wrapper for SVGA_FIFOCommit(), which + * always commits the last reserved block in its entirety. + * + * Results: + * None. + * + * Side effects: + * SVGA_FIFOCommit. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_FIFOCommitAll(void) +{ + SVGA_FIFOCommit(gSVGA.fifo.reservedSize); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_FIFOReserveCmd -- + * + * This is a convenience wrapper around SVGA_FIFOReserve, which + * prefixes the reserved memory block with a uint32 that + * indicates the command type. + * + * Results: + * Always returns a pointer to 'bytes' bytes of reserved space in the FIFO. + * + * Side effects: + * Begins a FIFO command, reserves space in the FIFO. Writes a + * 1-word header into the FIFO. May block (in SVGAFIFOFull) if + * the FIFO is full. + * + *----------------------------------------------------------------------------- + */ + +void * +SVGA_FIFOReserveCmd(uint32 type, // IN + uint32 bytes) // IN +{ + uint32 *cmd = SVGA_FIFOReserve(bytes + sizeof type); + cmd[0] = type; + return cmd + 1; +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_FIFOReserveEscape -- + * + * This is a convenience wrapper around SVGA_FIFOReserve, which + * prefixes the reserved memory block with an ESCAPE command header. + * + * ESCAPE commands are a way of encoding extensible and + * variable-length packets within the basic FIFO protocol + * itself. ESCAPEs are used for some SVGA device functionality, + * like video overlays, for VMware's internal debugging tools, + * and for communicating with third party code that can load into + * the SVGA device. + * + * Results: + * Always returns a pointer to 'bytes' bytes of reserved space in the FIFO. + * + * Side effects: + * Begins a FIFO command, reserves space in the FIFO. Writes a + * 3-word header into the FIFO. May block (in SVGAFIFOFull) if + * the FIFO is full. + * + *----------------------------------------------------------------------------- + */ + +void * +SVGA_FIFOReserveEscape(uint32 nsid, // IN + uint32 bytes) // IN +{ + uint32 paddedBytes = (bytes + 3) & ~3UL; + struct { + uint32 cmd; + uint32 nsid; + uint32 size; + } __attribute__ ((__packed__)) *header = SVGA_FIFOReserve(paddedBytes + + sizeof *header); + + header->cmd = SVGA_CMD_ESCAPE; + header->nsid = nsid; + header->size = bytes; + + return header + 1; +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGAFIFOFull -- + * + * This function is called repeatedly as long as the FIFO has too + * little free space for us to continue. + * + * The simplest implementation of this function is a no-op. This + * will just burn guest CPU until space is available. (That's a + * bad idea, since the host probably needs that CPU in order to + * make progress on emptying the FIFO.) + * + * A better implementation would sleep until a FIFO progress + * interrupt occurs. Depending on the OS you're writing drivers + * for, this may deschedule the calling task or it may simply put + * the CPU to sleep. + * + * Results: + * None. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +void +SVGAFIFOFull(void) +{ + if (SVGA_IsFIFORegValid(SVGA_FIFO_FENCE_GOAL) && + (gSVGA.capabilities & SVGA_CAP_IRQMASK)) { + + /* + * On hosts which support interrupts, we can sleep until the + * FIFO_PROGRESS interrupt occurs. This is the most efficient + * thing to do when the FIFO fills up. + * + * As with the IRQ-based SVGA_SyncToFence(), this will only work + * on Workstation 6.5 virtual machines and later. + */ + + SVGA_WriteReg(SVGA_REG_IRQMASK, SVGA_IRQFLAG_FIFO_PROGRESS); + SVGA_ClearIRQ(); + SVGA_RingDoorbell(); + SVGA_WaitForIRQ(); + SVGA_WriteReg(SVGA_REG_IRQMASK, 0); + + } else { + + /* + * Fallback implementation: Perform one iteration of the + * legacy-style sync. This synchronously processes FIFO commands + * for an arbitrary amount of time, then returns control back to + * the guest CPU. + */ + + SVGA_WriteReg(SVGA_REG_SYNC, 1); + SVGA_ReadReg(SVGA_REG_BUSY); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_InsertFence -- + * + * Write a new fence value to the FIFO. + * + * Fences are the basis of the SVGA device's synchronization + * model. A fence is a marker inserted into the FIFO by the + * guest. The host processes all FIFO commands in order. Once the + * fence is reached, the host does two things: + * + * - The fence value is written to the SVGA_FIFO_FENCE register. + * - Optionally, an interrupt is raised. + * + * There are multiple ways to use fences for synchronization. See + * SVGA_SyncToFence and SVGA_HasFencePassed. + * + * Results: + * + * Returns the value of the fence we inserted. Fence values + * increment, wrapping around at 32 bits. Fence value zero is + * reserved to mean "no fence". This function never returns zero. + * + * Certain very old versions of the VMware SVGA device do not + * support fences. On these devices, we always return 1. On these + * devices, SyncToFence will always do a full Sync and + * SyncToFence will always return FALSE, so the actual fence + * value we use is unimportant. Code written to use fences will + * run inefficiently, but it will still be correct. + * + * Side effects: + * Writes to the FIFO. Increments our nextFence. + * + *----------------------------------------------------------------------------- + */ + +uint32 +SVGA_InsertFence(void) +{ + uint32 fence; + + struct { + uint32 id; + uint32 fence; + } __attribute__ ((__packed__)) *cmd; + + if (!SVGA_HasFIFOCap(SVGA_FIFO_CAP_FENCE)) { + return 1; + } + + if (gSVGA.fifo.nextFence == 0) { + gSVGA.fifo.nextFence = 1; + } + fence = gSVGA.fifo.nextFence++; + + cmd = SVGA_FIFOReserve(sizeof *cmd); + cmd->id = SVGA_CMD_FENCE; + cmd->fence = fence; + SVGA_FIFOCommitAll(); + + return fence; +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_SyncToFence -- + * + * Sleep until the SVGA device has processed all FIFO commands + * prior to the insertion point of the specified fence. + * + * This is the most important way to maintain synchronization + * between the driver and the SVGA3D device itself. It can be + * used to provide flow control between the host and the guest, + * or to ensure that DMA operations have completed before reusing + * guest memory. + * + * If the provided fence is zero or it has already passed, + * this is a no-op. + * + * If the SVGA device and virtual machine hardware version are + * both new enough (Workstation 6.5 or later), this will use an + * efficient interrupt-driven mechanism to sleep until just after + * the host processes the fence. + * + * If not, this will use a less efficient synchronization + * mechanism which may require the host to process significantly + * more of the FIFO than is necessary. + * + * Results: + * void. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_SyncToFence(uint32 fence) // IN +{ + if (!fence) { + return; + } + + if (!SVGA_HasFIFOCap(SVGA_FIFO_CAP_FENCE)) { + /* + * Fall back on the legacy sync if the host does not support + * fences. This is the old sync mechanism that has been + * supported in the SVGA device pretty much since the dawn of + * time: write to the SYNC register, then read from BUSY until + * it's nonzero. This will drain the entire FIFO. + * + * The parameter we write to SVGA_REG_SYNC is an arbitrary + * nonzero value which can be used for debugging, but which is + * ignored by release builds of VMware products. + */ + + SVGA_WriteReg(SVGA_REG_SYNC, 1); + while (SVGA_ReadReg(SVGA_REG_BUSY) != FALSE); + return; + } + + if (SVGA_HasFencePassed(fence)) { + /* + * Nothing to do + */ + + return; + } + + if (SVGA_IsFIFORegValid(SVGA_FIFO_FENCE_GOAL) && + (gSVGA.capabilities & SVGA_CAP_IRQMASK)) { + + /* + * On hosts which support interrupts and which support the + * FENCE_GOAL interrupt, we can use our preferred + * synchronization mechanism. + * + * This provides low latency notification both from guest to + * host and from host to guest, and it doesn't block the guest + * while we're waiting. + * + * This will only work on Workstation 6.5 virtual machines + * or later. Older virtual machines did not allocate an IRQ + * for the SVGA device, and the IRQMASK capability will be + * unset. + */ + + /* + * Set the fence goal. This asks the host to send an interrupt + * when this specific fence has been reached. + */ + + gSVGA.fifoMem[SVGA_FIFO_FENCE_GOAL] = fence; + SVGA_WriteReg(SVGA_REG_IRQMASK, SVGA_IRQFLAG_FENCE_GOAL); + + SVGA_ClearIRQ(); + + /* + * Must check again, in case we reached the fence between the + * first HasFencePassed and when we set up the IRQ. + * + * As a small performance optimization, we check yet again after + * RingDoorbell, since there's a chance that RingDoorbell will + * deschedule this VM and process some SVGA FIFO commands in a + * way that appears synchronous from the VM's point of view. + */ + + if (!SVGA_HasFencePassed(fence)) { + /* + * We're about to go to sleep. Make sure the host is awake. + */ + SVGA_RingDoorbell(); + + if (!SVGA_HasFencePassed(fence)) { + SVGA_WaitForIRQ(); + } + } + + SVGA_WriteReg(SVGA_REG_IRQMASK, 0); + + } else { + /* + * Sync-to-fence mechanism for older hosts. Wake up the host, + * and spin on BUSY until we've reached the fence. This + * processes FIFO commands synchronously, blocking the VM's + * execution entirely until it's done. + */ + + Bool busy = TRUE; + + SVGA_WriteReg(SVGA_REG_SYNC, 1); + + while (!SVGA_HasFencePassed(fence) && busy) { + busy = (SVGA_ReadReg(SVGA_REG_BUSY) != 0); + } + } + + if (!SVGA_HasFencePassed(fence)) { + /* + * This shouldn't happen. If it does, there might be a bug in + * the SVGA device. + */ + SVGA_Panic("SyncToFence failed!"); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_HasFencePassed -- + * + * Test whether the host has processed all FIFO commands prior to + * the insertion point of the specified fence. + * + * This function tolerates fence wrap-around, but it will return + * the wrong result if 'fence' is more than 2^31 fences old. It + * is recommended that callers don't allow fence values to + * persist indefinitely. Once we notice that a fence has been + * passed, that fence variable should be set to zero so we don't + * test it in the future. + * + * Results: + * TRUE if the fence has been passed, + * TRUE if fence==0 (no fence), + * FALSE if the fence has not been passed, + * FALSE if the SVGA device does not support fences. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +Bool +SVGA_HasFencePassed(uint32 fence) // IN +{ + if (!fence) { + return TRUE; + } + + if (!SVGA_HasFIFOCap(SVGA_FIFO_CAP_FENCE)) { + return FALSE; + } + + return ((int32)(gSVGA.fifoMem[SVGA_FIFO_FENCE] - fence)) >= 0; +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_RingDoorbell -- + * + * FIFO fences are fundamentally a host-to-guest notification + * mechanism. This is the opposite: we can explicitly wake up + * the host when we know there is work for it to do. + * + * Background: The host processes the SVGA command FIFO in a + * separate thread which runs asynchronously with the virtual + * machine's CPU and other I/O devices. When the SVGA device is + * idle, this thread is sleeping. It periodically wakes up to + * poll for new commands. This polling must occur for various + * reasons, but it's mostly related to the historical way in + * which the SVGA device processes 2D updates. + * + * This polling introduces significant latency between when the + * first new command is placed in an empty FIFO, and when the + * host begins processing it. Normally this isn't a huge problem + * since the host and guest run fairly asynchronously, but in + * a synchronization-heavy workload this can be a bottleneck. + * + * For example, imagine an application with a worst-case + * synchronization bottleneck: The guest enqueues a single FIFO + * command, then waits for that command to finish using + * SyncToFence, then the guest spends a little time doing + * CPU-intensive processing before the cycle repeats. The + * workload may be latency-bound if the host-to-guest or + * guest-to-host notifications ever block. + * + * One solution would be for the guest to explicitly wake up the + * SVGA3D device any time a command is enqueued. This would solve + * the latency bottleneck above, but it would be inefficient on + * single-CPU host machines. One could easily imagine a situation + * in which we wake up the host after enqueueing one FIFO + * command, the physical CPU context switches to the SVGA + * device's thread, the single command is processed, then we + * context switch back to running guest code. + * + * Our recommended solution is to wake up the host only either: + * + * - After a "significant" amount of work has been enqueued into + * the FIFO. For example, at least one 3D drawing command. + * + * - After a complete frame has been rendered. + * + * - Just before the guest sleeps for any reason. + * + * This function implements the above guest wakeups. It uses the + * SVGA_FIFO_BUSY register to quickly assess whether the SVGA + * device may be idle. If so, it asynchronously wakes up the host + * by writing to SVGA_REG_SYNC. + * + * Results: + * None. + * + * Side effects: + * May wake up the SVGA3D device. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_RingDoorbell(void) +{ + if (SVGA_IsFIFORegValid(SVGA_FIFO_BUSY) && + gSVGA.fifoMem[SVGA_FIFO_BUSY] == FALSE) { + + /* Remember that we already rang the doorbell. */ + gSVGA.fifoMem[SVGA_FIFO_BUSY] = TRUE; + + /* + * Asynchronously wake up the SVGA3D device. The second + * parameter is an arbitrary nonzero 'sync reason' which can be + * used for debugging, but which isn't part of the SVGA3D + * protocol proper and which isn't used by release builds of + * VMware products. + */ + SVGA_WriteReg(SVGA_REG_SYNC, 1); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_ClearIRQ -- + * + * Clear all pending IRQs. Any IRQs which occurred prior to this + * function call will be ignored by the next SVGA_WaitForIRQ() + * call. + * + * Does not affect the current IRQ mask. This function is not + * useful unless the SVGA device has IRQ support. + * + * Results: + * Returns a mask of all the interrupt flags that were set prior + * to the clear. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +uint32 +SVGA_ClearIRQ(void) +{ + uint32 flags = 0; + Atomic_Exchange(gSVGA.irq.pending, flags); + return flags; +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_WaitForIRQ -- + * + * Sleep until an SVGA interrupt occurs. When we wake up, return + * a mask of all SVGA IRQs which occurred while we were asleep. + * + * The design of this function will be different for every OS, + * but it is imperative that you ensure it will work properly + * no matter when the interrupt actually occurs. The IRQ could have + * already happened (any time since the last ClearIRQ, it could + * happen while this function is running, or it could happen + * after we decide to sleep. + * + * In this example: + * + * 1. If the IRQ occurred before this function was called, + * the bit will already be set in irq.pending. We can return. + * + * 2. If the IRQ occurs while this function is executing, we + * ask our IRQ handler to do a light-weight context switch + * back to the beginning of this function, so we can + * re-examine irq.pending before sleeping. + * + * 3. If the IRQ occurs while we're sleeping, we wake up + * from the HLT instruction and re-test irq.pending. + * + * Results: + * Returns a mask of all the interrupt flags that were set prior + * to the clear. This will always be nonzero. + * + * Side effects: + * Clears the irq.pending flags for exactly the set of IRQs we return. + * + *----------------------------------------------------------------------------- + */ + +static __attribute__ ((noinline)) uint32 +SVGAWaitForIRQInternal(void *arg, ...) +{ + uint32 flags = 0; + + gSVGA.irq.switchContext = TRUE; + + Atomic_Exchange(gSVGA.irq.pending, flags); + + if (!flags) { + Intr_Halt(); + } + + gSVGA.irq.switchContext = FALSE; + return flags; +} + +uint32 +SVGA_WaitForIRQ(void) +{ + uint32 flags; + + /* + * Store this CPU context, and tell the IRQ handler to return + * here if an IRQ occurs. We use IntrContext here just like a + * setjmp/longjmp that works in ISRs. + * + * This must be above the irq.pending check, so that we re-test + * irq.pending if an IRQ occurs after testing irq.pending but + * before we halt. Without this, we could deadlock if an IRQ + * comes in before we actually halt but after we've decided to + * halt. + */ + + Intr_SaveContext(&gSVGA.irq.newContext); + + do { + + /* + * XXX: The arguments here are a kludge to prevent the interrupt + * stack frame from overlapping the stack frame referenced + * by Intr_SaveContext(). + */ + flags = SVGAWaitForIRQInternal(NULL, NULL, NULL, NULL); + + } while (flags == 0); + + return flags; +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGAInterruptHandler -- + * + * This is the ISR for the SVGA device's interrupt. We ask the + * SVGA device which interrupt occurred, and clear its flag. + * + * To report this IRQ to the rest of the driver, we: + * + * 1. Atomically remember the IRQ in the irq.pending bitmask. + * + * 2. Optionally switch to a different light-weight thread + * or a different place in this thread upon returning. + * This is analogous to waking up a sleeping thread in + * a driver for a real operating system. See SVGA_WaitForIRQ + * for details. + * + * Results: + * void. + * + * Side effects: + * Sets bits in pendingIRQs. Reads and clears the device's IRQ flags. + * May switch execution contexts. + * + *----------------------------------------------------------------------------- + */ + +void +SVGAInterruptHandler(int vector) // IN (unused) +{ + volatile IntrContext *context = Intr_GetContext(vector); + + /* + * The SVGA_IRQSTATUS_PORT is a separate I/O port, not a register. + * Reading from it gives us the set of IRQ flags which are + * set. Writing a '1' to any bit in this register will clear the + * corresponding flag. + * + * Here, we read then clear all flags. + */ + + uint16 port = gSVGA.ioBase + SVGA_IRQSTATUS_PORT; + uint32 irqFlags = IO_In32(port); + IO_Out32(port, irqFlags); + + gSVGA.irq.count++; + + if (!irqFlags) { + SVGA_Panic("Spurious SVGA IRQ"); + } + + Atomic_Or(gSVGA.irq.pending, irqFlags); + + if (gSVGA.irq.switchContext) { + gSVGA.irq.oldContext = *context; + *context = gSVGA.irq.newContext; + gSVGA.irq.switchContext = FALSE; + } +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_Update -- + * + * Send a 2D update rectangle through the FIFO. + * + * Results: + * None. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_Update(uint32 x, // IN + uint32 y, // IN + uint32 width, // IN + uint32 height) // IN +{ + SVGAFifoCmdUpdate *cmd = SVGA_FIFOReserveCmd(SVGA_CMD_UPDATE, sizeof *cmd); + cmd->x = x; + cmd->y = y; + cmd->width = width; + cmd->height = height; + SVGA_FIFOCommitAll(); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_BeginDefineCursor -- + * + * Begin an SVGA_CMD_DEFINE_CURSOR command. This copies the command header + * into the FIFO, and reserves enough space for the cursor image itself. + * We return pointers to FIFO memory where the AND/XOR masks can be written. + * When finished, the caller must invoke SVGA_FIFOCommitAll(). + * + * Results: + * Returns pointers to memory where the caller can store the AND/XOR masks. + * + * Side effects: + * Reserves space in the FIFO. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_BeginDefineCursor(const SVGAFifoCmdDefineCursor *cursorInfo, // IN + void **andMask, // OUT + void **xorMask) // OUT +{ + uint32 andPitch = ((cursorInfo->andMaskDepth * cursorInfo->width + 31) >> 5) << 2; + uint32 andSize = andPitch * cursorInfo->height; + uint32 xorPitch = ((cursorInfo->xorMaskDepth * cursorInfo->width + 31) >> 5) << 2; + uint32 xorSize = xorPitch * cursorInfo->height; + + SVGAFifoCmdDefineCursor *cmd = SVGA_FIFOReserveCmd(SVGA_CMD_DEFINE_CURSOR, + sizeof *cmd + andSize + xorSize); + *cmd = *cursorInfo; + *andMask = (void*) (cmd + 1); + *xorMask = (void*) (andSize + (uint8*) *andMask); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_BeginDefineAlphaCursor -- + * + * Begin an SVGA_CMD_DEFINE_ALPHA_CURSOR command. This copies the + * command header into the FIFO, and reserves enough space for + * the cursor image itself. We return a pointer to the FIFO + * memory where the caller should write a pre-multiplied BGRA + * image. When finished, the caller must invoke SVGA_FIFOCommitAll(). + * + * Results: + * Returns pointers to memory where the caller can store the image. + * + * Side effects: + * Reserves space in the FIFO. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_BeginDefineAlphaCursor(const SVGAFifoCmdDefineAlphaCursor *cursorInfo, // IN + void **data) // OUT +{ + uint32 imageSize = cursorInfo->width * cursorInfo->height * sizeof(uint32); + SVGAFifoCmdDefineAlphaCursor *cmd = SVGA_FIFOReserveCmd(SVGA_CMD_DEFINE_ALPHA_CURSOR, + sizeof *cmd + imageSize); + *cmd = *cursorInfo; + *data = (void*) (cmd + 1); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_MoveCursor -- + * + * Change the position or visibility of the hardware cursor, using + * the Cursor Bypass 3 protocol. + * + * Results: + * None. + * + * Side effects: + * Modifies FIFO registers. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_MoveCursor(uint32 visible, // IN + uint32 x, // IN + uint32 y) // IN +{ + if (SVGA_HasFIFOCap(SVGA_FIFO_CAP_CURSOR_BYPASS_3)) { + gSVGA.fifoMem[SVGA_FIFO_CURSOR_ON] = visible; + gSVGA.fifoMem[SVGA_FIFO_CURSOR_X] = x; + gSVGA.fifoMem[SVGA_FIFO_CURSOR_Y] = y; + gSVGA.fifoMem[SVGA_FIFO_CURSOR_COUNT]++; + } +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_BeginVideoSetRegs -- + * + * Begin an SVGA_ESCAPE_VMWARE_VIDEO_SET_REGS command. This can be + * used to set an arbitrary number of video registers atomically. + * + * Results: + * Returns a pointer to the command. The caller must fill in (*setRegs)->items. + * + * Side effects: + * Reserves space in the FIFO. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_BeginVideoSetRegs(uint32 streamId, // IN + uint32 numItems, // IN + SVGAEscapeVideoSetRegs **setRegs) // OUT +{ + SVGAEscapeVideoSetRegs *cmd; + uint32 cmdSize = (sizeof *cmd + - sizeof cmd->items + + numItems * sizeof cmd->items[0]); + + cmd = SVGA_FIFOReserveEscape(SVGA_ESCAPE_NSID_VMWARE, cmdSize); + cmd->header.cmdType = SVGA_ESCAPE_VMWARE_VIDEO_SET_REGS; + cmd->header.streamId = streamId; + + *setRegs = cmd; +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_VideoSetReg -- + * + * Atomically set all registers in a video overlay unit. + * + * 'maxReg' should be the highest video overlay register that the + * caller understands. We will not set any registers with IDs + * higher than maxReg. This prevents older applications compiled + * with newer headers from sending improper values to new overlay + * registers. + * + * Each video overlay unit (specified by streamId) has a collection + * of 32-bit registers which control the operation of that overlay. + * Changes to these registers take effect at the next Flush. + * + * Results: + * None. + * + * Side effects: + * Writes a FIFO command. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_VideoSetAllRegs(uint32 streamId, // IN + SVGAOverlayUnit *regs, // IN + uint32 maxReg) // IN +{ + uint32 *regArray = (uint32*) regs; + const uint32 numRegs = maxReg + 1; + SVGAEscapeVideoSetRegs *setRegs; + uint32 i; + + SVGA_BeginVideoSetRegs(streamId, numRegs, &setRegs); + + for (i = 0; i < numRegs; i++) { + setRegs->items[i].registerId = i; + setRegs->items[i].value = regArray[i]; + } + + SVGA_FIFOCommitAll(); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_VideoSetReg -- + * + * Set a single video overlay register. + * + * Each video overlay unit (specified by streamId) has a collection + * of 32-bit registers which control the operation of that overlay. + * Changes to these registers take effect at the next Flush. + * + * Results: + * None. + * + * Side effects: + * Writes a FIFO command. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_VideoSetReg(uint32 streamId, // IN + uint32 registerId, // IN + uint32 value) // IN +{ + SVGAEscapeVideoSetRegs *setRegs; + + SVGA_BeginVideoSetRegs(streamId, 1, &setRegs); + setRegs->items[0].registerId = registerId; + setRegs->items[0].value = value; + SVGA_FIFOCommitAll(); +} + + +/* + *----------------------------------------------------------------------------- + * + * SVGA_VideoFlush -- + * + * Update a video overlay. On a VideoFlush, all register changes + * take effect, and the device will perform a DMA transfer to + * copy the next frame of video from guest memory. + * + * The SVGA device will generally perform a DMA transfer from + * overlay memory only during a VideoFlush. The DMA operation + * will usually be completed before the host moves to the next + * FIFO command. However, this is not guaranteed. In unusual + * conditions, the device may re-perform the DMA operation at any + * time. This means that, as long as an overlay is enabled, its + * corresponding guest memory must be valid. + * + * Results: + * None. + * + * Side effects: + * Writes a FIFO command. May cause an asynchronous DMA transfer. + * + *----------------------------------------------------------------------------- + */ + +void +SVGA_VideoFlush(uint32 streamId) // IN +{ + SVGAEscapeVideoFlush *cmd; + + cmd = SVGA_FIFOReserveEscape(SVGA_ESCAPE_NSID_VMWARE, sizeof *cmd); + cmd->cmdType = SVGA_ESCAPE_VMWARE_VIDEO_FLUSH; + cmd->streamId = streamId; + SVGA_FIFOCommitAll(); +} diff --git a/lib/refdriver/svga.h b/lib/refdriver/svga.h new file mode 100644 index 0000000..2935dfa --- /dev/null +++ b/lib/refdriver/svga.h @@ -0,0 +1,120 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga.h -- + * + * This is a simple example driver for the VMware SVGA device. + * It handles initialization, register accesses, low-level + * command FIFO writes, and host/guest synchronization. + */ + +#ifndef __SVGA_H__ +#define __SVGA_H__ + +#include "types.h" +#include "pci.h" +#include "intr.h" +#include "svga_reg.h" +#include "svga_escape.h" +#include "svga_overlay.h" +#include "svga3d_reg.h" + +typedef struct SVGADevice { + PCIAddress pciAddr; + uint32 ioBase; + uint32 *fifoMem; + uint8 *fbMem; + uint32 fifoSize; + uint32 fbSize; + + uint32 deviceVersionId; + uint32 capabilities; + + uint32 width; + uint32 height; + uint32 bpp; + uint32 pitch; + + struct { + uint32 reservedSize; + Bool usingBounceBuffer; + uint8 bounceBuffer[1024 * 1024]; + uint32 nextFence; + } fifo; + + struct { + uint32 pending; + uint32 switchContext; + IntrContext oldContext; + IntrContext newContext; + uint32 count; + } irq; + +} SVGADevice; + +extern SVGADevice gSVGA; + +void SVGA_Init(void); +void SVGA_SetMode(uint32 width, uint32 height, uint32 bpp); +void SVGA_Disable(void); +void SVGA_Panic(const char *err); +void SVGA_DefaultFaultHandler(int vector); + +uint32 SVGA_ReadReg(uint32 index); +void SVGA_WriteReg(uint32 index, uint32 value); +uint32 SVGA_ClearIRQ(void); +uint32 SVGA_WaitForIRQ(); + +Bool SVGA_IsFIFORegValid(int reg); +Bool SVGA_HasFIFOCap(int cap); + +void *SVGA_FIFOReserve(uint32 bytes); +void *SVGA_FIFOReserveCmd(uint32 type, uint32 bytes); +void *SVGA_FIFOReserveEscape(uint32 nsid, uint32 bytes); +void SVGA_FIFOCommit(uint32 bytes); +void SVGA_FIFOCommitAll(void); + +uint32 SVGA_InsertFence(void); +void SVGA_SyncToFence(uint32 fence); +Bool SVGA_HasFencePassed(uint32 fence); +void SVGA_RingDoorbell(void); + +/* 2D commands */ + +void SVGA_Update(uint32 x, uint32 y, uint32 width, uint32 height); +void SVGA_BeginDefineCursor(const SVGAFifoCmdDefineCursor *cursorInfo, + void **andMask, void **xorMask); +void SVGA_BeginDefineAlphaCursor(const SVGAFifoCmdDefineAlphaCursor *cursorInfo, + void **data); +void SVGA_MoveCursor(uint32 visible, uint32 x, uint32 y); + +void SVGA_BeginVideoSetRegs(uint32 streamId, uint32 numItems, + SVGAEscapeVideoSetRegs **setRegs); +void SVGA_VideoSetAllRegs(uint32 streamId, SVGAOverlayUnit *regs, uint32 maxReg); +void SVGA_VideoSetReg(uint32 streamId, uint32 registerId, uint32 value); +void SVGA_VideoFlush(uint32 streamId); + +#endif /* __SVGA_H__ */ diff --git a/lib/refdriver/svga3d.c b/lib/refdriver/svga3d.c new file mode 100644 index 0000000..30ea68e --- /dev/null +++ b/lib/refdriver/svga3d.c @@ -0,0 +1,1115 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga3d.c -- + * + * FIFO command level interface to the SVGA3D protocol used by + * the VMware SVGA device. + */ + +#include "svga.h" +#include "svga3d.h" + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_Init -- + * + * Perform 3D-only initialization for the SVGA device. This + * function negotiates SVGA3D protocol versions between the host + * and the guest. + * + * The 3D protocol negotiation works as follows: + * + * 1. Before enabling the FIFO, the guest writes its 3D protocol + * version to the SVGA_FIFO_GUEST_3D_HWVERSION register. + * We do this step in SVGA_Init(). + * + * 2. When the FIFO is enabled, the host checks our 3D version + * for compatibility. If the host can support our protocol, + * the host puts its protocol version in SVGA_FIFO_3D_HWVERSION. + * If the host cannot support our protocol, it leaves the + * version set to zero. + * + * This function must be called after the FIFO is enabled. + * (After SVGA_SetMode.) + * + * Results: + * None. + * + * Side effects: + * Panic if the host is incompatible with 3D. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_Init(void) +{ + if (!(gSVGA.capabilities & SVGA_CAP_EXTENDED_FIFO)) { + SVGA_Panic("3D requires the Extended FIFO capability."); + } + + if (gSVGA.fifoMem[SVGA_FIFO_MIN] <= sizeof(uint32) * SVGA_FIFO_GUEST_3D_HWVERSION) { + SVGA_Panic("GUEST_3D_HWVERSION register not present."); + } + + /* + * Check the host's version, make sure we're binary compatible. + */ + + if (gSVGA.fifoMem[SVGA_FIFO_3D_HWVERSION] == 0) { + SVGA_Panic("3D disabled by host."); + } + if (gSVGA.fifoMem[SVGA_FIFO_3D_HWVERSION] < SVGA3D_HWVERSION_WS65_B1) { + SVGA_Panic("Host SVGA3D protocol is too old, not binary compatible."); + } +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_FIFOReserve -- + * + * Reserve space for an SVGA3D FIFO command. + * + * The 2D SVGA commands have been around for a while, so they + * have a rather asymmetric structure. The SVGA3D protocol is + * more uniform: each command begins with a header containing the + * command number and the full size. + * + * This is a convenience wrapper around SVGA_FIFOReserve. We + * reserve space for the whole command, and write the header. + * + * This function must be paired with SVGA_FIFOCommitAll(). + * + * Results: + * Returns a pointer to the space reserved for command-specific + * data. It must be 'cmdSize' bytes long. + * + * Side effects: + * Begins a FIFO reservation. + * + *---------------------------------------------------------------------- + */ + +void * +SVGA3D_FIFOReserve(uint32 cmd, // IN + uint32 cmdSize) // IN +{ + SVGA3dCmdHeader *header; + + header = SVGA_FIFOReserve(sizeof *header + cmdSize); + header->id = cmd; + header->size = cmdSize; + + return &header[1]; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginDefineSurface -- + * + * Begin a SURFACE_DEFINE command. This reserves space for it in + * the FIFO, and returns pointers to the command's faces and + * mipsizes arrays. + * + * This function must be paired with SVGA_FIFOCommitAll(). + * The faces and mipSizes arrays are initialized to zero. + * + * This creates a "surface" object in the SVGA3D device, + * with the provided surface ID (sid). Surfaces are generic + * containers for host VRAM objects like textures, vertex + * buffers, and depth/stencil buffers. + * + * Surfaces are hierarchial: + * + * - Surface may have multiple faces (for cube maps) + * + * - Each face has a list of mipmap levels + * + * - Each mipmap image may have multiple volume + * slices, if the image is three dimensional. + * + * - Each slice is a 2D array of 'blocks' + * + * - Each block may be one or more pixels. + * (Usually 1, more for DXT or YUV formats.) + * + * Surfaces are generic host VRAM objects. The SVGA3D device + * may optimize surfaces according to the format they were + * created with, but this format does not limit the ways in + * which the surface may be used. For example, a depth surface + * can be used as a texture, or a floating point image may + * be used as a vertex buffer. Some surface usages may be + * lower performance, due to software emulation, but any + * usage should work with any surface. + * + * If 'sid' is already defined, the old surface is deleted + * and this new surface replaces it. + * + * Surface IDs are arbitrary small non-negative integers, + * global to the entire SVGA device. + * + * Results: + * Returns pointers to arrays allocated in the FIFO for 'faces' + * and 'mipSizes'. + * + * Side effects: + * Begins a FIFO reservation. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginDefineSurface(uint32 sid, // IN + SVGA3dSurfaceFlags flags, // IN + SVGA3dSurfaceFormat format, // IN + SVGA3dSurfaceFace **faces, // OUT + SVGA3dSize **mipSizes, // OUT + uint32 numMipSizes) // IN +{ + SVGA3dCmdDefineSurface *cmd; + + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SURFACE_DEFINE, sizeof *cmd + + sizeof **mipSizes * numMipSizes); + + cmd->sid = sid; + cmd->surfaceFlags = flags; + cmd->format = format; + + *faces = &cmd->face[0]; + *mipSizes = (SVGA3dSize*) &cmd[1]; + + memset(*faces, 0, sizeof **faces * SVGA3D_MAX_SURFACE_FACES); + memset(*mipSizes, 0, sizeof **mipSizes * numMipSizes); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_DestroySurface -- + * + * Release the host VRAM encapsulated by a particular surface ID. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_DestroySurface(uint32 sid) // IN +{ + SVGA3dCmdDestroySurface *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SURFACE_DESTROY, sizeof *cmd); + cmd->sid = sid; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginSurfaceDMA-- + * + * Begin a SURFACE_DMA command. This reserves space for it in + * the FIFO, and returns a pointer to the command's box array. + * This function must be paired with SVGA_FIFOCommitAll(). + * + * When the SVGA3D device asynchronously processes this FIFO + * command, a DMA operation is performed between host VRAM and + * a generic SVGAGuestPtr. The guest pointer may refer to guest + * VRAM (provided by the SVGA PCI device) or to guest system + * memory that has been set up as a Guest Memory Region (GMR) + * by the SVGA device. + * + * The guest's DMA buffer must remain valid (not freed, paged out, + * or overwritten) until the host has finished processing this + * command. The guest can determine that the host has finished + * by using the SVGA device's FIFO Fence mechanism. + * + * The guest's image buffer can be an arbitrary size and shape. + * Guest image data is interpreted according to the SVGA3D surface + * format specified when the surface was defined. + * + * The caller may optionally define the guest image's pitch. + * guestImage->pitch can either be zero (assume image is tightly + * packed) or it must be the number of bytes between vertically + * adjacent image blocks. + * + * The provided copybox list specifies which regions of the source + * image are to be copied, and where they appear on the destination. + * + * NOTE: srcx/srcy are always on the guest image and x/y are + * always on the host image, regardless of the actual transfer + * direction! + * + * For efficiency, the SVGA3D device is free to copy more data + * than specified. For example, it may round copy boxes outwards + * such that they lie on particular alignment boundaries. + * + * The box array is initialized with zeroes. + * + * Results: + * Returns pointers to a box array allocated in the FIFO. + * + * Side effects: + * Begins a FIFO reservation. + * Begins a FIFO command which will eventually perform DMA. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginSurfaceDMA(SVGA3dGuestImage *guestImage, // IN + SVGA3dSurfaceImageId *hostImage, // IN + SVGA3dTransferType transfer, // IN + SVGA3dCopyBox **boxes, // OUT + uint32 numBoxes) // IN +{ + SVGA3dCmdSurfaceDMA *cmd; + uint32 boxesSize = sizeof **boxes * numBoxes; + + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SURFACE_DMA, sizeof *cmd + boxesSize); + + cmd->guest = *guestImage; + cmd->host = *hostImage; + cmd->transfer = transfer; + *boxes = (SVGA3dCopyBox*) &cmd[1]; + + memset(*boxes, 0, boxesSize); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_DefineContext -- + * + * Create a new context, to be referred to with the provided ID. + * + * Context objects encapsulate all render state, and shader + * objects are per-context. + * + * Surfaces are not per-context. The same surface can be shared + * between multiple contexts, and surface operations can occur + * without a context. + * + * If the provided context ID already existed, it is redefined. + * + * Context IDs are arbitrary small non-negative integers, + * global to the entire SVGA device. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_DefineContext(uint32 cid) // IN +{ + SVGA3dCmdDefineContext *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_CONTEXT_DEFINE, sizeof *cmd); + cmd->cid = cid; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_DestroyContext -- + * + * Delete a context created with SVGA3D_DefineContext. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_DestroyContext(uint32 cid) // IN +{ + SVGA3dCmdDestroyContext *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_CONTEXT_DESTROY, sizeof *cmd); + cmd->cid = cid; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetRenderTarget -- + * + * Bind a surface object to a particular render target attachment + * point on the current context. Render target attachment points + * exist for color buffers, a depth buffer, and a stencil buffer. + * + * The SVGA3D device is quite lenient about the types of surfaces + * that may be used as render targets. The color buffers must + * all be the same size, but the depth and stencil buffers do not + * have to be the same size as the color buffer. All attachments + * are optional. + * + * Some combinations of render target formats may require software + * emulation, depending on the capabilities of the host graphics + * API and graphics hardware. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SetRenderTarget(uint32 cid, // IN + SVGA3dRenderTargetType type, // IN + SVGA3dSurfaceImageId *target) // IN +{ + SVGA3dCmdSetRenderTarget *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETRENDERTARGET, sizeof *cmd); + cmd->cid = cid; + cmd->type = type; + cmd->target = *target; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetTransform -- + * + * Set one of the current context's transform matrices. + * The 'type' parameter should be an SVGA3D_TRANSFORM_* constant. + * + * All transformation matrices follow Direct3D-style coordinate + * system semantics. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + + +void +SVGA3D_SetTransform(uint32 cid, // IN + SVGA3dTransformType type, // IN + const float *matrix) // IN +{ + SVGA3dCmdSetTransform *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETTRANSFORM, sizeof *cmd); + cmd->cid = cid; + cmd->type = type; + memcpy(&cmd->matrix[0], matrix, sizeof(float) * 16); + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetMaterial -- + * + * Set all material data for one SVGA3dFace. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SetMaterial(uint32 cid, // IN + SVGA3dFace face, // IN + const SVGA3dMaterial *material) // IN +{ + SVGA3dCmdSetMaterial *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETMATERIAL, sizeof *cmd); + cmd->cid = cid; + cmd->face = face; + memcpy(&cmd->material, material, sizeof *material); + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetLightEnabled -- + * + * Enable or disable one fixed-function light. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SetLightEnabled(uint32 cid, // IN + uint32 index, // IN + Bool enabled) // IN +{ + SVGA3dCmdSetLightEnabled *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETLIGHTENABLED, sizeof *cmd); + cmd->cid = cid; + cmd->index = index; + cmd->enabled = enabled; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetLightData -- + * + * Set all state for one fixed-function light. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SetLightData(uint32 cid, // IN + uint32 index, // IN + const SVGA3dLightData *data) // IN +{ + SVGA3dCmdSetLightData *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETLIGHTDATA, sizeof *cmd); + cmd->cid = cid; + cmd->index = index; + memcpy(&cmd->data, data, sizeof *data); + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_DefineShader -- + * + * Upload the bytecode for a new shader. The bytecode is "SVGA3D + * format", which is theoretically a binary-compatible superset + * of Microsoft's DirectX shader bytecode. In practice, the + * SVGA3D bytecode doesn't yet have any extensions to DirectX's + * bytecode format. + * + * The SVGA3D device supports shader models 1.1 through 2.0. + * + * The caller chooses a shader ID (small positive integer) by + * which this shader will be identified in future commands. This + * ID is in a namespace which is per-context and per-shader-type. + * + * 'bytecodeLen' is specified in bytes. It must be a multiple of 4. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_DefineShader(uint32 cid, // IN + uint32 shid, // IN + SVGA3dShaderType type, // IN + const uint32 *bytecode, // IN + uint32 bytecodeLen) // IN +{ + SVGA3dCmdDefineShader *cmd; + + if (bytecodeLen & 3) { + SVGA_Panic("Shader bytecode length isn't a multiple of 32 bits!"); + } + + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SHADER_DEFINE, sizeof *cmd + bytecodeLen); + cmd->cid = cid; + cmd->shid = shid; + cmd->type = type; + memcpy(&cmd[1], bytecode, bytecodeLen); + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_DestroyShader -- + * + * Delete a shader that was created by SVGA3D_DefineShader. If + * the shader was the current vertex or pixel shader for its + * context, rendering results are undefined until a new shader is + * bound. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_DestroyShader(uint32 cid, // IN + uint32 shid, // IN + SVGA3dShaderType type) // IN +{ + SVGA3dCmdDestroyShader *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SHADER_DESTROY, sizeof *cmd); + cmd->cid = cid; + cmd->shid = shid; + cmd->type = type; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetShaderConst -- + * + * Set the value of a shader constant. + * + * Shader constants are analogous to uniform variables in GLSL, + * except that they belong to the render context rather than to + * an individual shader. + * + * Constants may have one of three types: A 4-vector of floats, + * a 4-vector of integers, or a single boolean flag. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SetShaderConst(uint32 cid, // IN + uint32 reg, // IN + SVGA3dShaderType type, // IN + SVGA3dShaderConstType ctype, // IN + const void *value) // IN +{ + SVGA3dCmdSetShaderConst *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SET_SHADER_CONST, sizeof *cmd); + cmd->cid = cid; + cmd->reg = reg; + cmd->type = type; + cmd->ctype = ctype; + + switch (ctype) { + + case SVGA3D_CONST_TYPE_FLOAT: + case SVGA3D_CONST_TYPE_INT: + memcpy(&cmd->values, value, sizeof cmd->values); + break; + + case SVGA3D_CONST_TYPE_BOOL: + memset(&cmd->values, 0, sizeof cmd->values); + cmd->values[0] = *(uint32*)value; + break; + + default: + SVGA_Panic("Bad shader constant type."); + break; + + } + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetShader -- + * + * Switch active shaders. This binds a new vertex or pixel shader + * to the specified context. + * + * A shader ID of SVGA3D_INVALID_ID unbinds any shader, switching + * back to the fixed function vertex or pixel pipeline. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SetShader(uint32 cid, // IN + SVGA3dShaderType type, // IN + uint32 shid) // IN +{ + SVGA3dCmdSetShader *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SET_SHADER, sizeof *cmd); + cmd->cid = cid; + cmd->type = type; + cmd->shid = shid; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginPresent -- + * + * Begin a PRESENT command. This reserves space for it in the + * FIFO, and returns a pointer to the command's rectangle array. + * This function must be paired with SVGA_FIFOCommitAll(). + * + * Present is the SVGA3D device's way of transferring fully + * rendered images to the 2D portion of the SVGA device. Present + * is a hardware accelerated surface-to-screen blit. + * + * Important caveats: + * + * - Present may or may not modify the guest-visible 2D + * framebuffer. If you need to read back rendering results, + * use an surface DMA transfer. + * + * - Present is a good place to think about flow control + * between the host and the guest. If the host and guest + * have no other form of synchronization, the FIFO could + * fill with many frames worth of rendering commands. The + * host will visibly lag the guest. Depending on the + * size of the FIFO and the size of the frames, it could + * lag by hours! It is advisable to use FIFO fences in order + * to guarantee that no more than one or two Presents are + * queued in the FIFO at any given time. + * + * Results: + * None. + * + * Side effects: + * May or may not write to the 2D framebuffer. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginPresent(uint32 sid, // IN + SVGA3dCopyRect **rects, // OUT + uint32 numRects) // IN +{ + SVGA3dCmdPresent *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_PRESENT, sizeof *cmd + + sizeof **rects * numRects); + cmd->sid = sid; + *rects = (SVGA3dCopyRect*) &cmd[1]; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginClear -- + * + * Begin a CLEAR command. This reserves space for it in the FIFO, + * and returns a pointer to the command's rectangle array. This + * function must be paired with SVGA_FIFOCommitAll(). + * + * Clear is a rendering operation which fills a list of + * rectangles with constant values on all render target types + * indicated by 'flags'. + * + * Clear is not affected by clipping, depth test, or other + * render state which affects the fragment pipeline. + * + * Results: + * None. + * + * Side effects: + * May write to attached render target surfaces. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginClear(uint32 cid, // IN + SVGA3dClearFlag flags, // IN + uint32 color, // IN + float depth, // IN + uint32 stencil, // IN + SVGA3dRect **rects, // OUT + uint32 numRects) // IN +{ + SVGA3dCmdClear *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_CLEAR, sizeof *cmd + + sizeof **rects * numRects); + cmd->cid = cid; + cmd->clearFlag = flags; + cmd->color = color; + cmd->depth = depth; + cmd->stencil = stencil; + *rects = (SVGA3dRect*) &cmd[1]; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginDrawPrimitives -- + * + * Begin a DRAW_PRIMITIVES command. This reserves space for it in + * the FIFO, and returns a pointer to the command's arrays. + * This function must be paired with SVGA_FIFOCommitAll(). + * + * Drawing commands consist of two variable-length arrays: + * SVGA3dVertexDecl elements declare a set of vertex buffers to + * use while rendering, and SVGA3dPrimitiveRange elements specify + * groups of primitives each with an optional index buffer. + * + * The decls and ranges arrays are initialized to zero. + * + * Results: + * None. + * + * Side effects: + * May write to attached render target surfaces. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginDrawPrimitives(uint32 cid, // IN + SVGA3dVertexDecl **decls, // OUT + uint32 numVertexDecls, // IN + SVGA3dPrimitiveRange **ranges, // OUT + uint32 numRanges) // IN +{ + SVGA3dCmdDrawPrimitives *cmd; + SVGA3dVertexDecl *declArray; + SVGA3dPrimitiveRange *rangeArray; + uint32 declSize = sizeof **decls * numVertexDecls; + uint32 rangeSize = sizeof **ranges * numRanges; + + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_DRAW_PRIMITIVES, sizeof *cmd + + declSize + rangeSize); + + cmd->cid = cid; + cmd->numVertexDecls = numVertexDecls; + cmd->numRanges = numRanges; + + declArray = (SVGA3dVertexDecl*) &cmd[1]; + rangeArray = (SVGA3dPrimitiveRange*) &declArray[numVertexDecls]; + + memset(declArray, 0, declSize); + memset(rangeArray, 0, rangeSize); + + *decls = declArray; + *ranges = rangeArray; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginSurfaceCopy -- + * + * Begin a SURFACE_COPY command. This reserves space for it in + * the FIFO, and returns a pointer to the command's arrays. This + * function must be paired with SVGA_FIFOCommitAll(). + * + * The box array is initialized with zeroes. + * + * Results: + * None. + * + * Side effects: + * Asynchronously copies a list of boxes from surface to surface. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginSurfaceCopy(SVGA3dSurfaceImageId *src, // IN + SVGA3dSurfaceImageId *dest, // IN + SVGA3dCopyBox **boxes, // OUT + uint32 numBoxes) // IN +{ + SVGA3dCmdSurfaceCopy *cmd; + uint32 boxesSize = sizeof **boxes * numBoxes; + + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SURFACE_COPY, sizeof *cmd + boxesSize); + + cmd->src = *src; + cmd->dest = *dest; + *boxes = (SVGA3dCopyBox*) &cmd[1]; + + memset(*boxes, 0, boxesSize); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SurfaceStretchBlt -- + * + * Issue a SURFACE_STRETCHBLT command: an asynchronous + * surface-to-surface blit, with scaling. + * + * Results: + * None. + * + * Side effects: + * Asynchronously copies one box from surface to surface. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SurfaceStretchBlt(SVGA3dSurfaceImageId *src, // IN + SVGA3dSurfaceImageId *dest, // IN + SVGA3dBox *boxSrc, // IN + SVGA3dBox *boxDest, // IN + SVGA3dStretchBltMode mode) // IN +{ + SVGA3dCmdSurfaceStretchBlt *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SURFACE_STRETCHBLT, sizeof *cmd); + cmd->src = *src; + cmd->dest = *dest; + cmd->boxSrc = *boxSrc; + cmd->boxDest = *boxDest; + cmd->mode = mode; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetViewport -- + * + * Set the current context's viewport rectangle. The viewport + * is clipped to the dimensions of the current render target, + * then all rendering is clipped to the viewport. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SetViewport(uint32 cid, // IN + SVGA3dRect *rect) // IN +{ + SVGA3dCmdSetViewport *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETVIEWPORT, sizeof *cmd); + cmd->cid = cid; + cmd->rect = *rect; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_SetZRange -- + * + * Set the range of the depth buffer to use. 'min' and 'max' + * are values between 0.0 and 1.0. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_SetZRange(uint32 cid, // IN + float zMin, // IN + float zMax) // IN +{ + SVGA3dCmdSetZRange *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETZRANGE, sizeof *cmd); + cmd->cid = cid; + cmd->zRange.min = zMin; + cmd->zRange.max = zMax; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginSetTextureState -- + * + * Begin a SETTEXTURESTATE command. This reserves space for it in + * the FIFO, and returns a pointer to the command's texture state + * array. This function must be paired with SVGA_FIFOCommitAll(). + * + * This command sets rendering state which is per-texture-unit. + * + * XXX: Individual texture states need documentation. However, + * they are very similar to the texture states defined by + * Direct3D. The D3D documentation is a good starting point + * for understanding SVGA3D texture states. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginSetTextureState(uint32 cid, // IN + SVGA3dTextureState **states, // OUT + uint32 numStates) // IN +{ + SVGA3dCmdSetTextureState *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETTEXTURESTATE, sizeof *cmd + + sizeof **states * numStates); + cmd->cid = cid; + *states = (SVGA3dTextureState*) &cmd[1]; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginSetRenderState -- + * + * Begin a SETRENDERSTATE command. This reserves space for it in + * the FIFO, and returns a pointer to the command's texture state + * array. This function must be paired with SVGA_FIFOCommitAll(). + * + * This command sets rendering state which is global to the context. + * + * XXX: Individual render states need documentation. However, + * they are very similar to the render states defined by + * Direct3D. The D3D documentation is a good starting point + * for understanding SVGA3D render states. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginSetRenderState(uint32 cid, // IN + SVGA3dRenderState **states, // OUT + uint32 numStates) // IN +{ + SVGA3dCmdSetRenderState *cmd; + cmd = SVGA3D_FIFOReserve(SVGA_3D_CMD_SETRENDERSTATE, sizeof *cmd + + sizeof **states * numStates); + cmd->cid = cid; + *states = (SVGA3dRenderState*) &cmd[1]; +} + +/* + *---------------------------------------------------------------------- + * + * SVGA3D_BeginPresentReadback -- + * + * Begin a PRESENT_READBACK command. This reserves space for it + * in the FIFO, and returns a pointer to the command's SVGA3dRect + * array. This function must be paired with + * SVGA_FIFOCommitAll(). + * + * This command will update the 2D framebuffer with the most + * recently presented data in the supplied regions. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3D_BeginPresentReadback(SVGA3dRect **rects, // OUT + uint32 numRects) // IN +{ + void *cmd; + cmd = (void *) SVGA3D_FIFOReserve(SVGA_3D_CMD_PRESENT_READBACK, + sizeof **rects * numRects); + *rects = (SVGA3dRect*) cmd; +} diff --git a/lib/refdriver/svga3d.h b/lib/refdriver/svga3d.h new file mode 100644 index 0000000..be49de0 --- /dev/null +++ b/lib/refdriver/svga3d.h @@ -0,0 +1,139 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga3d.h -- + * + * FIFO command level interface to the SVGA3D protocol used by + * the VMware SVGA device. + */ + +#ifndef __SVGA3D_H__ +#define __SVGA3D_H__ + +#include "svga.h" +#include "svga3d_reg.h" + + +/* + * SVGA Device Interoperability + */ + +void SVGA3D_Init(void); +void SVGA3D_BeginPresent(uint32 sid, SVGA3dCopyRect **rects, uint32 numRects); +void SVGA3D_BeginPresentReadback(SVGA3dRect **rects, uint32 numRects); + + +/* + * Surface Management + */ + +void SVGA3D_BeginDefineSurface(uint32 sid, + SVGA3dSurfaceFlags flags, + SVGA3dSurfaceFormat format, + SVGA3dSurfaceFace **faces, + SVGA3dSize **mipSizes, + uint32 numMipSizes); +void SVGA3D_DestroySurface(uint32 sid); +void SVGA3D_BeginSurfaceDMA(SVGA3dGuestImage *guestImage, + SVGA3dSurfaceImageId *hostImage, + SVGA3dTransferType transfer, + SVGA3dCopyBox **boxes, + uint32 numBoxes); + + +/* + * Context Management + */ + +void SVGA3D_DefineContext(uint32 cid); +void SVGA3D_DestroyContext(uint32 cid); + + +/* + * Drawing Operations + */ + +void SVGA3D_BeginClear(uint32 cid, SVGA3dClearFlag flags, + uint32 color, float depth, uint32 stencil, + SVGA3dRect **rects, uint32 numRects); +void SVGA3D_BeginDrawPrimitives(uint32 cid, + SVGA3dVertexDecl **decls, + uint32 numVertexDecls, + SVGA3dPrimitiveRange **ranges, + uint32 numRanges); + +/* + * Blits + */ + +void SVGA3D_BeginSurfaceCopy(SVGA3dSurfaceImageId *src, + SVGA3dSurfaceImageId *dest, + SVGA3dCopyBox **boxes, uint32 numBoxes); + +void SVGA3D_SurfaceStretchBlt(SVGA3dSurfaceImageId *src, + SVGA3dSurfaceImageId *dest, + SVGA3dBox *boxSrc, SVGA3dBox *boxDest, + SVGA3dStretchBltMode mode); + +/* + * Shared FFP/Shader Render State + */ + +void SVGA3D_SetRenderTarget(uint32 cid, SVGA3dRenderTargetType type, + SVGA3dSurfaceImageId *target); +void SVGA3D_SetZRange(uint32 cid, float zMin, float zMax); +void SVGA3D_SetViewport(uint32 cid, SVGA3dRect *rect); +void SVGA3D_SetScissorRect(uint32 cid, SVGA3dRect *rect); +void SVGA3D_SetClipPlane(uint32 cid, uint32 index, const float *plane); +void SVGA3D_BeginSetTextureState(uint32 cid, SVGA3dTextureState **states, + uint32 numStates); +void SVGA3D_BeginSetRenderState(uint32 cid, SVGA3dRenderState **states, + uint32 numStates); + + +/* + * Fixed-function Render State + */ + +void SVGA3D_SetTransform(uint32 cid, SVGA3dTransformType type, + const float *matrix); +void SVGA3D_SetMaterial(uint32 cid, SVGA3dFace face, const SVGA3dMaterial *material); +void SVGA3D_SetLightData(uint32 cid, uint32 index, const SVGA3dLightData *data); +void SVGA3D_SetLightEnabled(uint32 cid, uint32 index, Bool enabled); + + +/* + * Shaders + */ + +void SVGA3D_DefineShader(uint32 cid, uint32 shid, SVGA3dShaderType type, + const uint32 *bytecode, uint32 bytecodeLen); +void SVGA3D_DestroyShader(uint32 cid, uint32 shid, SVGA3dShaderType type); +void SVGA3D_SetShaderConst(uint32 cid, uint32 reg, SVGA3dShaderType type, + SVGA3dShaderConstType ctype, const void *value); +void SVGA3D_SetShader(uint32 cid, SVGA3dShaderType type, uint32 shid); + +#endif /* __SVGA3D_H__ */ diff --git a/lib/util/matrix.c b/lib/util/matrix.c new file mode 100644 index 0000000..efe3cea --- /dev/null +++ b/lib/util/matrix.c @@ -0,0 +1,312 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * matrix.c -- + * + * Simple operations for 4x4 row-major float matrices. + */ + +#include "matrix.h" +#include "math.h" + +/* Shortcut for accessing elements */ +#define EL(col, row) (((row)<<2) + (col)) + +const Matrix gIdentityMatrix = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f, +}; + + +/* + *---------------------------------------------------------------------- + * + * Matrix_Copy -- + * + * Copy from 'other' to 'self'. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Matrix_Copy(Matrix self, // OUT + const Matrix other) // IN +{ + memcpy(self, other, sizeof(Matrix)); +} + + +/* + *---------------------------------------------------------------------- + * + * Matrix_Perspective -- + * + * Load a generic perspective matrix, equivalent to gluPerspective(). + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Matrix_Perspective(Matrix self, // OUT + float fovY, // IN + float aspect, // IN + float zNear, // IN + float zFar) // IN +{ + + float f = 1.0 / tanf(fovY * (M_PI / 180) / 2); + float q = zFar / (zFar - zNear); + + memset(self, 0, sizeof self); + + self[EL(0,0)] = f / aspect; + self[EL(1,1)] = f; + self[EL(2,2)] = q; + self[EL(2,3)] = -q * zNear; + self[EL(3,2)] = 1; +} + + +/* + *---------------------------------------------------------------------- + * + * Matrix_Scale -- + * + * Scale a matrix by the provided 4-vector. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Matrix_Scale(Matrix self, // IN/OUT + float x, // IN + float y, // IN + float z, // IN + float w) // IN +{ + self[EL(0, 0)] *= x; + self[EL(0, 1)] *= x; + self[EL(0, 2)] *= x; + self[EL(0, 3)] *= x; + + self[EL(1, 0)] *= y; + self[EL(1, 1)] *= y; + self[EL(1, 2)] *= y; + self[EL(1, 3)] *= y; + + self[EL(2, 0)] *= z; + self[EL(2, 1)] *= z; + self[EL(2, 2)] *= z; + self[EL(2, 3)] *= z; + + self[EL(3, 0)] *= w; + self[EL(3, 1)] *= w; + self[EL(3, 2)] *= w; + self[EL(3, 3)] *= w; +} + + +/* + *---------------------------------------------------------------------- + * + * Matrix_Translate -- + * + * Add a translation to a homogeneous matrix. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Matrix_Translate(Matrix self, // IN/OUT + float x, // IN + float y, // IN + float z) // IN +{ + self[EL(0, 3)] += x; + self[EL(1, 3)] += y; + self[EL(2, 3)] += z; +} + + +/* + *---------------------------------------------------------------------- + * + * Matrix_Multiply -- + * + * 4x4 matrix multiply. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Matrix_Multiply(Matrix self, // IN/OUT + const Matrix other) // IN +{ + Matrix result; + int i; + +#define A(x,y) self[EL(x,y)] +#define B(x,y) other[EL(x,y)] +#define C(x,y) result[EL(x,y)] + + for (i = 0; i < 4; i++) { + C(0,i) = A(0,i)*B(0,0) + A(1,i)*B(0,1) + A(2,i)*B(0,2) + A(3,i)*B(0,3); + C(1,i) = A(0,i)*B(1,0) + A(1,i)*B(1,1) + A(2,i)*B(1,2) + A(3,i)*B(1,3); + C(2,i) = A(0,i)*B(2,0) + A(1,i)*B(2,1) + A(2,i)*B(2,2) + A(3,i)*B(2,3); + C(3,i) = A(0,i)*B(3,0) + A(1,i)*B(3,1) + A(2,i)*B(3,2) + A(3,i)*B(3,3); + } + +#undef A +#undef B +#undef C + + memcpy(self, result, sizeof result); +} + + +/* + *---------------------------------------------------------------------- + * + * Matrix_RotateX -- + * + * Rotate a matrix about the X axis. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Matrix_RotateX(Matrix self, // IN/OUT + float rad) // IN +{ + Matrix rotation = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, cosf(rad), sinf(rad), 0.0f, + 0.0f, -sinf(rad), cosf(rad), 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f, + }; + + Matrix_Multiply(self, rotation); +} + + +/* + *---------------------------------------------------------------------- + * + * Matrix_RotateY -- + * + * Rotate a matrix about the Y axis. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Matrix_RotateY(Matrix self, // IN/OUT + float rad) // IN +{ + Matrix rotation = { + cosf(rad), 0.0f, -sinf(rad), 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + sinf(rad), 0.0f, cosf(rad), 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f, + }; + + Matrix_Multiply(self, rotation); +} + + +/* + *---------------------------------------------------------------------- + * + * Matrix_RotateZ -- + * + * Rotate a matrix about the Z axis. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Matrix_RotateZ(Matrix self, // IN/OUT + float rad) // IN +{ + Matrix rotation = { + cosf(rad), sinf(rad), 0.0f, 0.0f, + -sinf(rad), cosf(rad), 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f, + }; + + Matrix_Multiply(self, rotation); +} diff --git a/lib/util/matrix.h b/lib/util/matrix.h new file mode 100644 index 0000000..c30631f --- /dev/null +++ b/lib/util/matrix.h @@ -0,0 +1,50 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * matrix.h -- + * + * Simple operations for 4x4 row-major float matrices. + */ + +#ifndef __MATRIX_H__ +#define __MATRIX_H__ + +#include "types.h" + +typedef float Matrix[16]; + +extern const Matrix gIdentityMatrix; + +void Matrix_Copy(Matrix self, const Matrix other); +void Matrix_Scale(Matrix self, float x, float y, float z, float w); +void Matrix_Translate(Matrix self, float x, float y, float z); +void Matrix_Multiply(Matrix self, const Matrix other); +void Matrix_RotateX(Matrix self, float rad); +void Matrix_RotateY(Matrix self, float rad); +void Matrix_RotateZ(Matrix self, float rad); +void Matrix_Perspective(Matrix self, float fovY, float aspect, float zNear, float zFar); + +#endif /* __MATRIX_H_ */ diff --git a/lib/util/mt19937ar.c b/lib/util/mt19937ar.c new file mode 100644 index 0000000..aabe2a8 --- /dev/null +++ b/lib/util/mt19937ar.c @@ -0,0 +1,171 @@ +/* + A C-program for MT19937, with initialization improved 2002/1/26. + Coded by Takuji Nishimura and Makoto Matsumoto. + + Before using, initialize the state by using init_genrand(seed) + or init_by_array(init_key, key_length). + + Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura, + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + 3. The names of its contributors may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + Any feedback is very welcome. + http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html + email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space) +*/ + +/* Period parameters */ +#define N 624 +#define M 397 +#define MATRIX_A 0x9908b0dfUL /* constant vector a */ +#define UPPER_MASK 0x80000000UL /* most significant w-r bits */ +#define LOWER_MASK 0x7fffffffUL /* least significant r bits */ + +static unsigned long mt[N]; /* the array for the state vector */ +static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */ + +/* initializes mt[N] with a seed */ +void init_genrand(unsigned long s) +{ + mt[0]= s & 0xffffffffUL; + for (mti=1; mti> 30)) + mti); + /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */ + /* In the previous versions, MSBs of the seed affect */ + /* only MSBs of the array mt[]. */ + /* 2002/01/09 modified by Makoto Matsumoto */ + mt[mti] &= 0xffffffffUL; + /* for >32 bit machines */ + } +} + +/* initialize by an array with array-length */ +/* init_key is the array for initializing keys */ +/* key_length is its length */ +/* slight change for C++, 2004/2/26 */ +void init_by_array(unsigned long init_key[], int key_length) +{ + int i, j, k; + init_genrand(19650218UL); + i=1; j=0; + k = (N>key_length ? N : key_length); + for (; k; k--) { + mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL)) + + init_key[j] + j; /* non linear */ + mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */ + i++; j++; + if (i>=N) { mt[0] = mt[N-1]; i=1; } + if (j>=key_length) j=0; + } + for (k=N-1; k; k--) { + mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL)) + - i; /* non linear */ + mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */ + i++; + if (i>=N) { mt[0] = mt[N-1]; i=1; } + } + + mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */ +} + +/* generates a random number on [0,0xffffffff]-interval */ +unsigned long genrand_int32(void) +{ + unsigned long y; + static unsigned long mag01[2]={0x0UL, MATRIX_A}; + /* mag01[x] = x * MATRIX_A for x=0,1 */ + + if (mti >= N) { /* generate N words at one time */ + int kk; + + if (mti == N+1) /* if init_genrand() has not been called, */ + init_genrand(5489UL); /* a default initial seed is used */ + + for (kk=0;kk> 1) ^ mag01[y & 0x1UL]; + } + for (;kk> 1) ^ mag01[y & 0x1UL]; + } + y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK); + mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL]; + + mti = 0; + } + + y = mt[mti++]; + + /* Tempering */ + y ^= (y >> 11); + y ^= (y << 7) & 0x9d2c5680UL; + y ^= (y << 15) & 0xefc60000UL; + y ^= (y >> 18); + + return y; +} + +/* generates a random number on [0,0x7fffffff]-interval */ +long genrand_int31(void) +{ + return (long)(genrand_int32()>>1); +} + +/* generates a random number on [0,1]-real-interval */ +double genrand_real1(void) +{ + return genrand_int32()*(1.0/4294967295.0); + /* divided by 2^32-1 */ +} + +/* generates a random number on [0,1)-real-interval */ +double genrand_real2(void) +{ + return genrand_int32()*(1.0/4294967296.0); + /* divided by 2^32 */ +} + +/* generates a random number on (0,1)-real-interval */ +double genrand_real3(void) +{ + return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0); + /* divided by 2^32 */ +} + +/* generates a random number on [0,1) with 53-bit resolution*/ +double genrand_res53(void) +{ + unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6; + return(a*67108864.0+b)*(1.0/9007199254740992.0); +} +/* These real versions are due to Isaku Wada, 2002/01/09 added */ + diff --git a/lib/util/mt19937ar.h b/lib/util/mt19937ar.h new file mode 100644 index 0000000..d3a6053 --- /dev/null +++ b/lib/util/mt19937ar.h @@ -0,0 +1,9 @@ +void init_genrand(unsigned long s); +void init_by_array(unsigned long init_key[], int key_length); +unsigned long genrand_int32(void); +long genrand_int31(void); +double genrand_real1(void); +double genrand_real2(void); +double genrand_real3(void); +double genrand_res53(void); + diff --git a/lib/util/png.c b/lib/util/png.c new file mode 100644 index 0000000..15da743 --- /dev/null +++ b/lib/util/png.c @@ -0,0 +1,337 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * png.c -- + * + * An extremely simple library for reading in-memory PNG images. + */ + +#include "png.h" +#include "puff.h" + + +/* + *---------------------------------------------------------------------- + * + * PNG_Header -- + * + * Get a pointer to the header chunk of an in-memory PNG file. + * + * Results: + * Always returns a PNGChunkIHDR. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +PNGChunkIHDR * +PNG_Header(void *pngData) // IN +{ + return (PNGChunkIHDR*) ((uint8*)pngData + 8); +} + + +/* + *---------------------------------------------------------------------- + * + * PNG_NextChunk -- + * + * Given a pointer to one PNG chunk, return the next one. + * + * Results: + * Always returns a PNGChunk. Does not check for end-of-file. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +PNGChunk * +PNG_NextChunk(PNGChunk *lastChunk) // IN +{ + return (PNGChunk*) (lastChunk->data + bswap32(lastChunk->length) + 4); +} + + +/* + *---------------------------------------------------------------------- + * + * PNGJoinIDAT -- + * + * Join all of the IDAT chunks together into a contiguous block + * of compressed data. + * + * Results: + * Returns a PNGChunk header which contains the full compressed + * data content of the PNG file. + * + * Side effects: + * Modifies the PNG file, by joining all IDAT chunks. + * + *---------------------------------------------------------------------- + */ + +PNGChunk * +PNGJoinIDAT(PNGChunk *firstChunk) // IN +{ + PNGChunk *firstIDAT = NULL; + PNGChunk *current = firstChunk; + uint8 *tail = NULL; + + while (current->type != PNG_IEND) { + PNGChunk *nextChunk = PNG_NextChunk(current); + uint32 len = bswap32(current->length); + + if (current->type == PNG_IDAT) { + if (firstIDAT == NULL) { + /* + * First IDAT chunk. + */ + firstIDAT = current; + tail = firstIDAT->data + len; + + } else { + /* + * Additional IDAT chunk. Append the data. + */ + memcpy(tail, current->data, len); + tail += len; + } + } + + current = nextChunk; + } + + /* + * Fix up the IDAT header. + */ + firstIDAT->length = bswap32(tail - firstIDAT->data); + + /* + * Write an IEND afterwards, so this process is repeatable. + */ + current = PNG_NextChunk(firstIDAT); + current->type = PNG_IEND; + current->length = 0; + + return firstIDAT; +} + + +/* + *---------------------------------------------------------------------- + * + * PaethPredictor -- + * + * This is a simple image predictor which works based on the values + * of the pixels above, left, and to the top-left of the pixel we're + * predicting. It is defined in the PNG spec: + * + * http://www.libpng.org/pub/png/spec/1.2/PNG-Filters.html + * + * Results: + * Returns the predicted byte. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static uint8 +PaethPredictor(uint8 a, // IN + uint8 b, // IN + uint8 c) // IN +{ + int p = a + b - c; + int pa = p > a ? p - a : a - p; + int pb = p > b ? p - b : b - p; + int pc = p > c ? p - c : c - p; + + if (pa <= pb && pa <= pc) { + return a; + } else if (pb <= pc) { + return b; + } + return c; +} + + +/* + *---------------------------------------------------------------------- + * + * PNG_DecompressBGRX -- + * + * This is a very simple PNG decompressor, which requires very + * little code and no separate temporary buffers. + * + * Limitations: + * + * - Modifies the input PNG file, in order to join all IDAT chunks. + * + * - Only supports RGB (24-bit) PNG files. + * + * - Always writes the output in 32-bit BGRX format. + * + * - Does not support interlaced PNGs. + * + * - Does not support filter types other than "None", "Sub", and "Up". + * + * - Has no validation whatsoever. Unexpected or broken PNGs + * will just cause us to produce incorrect results or crash. + * + * - Uses one extra line ('pitch' bytes) of memory in 'framebuffer' + * past the end of the decompressed image, for scratch space. + * + * Results: + * Writes the decompressed image to 'framebuffer'. + * + * Side effects: + * Uses the framebuffer as temporary space during decompression. + * Modifies the input PNG data in a non-reversible way. + * + *---------------------------------------------------------------------- + */ + +void +PNG_DecompressBGRX(PNGChunkIHDR *ihdr, // IN + uint32 *framebuffer, // OUT + uint32 pitch) // OUT +{ + uint32 width = bswap32(ihdr->width); + uint32 height = bswap32(ihdr->height); + + /* + * Size of raw decompressed image: 3 bytes per pixel, plus one byte + * (filter type) per scanline. + */ + uint32 rawPitch = (width * 3) + 1; + unsigned long rawSize = height * rawPitch; + + /* + * Size of final decompressed image + */ + uint32 finalSize = height * pitch; + + /* + * Use the bottom of the framebuffer for temporary memory. The + * final raw-to-final conversion must read from higher addresses + * and write to lower addresses, so we don't overwrite our + * temporary buffer prematurely. To do this with all filter types, + * we need to use one extra line of temporary space. + */ + uint8 *rawBuffer = (uint8*)framebuffer + finalSize - rawSize + pitch; + + /* + * Decompress all IDAT data into our raw buffer. We need to join + * all IDAT chunks to get a raw zlib data stream, then strip off + * the 2-byte ZLIB header and 4-byte checksum to get a raw DEFLATE + * stream. + */ + PNGChunk *idat = PNGJoinIDAT(&ihdr->hdr); + unsigned long compressedSize = bswap32(idat->length) - 6; + puff(rawBuffer, &rawSize, idat->data + 2, &compressedSize); + + /* + * Line-by-line, expand the decompressed filtered data into BGRX. + */ + + uint32 lines = height; + Bool notFirstRow = FALSE; + + while (lines--) { + uint8 *rawLine = rawBuffer; + uint32 *fbLine = framebuffer; + uint32 pixels = width; + + framebuffer = (uint32*) (pitch + (uint8*)framebuffer); + rawBuffer += rawPitch; + + uint8 filterType = *(rawLine++); + Bool notFirstColumn = FALSE; + + while (pixels--) { + + /* + * Undo the per-scanline filtering. + */ + + uint8 *up = rawLine - rawPitch; + uint8 *left = rawLine - 3; + uint8 *upLeft = rawLine - 3 - rawPitch; + uint32 i; + + for (i = 0; i < 3; i++) { + switch (filterType) { + + case 0: // None + break; + + case 1: // Sub + if (notFirstColumn) { + rawLine[i] += left[i]; + } + break; + + case 2: // Up + if (notFirstRow) { + rawLine[i] += up[i]; + } + break; + + case 3: // Average + rawLine[i] += ((notFirstColumn ? left[i] : 0) + + (notFirstRow ? up[i] : 0)) >> 1; + break; + + case 4: // Paeth + rawLine[i] += PaethPredictor(notFirstColumn ? left[i] : 0, + notFirstRow ? up[i] : 0, + (notFirstRow && notFirstColumn) + ? upLeft[i] : 0); + break; + } + } + + /* + * Decode RGB to BGRX. + */ + + uint8 r = rawLine[0]; + uint8 g = rawLine[1]; + uint8 b = rawLine[2]; + + *(fbLine++) = (r << 16) | (g << 8) | b; + + rawLine += 3; + notFirstColumn = TRUE; + } + notFirstRow = TRUE; + } +} diff --git a/lib/util/png.h b/lib/util/png.h new file mode 100644 index 0000000..a86690a --- /dev/null +++ b/lib/util/png.h @@ -0,0 +1,93 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * png.h -- + * + * An extremely simple library for reading in-memory PNG images. + * + * This library has no validation at all, so it must be used only + * with images from trusted sources. + */ + +#ifndef __PNG_H__ +#define __PNG_H__ + +#include "types.h" + + +/* + * PNG fields are in Big Endian byte order. Define a new data type + * for Big Endian numbers, and an inline function to do 32-bit byte + * swapping. + */ + +typedef uint32 be32; + +static inline uint32 +bswap32(uint32 x) +{ + __asm__ ("bswap %0" : "+r" (x)); + return x; +} + + +/* + * PNG data types + */ + +typedef struct { + be32 length; + uint32 type; + uint8 data[0]; +} PNGChunk; + +typedef struct { + PNGChunk hdr; + be32 width; + be32 height; + uint8 bitDepth; + uint8 colorType; + uint8 compression; + uint8 filter; + uint8 interlace; +} PNGChunkIHDR; + +#define PNG_CHUNK(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24)) +#define PNG_IHDR PNG_CHUNK('I','H','D','R') +#define PNG_IDAT PNG_CHUNK('I','D','A','T') +#define PNG_IEND PNG_CHUNK('I','E','N','D') + + +/* + * Public functions + */ + +PNGChunkIHDR *PNG_Header(void *pngData); +PNGChunk *PNG_NextChunk(PNGChunk *lastChunk); +void PNG_DecompressBGRX(PNGChunkIHDR *ihdr, uint32 *framebuffer, uint32 pitch); + + +#endif /* __PNG_H_ */ diff --git a/lib/util/svga3dtext.c b/lib/util/svga3dtext.c new file mode 100644 index 0000000..48b3a42 --- /dev/null +++ b/lib/util/svga3dtext.c @@ -0,0 +1,432 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga3dtext.c -- + * + * Emulated text console, built on the SVGA3D protocol. This + * module allows the use of the VGA Console in 3D mode. We + * convert the ROM BIOS font into a texture, and sample character + * data from the text-mode framebuffer. Text attributes are + * ignored. + * + * This is used as a debug/diagnostic facility in the example + * programs, plus it's a simple but relatively efficient example + * of rendering using dynamic vertex buffer data. + * + * XXX: Now that there can be multiple Console backends, this no + * longer needs to be tied to VGA. We should just implement this + * as a normal Console backend. + */ + +#include "svga3dutil.h" +#include "svga3dtext.h" +#include "matrix.h" +#include "console_vga.h" + +typedef uint16 IndexType; + +typedef struct { + uint16 position[2]; + float texCoord[2]; + uint32 color; +} VertexType; + +#define MAX_NUM_CHARACTERS (VGA_TEXT_WIDTH * VGA_TEXT_HEIGHT) +#define MAX_VERTICES (MAX_NUM_CHARACTERS * 4) +#define MAX_INDICES (MAX_NUM_CHARACTERS * 6) +#define INDEX_BUF_SIZE (MAX_INDICES * sizeof(IndexType)) +#define VERTEX_BUF_SIZE (MAX_VERTICES * sizeof(VertexType)) +#define FONT_CHARACTERS 256 +#define FONT_CHAR_WIDTH 9 +#define FONT_CHAR_HEIGHT 9 +#define FONT_GRID_WIDTH 25 +#define FONT_WIDTH 256 +#define FONT_HEIGHT 64 + +static struct { + uint32 fontSid; + uint32 ibSid; + + uint32 vbSid; + SVGAGuestPtr vbGuestPtr; + VertexType *vbBuffer; + uint32 vbFence; + uint32 numTriangles; + + Matrix view; +} self; + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DTextUnpackROMFont -- + * + * Unpack the ROM BIOS font into a square texture, 16 characters + * by 8 characters, in 8-bit alpha format. + * + * Results: + * None. + * + * Side effects: + * Reads from BIOS memory. + * + *---------------------------------------------------------------------- + */ + +static void +SVGA3DTextUnpackROMFont(uint8 *buffer) +{ + uint8 *romFont = (uint8*) 0xFFA6E; + uint8 fontChar = 0; + int gridX = 0, gridY = 0; + int charY; + + memset(buffer, 0, FONT_WIDTH * FONT_HEIGHT); + + while (fontChar < 128) { + for (charY = 0; charY < 8; charY++) { + uint8 fontByte = *(romFont++); + uint8 mask = 0x80; + uint8 *bufferLine = &buffer[FONT_WIDTH * (gridY * FONT_CHAR_HEIGHT + charY) + + gridX * FONT_CHAR_WIDTH]; + while (mask) { + if (fontByte & mask) { + *bufferLine = 0xFF; + } + bufferLine++; + mask >>= 1; + } + } + fontChar++; + gridX++; + if (gridX == FONT_GRID_WIDTH) { + gridX = 0; + gridY++; + } + } +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DText_Init -- + * + * Initialize the SVGA3DText module. This populates the font + * texture, and sets up the vertex buffer and index buffer + * surfaces. It implicitly calls SVGA3DText_Update() for the + * first time. + * + * Results: + * None. + * + * Side effects: + * Allocates buffers, begins DMA. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DText_Init(void) +{ + int i; + void *fontBuffer; + IndexType *indexBuffer; + SVGAGuestPtr fontGuestPtr; + SVGAGuestPtr ibGuestPtr; + + /* + * XXX: We should stop depending on console_vga, and get our own framebuffer. + */ + ConsoleVGA_Init(); + + /* + * Populate the font texture with our ROM BIOS font. + */ + + fontBuffer = SVGA3DUtil_AllocDMABuffer(FONT_WIDTH * FONT_HEIGHT, &fontGuestPtr); + SVGA3DTextUnpackROMFont(fontBuffer); + + self.fontSid = SVGA3DUtil_DefineSurface2D(FONT_WIDTH, FONT_HEIGHT, SVGA3D_ALPHA8); + SVGA3DUtil_SurfaceDMA2D(self.fontSid, &fontGuestPtr, SVGA3D_WRITE_HOST_VRAM, + FONT_WIDTH, FONT_HEIGHT); + + /* + * Populate the index buffer with a static pattern for drawing quads. + */ + + indexBuffer = SVGA3DUtil_AllocDMABuffer(INDEX_BUF_SIZE, &ibGuestPtr); + + for (i = 0; i < MAX_NUM_CHARACTERS; i++) { + /* First triangle */ + indexBuffer[i * 6 + 0] = i * 4 + 0; + indexBuffer[i * 6 + 1] = i * 4 + 1; + indexBuffer[i * 6 + 2] = i * 4 + 2; + + /* Second triangle */ + indexBuffer[i * 6 + 3] = i * 4 + 2; + indexBuffer[i * 6 + 4] = i * 4 + 3; + indexBuffer[i * 6 + 5] = i * 4 + 0; + } + + self.ibSid = SVGA3DUtil_DefineSurface2D(INDEX_BUF_SIZE, 1, SVGA3D_BUFFER); + SVGA3DUtil_SurfaceDMA2D(self.ibSid, &ibGuestPtr, SVGA3D_WRITE_HOST_VRAM, + INDEX_BUF_SIZE, 1); + + /* + * Set up an empty vertex buffer. We'll fill it later. + */ + + self.vbBuffer = SVGA3DUtil_AllocDMABuffer(VERTEX_BUF_SIZE, &self.vbGuestPtr); + self.vbSid = SVGA3DUtil_DefineSurface2D(VERTEX_BUF_SIZE, 1, SVGA3D_BUFFER); + + /* + * Set up the view matrix. + */ + { + const float border = 0.05; + const float width = (2.0 - border*2) / VGA_TEXT_WIDTH; + const float height = (2.0 - border*2) / VGA_TEXT_HEIGHT; + + Matrix_Copy(self.view, gIdentityMatrix); + Matrix_Scale(self.view, width, -height, 1, 1); + Matrix_Translate(self.view, -1 + border, 1 - border, 0); + } + + SVGA3DText_Update(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DText_Update -- + * + * Build and upload a vertex buffer for rendering text from the + * current contents of the VGA framebuffer. + * + * Results: + * None. + * + * Side effects: + * May SyncToFence. Reads VGA memory. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DText_Update(void) +{ + uint8 *textFb = (uint8*) 0xB8000; + int x, y; + VertexType *vertex = self.vbBuffer; + + /* Wait for any previous DMA operations to finish. */ + SVGA_SyncToFence(self.vbFence); + + self.numTriangles = 0; + + for (y = 0; y < VGA_TEXT_HEIGHT; y++) { + for (x = 0; x < VGA_TEXT_WIDTH; x++) { + uint8 textChar = *textFb; + textFb += 2; + + if (textChar > 0 && textChar < 0x80 && textChar != ' ') { + int charX = textChar % FONT_GRID_WIDTH; + int charY = textChar / FONT_GRID_WIDTH; + const float xHalfTexel = 0.5 / (float)FONT_WIDTH; + const float yHalfTexel = 0.5 / (float)FONT_HEIGHT; + const float charWidth = FONT_CHAR_WIDTH / (float)FONT_WIDTH; + const float charHeight = FONT_CHAR_WIDTH / (float)FONT_HEIGHT; + + vertex[0].position[0] = x; + vertex[0].position[1] = y; + vertex[0].texCoord[0] = charX * charWidth - xHalfTexel; + vertex[0].texCoord[1] = charY * charHeight - yHalfTexel; + vertex[0].color = 0xFFFFFFFF; + + vertex[2].position[0] = x+1; + vertex[2].position[1] = y+1; + vertex[2].texCoord[0] = (charX+1) * charWidth - xHalfTexel; + vertex[2].texCoord[1] = (charY+1) * charHeight - yHalfTexel; + vertex[2].color = 0xFFFFFFFF; + + vertex[1].position[0] = vertex[2].position[0]; + vertex[1].position[1] = vertex[0].position[1]; + vertex[1].texCoord[0] = vertex[2].texCoord[0]; + vertex[1].texCoord[1] = vertex[0].texCoord[1]; + vertex[1].color = 0xFFFFFFFF; + + vertex[3].position[0] = vertex[0].position[0]; + vertex[3].position[1] = vertex[2].position[1]; + vertex[3].texCoord[0] = vertex[0].texCoord[0]; + vertex[3].texCoord[1] = vertex[2].texCoord[1]; + vertex[3].color = 0xFFFFFFFF; + + self.numTriangles += 2; + vertex += 4; + } + } + } + + SVGA3DUtil_SurfaceDMA2D(self.vbSid, &self.vbGuestPtr, SVGA3D_WRITE_HOST_VRAM, + (uint8*)vertex - (uint8*)self.vbBuffer, 1); + self.vbFence = SVGA_InsertFence(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DText_Draw -- + * + * Draw a screen full of text, using the current vertex buffer contents. + * + * Results: + * None. + * + * Side effects: + * Modifies a lot of render state. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DText_Draw(void) +{ + SVGA3dVertexDecl *decls; + SVGA3dPrimitiveRange *ranges; + SVGA3dTextureState *ts; + SVGA3dRenderState *rs; + + static const SVGA3dMaterial mat = { + .diffuse = { 1, 1, 1, 1 }, + }; + + SVGA3D_SetMaterial(CID, SVGA3D_FACE_FRONT_BACK, &mat); + + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, self.view); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, gIdentityMatrix); + SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, gIdentityMatrix); + + SVGA3D_BeginSetRenderState(CID, &rs, 8); + { + rs[0].state = SVGA3D_RS_ZENABLE; + rs[0].uintValue = FALSE; + + rs[1].state = SVGA3D_RS_ZWRITEENABLE; + rs[1].uintValue = FALSE; + + rs[2].state = SVGA3D_RS_BLENDENABLE; + rs[2].uintValue = TRUE; + + rs[3].state = SVGA3D_RS_SRCBLEND; + rs[3].uintValue = SVGA3D_BLENDOP_SRCALPHA; + + rs[4].state = SVGA3D_RS_DSTBLEND; + rs[4].uintValue = SVGA3D_BLENDOP_INVSRCALPHA; + + rs[5].state = SVGA3D_RS_BLENDEQUATION; + rs[5].uintValue = SVGA3D_BLENDEQ_ADD; + + rs[6].state = SVGA3D_RS_LIGHTINGENABLE; + rs[6].uintValue = FALSE; + + rs[7].state = SVGA3D_RS_CULLMODE; + rs[7].uintValue = SVGA3D_FACE_NONE; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginSetTextureState(CID, &ts, 9); + { + ts[0].stage = 0; + ts[0].name = SVGA3D_TS_BIND_TEXTURE; + ts[0].value = self.fontSid; + + ts[1].stage = 0; + ts[1].name = SVGA3D_TS_COLOROP; + ts[1].value = SVGA3D_TC_SELECTARG1; + + ts[2].stage = 0; + ts[2].name = SVGA3D_TS_COLORARG1; + ts[2].value = SVGA3D_TA_DIFFUSE; + + ts[3].stage = 0; + ts[3].name = SVGA3D_TS_ALPHAOP; + ts[3].value = SVGA3D_TC_SELECTARG1; + + ts[4].stage = 0; + ts[4].name = SVGA3D_TS_ALPHAARG1; + ts[4].value = SVGA3D_TA_TEXTURE; + + ts[5].stage = 0; + ts[5].name = SVGA3D_TS_MINFILTER; + ts[5].value = SVGA3D_TEX_FILTER_LINEAR; + + ts[6].stage = 0; + ts[6].name = SVGA3D_TS_MAGFILTER; + ts[6].value = SVGA3D_TEX_FILTER_LINEAR; + + ts[7].stage = 0; + ts[7].name = SVGA3D_TS_ADDRESSU; + ts[7].value = SVGA3D_TEX_ADDRESS_WRAP; + + ts[8].stage = 0; + ts[8].name = SVGA3D_TS_ADDRESSV; + ts[8].value = SVGA3D_TEX_ADDRESS_WRAP; + } + SVGA_FIFOCommitAll(); + + SVGA3D_BeginDrawPrimitives(CID, &decls, 3, &ranges, 1); + { + decls[0].identity.type = SVGA3D_DECLTYPE_SHORT2; + decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; + decls[0].array.surfaceId = self.vbSid; + decls[0].array.stride = sizeof(VertexType); + decls[0].array.offset = offsetof(VertexType, position); + + decls[1].identity.type = SVGA3D_DECLTYPE_FLOAT2; + decls[1].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD; + decls[1].array.surfaceId = self.vbSid; + decls[1].array.stride = sizeof(VertexType); + decls[1].array.offset = offsetof(VertexType, texCoord); + + decls[2].identity.type = SVGA3D_DECLTYPE_D3DCOLOR; + decls[2].identity.usage = SVGA3D_DECLUSAGE_COLOR; + decls[2].array.surfaceId = self.vbSid; + decls[2].array.stride = sizeof(VertexType); + decls[2].array.offset = offsetof(VertexType, color); + + ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; + ranges[0].primitiveCount = self.numTriangles; + ranges[0].indexArray.surfaceId = self.ibSid; + ranges[0].indexArray.stride = sizeof(IndexType); + ranges[0].indexWidth = sizeof(IndexType); + } + SVGA_FIFOCommitAll(); + SVGA_RingDoorbell(); +} diff --git a/lib/util/svga3dtext.h b/lib/util/svga3dtext.h new file mode 100644 index 0000000..7a33d24 --- /dev/null +++ b/lib/util/svga3dtext.h @@ -0,0 +1,48 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga3dtext.h -- + * + * Emulated text console, built on the SVGA3D protocol. This + * module allows the use of VGAText in 3D mode. We convert the + * ROM BIOS font into a texture, and sample character data from + * the text-mode framebuffer. Text attributes are ignored. + * + * This is used as a debug/diagnostic facility in the example + * programs, plus it's a simple but relatively efficient example + * of rendering using dynamic vertex buffer data. + */ + +#ifndef __SVGA3DTEXT_H__ +#define __SVGA3DTEXT_H__ + +#include "console.h" + +void SVGA3DText_Init(void); +void SVGA3DText_Update(void); +void SVGA3DText_Draw(void); + +#endif /* __SVGA3DTEXT_H__ */ diff --git a/lib/util/svga3dutil.c b/lib/util/svga3dutil.c new file mode 100644 index 0000000..c251e0f --- /dev/null +++ b/lib/util/svga3dutil.c @@ -0,0 +1,749 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga3dutil.c -- + * + * Higher-level convenience functions built on top of the SVGA3D + * FIFO command layer. + */ + +#include "svga3dutil.h" +#include "intr.h" + +FullscreenState gFullscreen; + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_InitFullscreen -- + * + * This is a "big hammer" for initializing the SVGA device in + * our simple 3D example programs. It does the following: + * + * - Initializes interrupts + * - Initializes the SVGA adapter + * - Switches video modes + * - Initializes the absolute mouse + * - Initializes the 3D subsystem + * - Creates a color buffer and depth buffer + * - Creates a context + * - Attaches the color/depth buffers to the context + * - Sets the viewport + * - Sets default render states + * + * Results: + * void. + * + * Side effects: + * Panic if anything fails. + * Stores the fullscreen color buffer surface ID. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DUtil_InitFullscreen(uint32 cid, // IN + uint32 width, // IN + uint32 height) // IN +{ + SVGA3dRenderState *rs; + + gFullscreen.screen.x = 0; + gFullscreen.screen.y = 0; + gFullscreen.screen.w = width; + gFullscreen.screen.h = height; + + Intr_Init(); + Intr_SetFaultHandlers(SVGA_DefaultFaultHandler); + + SVGA_Init(); + SVGA_SetMode(width, height, 32); + VMBackdoor_MouseInit(TRUE); + SVGA3D_Init(); + + gFullscreen.colorImage.sid = SVGA3DUtil_DefineSurface2D(width, height, + SVGA3D_X8R8G8B8); + + gFullscreen.depthImage.sid = SVGA3DUtil_DefineSurface2D(width, height, + SVGA3D_Z_D16); + + SVGA3D_DefineContext(cid); + + SVGA3D_SetRenderTarget(cid, SVGA3D_RT_COLOR0, &gFullscreen.colorImage); + SVGA3D_SetRenderTarget(cid, SVGA3D_RT_DEPTH, &gFullscreen.depthImage); + + SVGA3D_SetViewport(cid, &gFullscreen.screen); + SVGA3D_SetZRange(cid, 0.0f, 1.0f); + + /* + * The device defaults to flat shading, but to retain compatibility + * across OpenGL and Direct3D it may be much slower in this + * mode. Usually we don't want flat shading, so go ahead and switch + * into smooth shading mode. + * + * Note that this is a per-context render state. + * + * XXX: There is also a bug in VMware Workstation 6.5.2 which shows + * up if you're in flat shading mode and you're using a drawing + * command which does not include an SVGA3dVertexDivisor array. + * Avoiding flat shading is one workaround, another is to include + * a dummy SVGA3dVertexDivisor array on every draw. + */ + + SVGA3D_BeginSetRenderState(cid, &rs, 1); + { + rs[0].state = SVGA3D_RS_SHADEMODE; + rs[0].uintValue = SVGA3D_SHADEMODE_SMOOTH; + } + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_PresentFullscreen -- + * + * This is a simplified version of SVGA3D_BeginPresent(), which + * assumes that we're running in full-screen mode and that the + * whole screen needs updating. + * + * It also includes the recommended flow control, to prevent + * the SVGA3D device from lagging too far behind the driver- + * we use FIFO fences to ensure that only one Present command + * is in the FIFO at once. + * + * This is much better than performing a full Sync after each + * Present, since it allows the guest to be preparing frame N+1 + * while the host is still rendering frame N. + * + * Note that this simplified logic needs to be modified if the + * application/driver is presenting from multiple + * surfaces. Ideally, we actaully want only a single frame per + * surface in the FIFO at once. It is recommended that drivers + * store lastPresentFence per-surface. + * + * Results: + * None. + * + * Side effects: + * SVGA_SyncToFence(). + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DUtil_PresentFullscreen(void) +{ + SVGA3dCopyRect *cr; + + SVGA_SyncToFence(gFullscreen.lastPresentFence); + + SVGA3D_BeginPresent(gFullscreen.colorImage.sid, &cr, 1); + memset(cr, 0, sizeof *cr); + cr->w = gSVGA.width; + cr->h = gSVGA.height; + SVGA_FIFOCommitAll(); + + gFullscreen.lastPresentFence = SVGA_InsertFence(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_AsyncCall -- + * + * This is a simple asynchronous call mechanism, which is used to + * invoke a specified function once the SVGA3D device's FIFO + * processing has reached the current point in the command + * stream. It can be used, for example, to asynchronously garbage + * collect DMA buffers or asynchronously handle downloads from + * host VRAM. + * + * This single function both dispatches previous calls and + * optionall enqueues a new call. + * + * A fixed number of asynchronous calls may be in flight at any + * given time. If MAX_ASYNC_CALLS calls are pending, we wait for + * the oldest one to finish. + * + * You can call this function with handler==NULL to just flush + * any existing async calls which have completed. + * + * Results: + * None. + * + * Side effects: + * SVGA_SyncToFence(), any side-effects caused by other async + * call handlers. If we're enqueueing a handler, this inserts + * a FIFO fence. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DUtil_AsyncCall(AsyncCallFn handler, // IN (optional) + void *arg) // IN (optional) +{ + static struct { + uint32 head, tail, count; + struct { + AsyncCallFn handler; + void *arg; + uint32 fence; + } calls[MAX_ASYNC_CALLS]; + } queue; + + if (queue.count > MAX_ASYNC_CALLS || + queue.head >= MAX_ASYNC_CALLS || + queue.tail >= MAX_ASYNC_CALLS) { + SVGA_Panic("Async call queue corrupted"); + } + + if (queue.count == MAX_ASYNC_CALLS) { + SVGA_SyncToFence(queue.calls[queue.tail].fence); + } + + while (queue.count && SVGA_HasFencePassed(queue.calls[queue.tail].fence)) { + queue.calls[queue.tail].handler(queue.calls[queue.tail].arg); + queue.tail = (queue.tail + 1) % MAX_ASYNC_CALLS; + queue.count--; + } + + if (handler) { + queue.calls[queue.head].handler = handler; + queue.calls[queue.head].arg = arg; + queue.calls[queue.head].fence = SVGA_InsertFence(); + queue.head = (queue.head + 1) % MAX_ASYNC_CALLS; + queue.count++; + } +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_UpdateFPSCounter -- + * + * This is a simple self-contained frame and frame rate counter. + * + * Initialize an FPSCounterState structure to zero (or allocate + * it in the BSS segment) and call this function once per frame. + * Any time it returns TRUE, the caller should update the + * on-screen display with a new frame rate. + * + * Guaranteed to return TRUE on the first call. + * + * Results: + * TRUE if the frame rate needs updating. + * + * Side effects: + * Occasionally requests the current host wallclock time via the + * VMware backdoor port. + * + *---------------------------------------------------------------------- + */ + +static char +FPSDigit(uint32 n, uint32 divisor) +{ + n /= divisor; + if (n == 0) { + return ' '; + } else { + return (n % 10) + '0'; + } +} + +Bool +SVGA3DUtil_UpdateFPSCounter(FPSCounterState *self) // IN/OUT +{ + uint32 msecDiff; + uint32 frameDiff; + + if (!self->initialized) { + VMBackdoor_GetTime(&self->now); + self->lastUpdate.time = self->now; + self->initialized = TRUE; + return TRUE; + } + + self->frame++; + + /* + * Only check the time every several frames, to avoid the small + * overhead of making backdoor calls on every frame. + */ + if (self->frame & 0x0F) { + return FALSE; + } + + VMBackdoor_GetTime(&self->now); + + msecDiff = VMBackdoor_TimeDiffUS(&self->lastUpdate.time, &self->now) / 1000; + + if (msecDiff < 500) { + /* Too soon since the last update */ + return FALSE; + } + + frameDiff = self->frame - self->lastUpdate.frame; + self->hundredths = (frameDiff * (1000 * 100)) / msecDiff; + + self->text[0] = FPSDigit(self->hundredths, 1000000); + self->text[1] = FPSDigit(self->hundredths, 100000); + self->text[2] = FPSDigit(self->hundredths, 10000); + self->text[3] = FPSDigit(self->hundredths, 1000); + self->text[4] = FPSDigit(self->hundredths, 100); + self->text[5] = '.'; + self->text[6] = FPSDigit(self->hundredths, 10); + self->text[7] = FPSDigit(self->hundredths, 1); + self->text[8] = ' '; + self->text[9] = 'F'; + self->text[10] = 'P'; + self->text[11] = 'S'; + self->text[12] = '\0'; + + self->lastUpdate.time = self->now; + self->lastUpdate.frame = self->frame; + return TRUE; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_AllocSurfaceID -- + * + * Allocate the next available surface ID. + * + * XXX: This is a trivial implementation which just returns + * an incrementing integer. + * + * Results: + * Returns an unused sid. + * + * Side effects: + * Marks this sid as used. + * + *---------------------------------------------------------------------- + */ + +uint32 +SVGA3DUtil_AllocSurfaceID(void) +{ + static uint32 nextSid = 0; + return nextSid++; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_AllocDMABuffer -- + * + * Allocate a buffer for DMA operations. Returns both a pointer + * (for us to use) and an SVGAGuestPtr (for the SVGA3D device to + * use). + * + * XXX: This is a trivial implementation which just returns + * consecutive addresses in the framebuffer. + * + * Results: + * Returns a local pointer and an SVGAGuestPtr to unused memory. + * + * Side effects: + * Allocates memory. + * + *---------------------------------------------------------------------- + */ + +void * +SVGA3DUtil_AllocDMABuffer(uint32 size, // IN + SVGAGuestPtr *ptr) // OUT +{ + static SVGAGuestPtr nextPtr = { SVGA_GMR_FRAMEBUFFER, 0 }; + *ptr = nextPtr; + nextPtr.offset += size; + return gSVGA.fbMem + ptr->offset; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_DefineSurface2D -- + * + * This is a simplified version of SVGA3D_BeginDefineSurface(), + * which does not support cube maps, mipmaps, or volume textures. + * + * Results: + * Returns the new surface ID. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +uint32 +SVGA3DUtil_DefineSurface2D(uint32 width, // IN + uint32 height, // IN + SVGA3dSurfaceFormat format) // IN +{ + uint32 sid; + SVGA3dSize *mipSizes; + SVGA3dSurfaceFace *faces; + + sid = SVGA3DUtil_AllocSurfaceID(); + SVGA3D_BeginDefineSurface(sid, 0, format, &faces, &mipSizes, 1); + + faces[0].numMipLevels = 1; + + mipSizes[0].width = width; + mipSizes[0].height = height; + mipSizes[0].depth = 1; + + SVGA_FIFOCommitAll(); + + return sid; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_SurfaceDMA2D -- + * + * This is a simplified version of SVGA3D_BeginSurfaceDMA(), + * which copies a single 2D rectangle rooted at 0,0. It does + * not support volume textures, mipmaps, cube maps, or guest + * images with non-default pitch. + * + * Results: + * None. + * + * Side effects: + * Begins an asynchronous DMA operation. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DUtil_SurfaceDMA2D(uint32 sid, // IN + SVGAGuestPtr *guestPtr, // IN + SVGA3dTransferType transfer, // IN + uint32 width, // IN + uint32 height) // IN +{ + SVGA3dCopyBox *boxes; + SVGA3dGuestImage guestImage; + SVGA3dSurfaceImageId hostImage = { sid }; + + guestImage.ptr = *guestPtr; + guestImage.pitch = 0; + + SVGA3D_BeginSurfaceDMA(&guestImage, &hostImage, transfer, &boxes, 1); + boxes[0].w = width; + boxes[0].h = height; + boxes[0].d = 1; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_DefineStaticBuffer -- + * + * This is a simplified function which defines a 1 dimensional + * surface with the format SVGA3D_BUFFER, copies the supplied + * data into a new DMA buffer, and begins a DMA transfer into + * the new surface. + * + * Results: + * Returns the new surface ID. + * + * Side effects: + * Allocates a surface. + * Allocates a DMA buffer. + * Begins an asynchronous DMA operation. + * + *---------------------------------------------------------------------- + */ + +uint32 +SVGA3DUtil_DefineStaticBuffer(const void *data, // IN + uint32 size) // IN +{ + void *buffer; + SVGAGuestPtr gPtr; + uint32 sid = SVGA3DUtil_DefineSurface2D(size, 1, SVGA3D_BUFFER); + + buffer = SVGA3DUtil_AllocDMABuffer(size, &gPtr); + memcpy(buffer, data, size); + + SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, size, 1); + + return sid; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_LoadCompressedBuffer -- + * + * This is a simplified function which defines a 1 dimensional + * surface with the format SVGA3D_BUFFER, decompresses a DataFile + * object into a new DMA buffer, and begins a DMA transfer into + * the new surface. + * + * Results: + * Returns the new surface ID. Optionally returns the + * decompressed size of the buffer. + * + * Side effects: + * Allocates a surface. + * Allocates a DMA buffer. + * Begins an asynchronous DMA operation. + * + *---------------------------------------------------------------------- + */ + +uint32 +SVGA3DUtil_LoadCompressedBuffer(const DataFile *file, // IN + uint32 *pSize) // OUT (optional) +{ + void *buffer; + SVGAGuestPtr gPtr; + uint32 size = DataFile_GetDecompressedSize(file); + uint32 sid = SVGA3DUtil_DefineSurface2D(size, 1, SVGA3D_BUFFER); + + buffer = SVGA3DUtil_AllocDMABuffer(size, &gPtr); + DataFile_Decompress(file, buffer, size); + + SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, size, 1); + + if (pSize) { + *pSize = size; + } + + return sid; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_ClearFullscreen -- + * + * This is a simplified version of SVGA3D_BeginClear(), which + * assumes we're in full-screen mode and that the entire render + * target needs to be cleared. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DUtil_ClearFullscreen(uint32 cid, // IN + SVGA3dClearFlag flags, // IN + uint32 color, // IN + float depth, // IN + uint32 stencil) // IN +{ + SVGA3dRect *rect; + + SVGA3D_BeginClear(cid, flags, color, depth, stencil, &rect, 1); + memset(rect, 0, sizeof *rect); + rect->w = gSVGA.width; + rect->h = gSVGA.height; + SVGA_FIFOCommitAll(); +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_AllocDMAPool -- + * + * This is a simple example implementation of a DMA buffer pool- + * a collection of identically-sized DMA buffers which are + * allocated once and recycled. + * + * Results: + * Initializes the provided DMAPool structure. + * + * Side effects: + * Allocates DMA memory. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DUtil_AllocDMAPool(DMAPool *self, // OUT + uint32 bufferSize, // IN + uint32 numBuffers) // IN +{ + int i; + + memset(self, 0, sizeof *self); + + self->bufferSize = bufferSize; + self->numBuffers = numBuffers; + + if (numBuffers > MAX_DMA_POOL_BUFFERS) { + SVGA_Panic("DMA pool larger than MAX_DMA_POOL_BUFFERS"); + } + + for (i = 0; i < numBuffers; i++) { + + self->buffers[i].pool = self; + self->buffers[i].buffer = SVGA3DUtil_AllocDMABuffer(bufferSize, + &self->buffers[i].ptr); + + self->buffers[i].next = self->freeList; + self->freeList = &self->buffers[i]; + } +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_DMAPoolGetBuffer -- + * + * Retrieve an available buffer from a DMAPool. This + * returns the first available buffer from our freelist. + * + * If no buffers are on the freelist, we use Sync and + * AsyncCall to give them a chance to become available. + * + * If that fails, there must have been a buffer leak. We panic. + * + * Results: + * Returns an available DMAPoolBuffer. + * + * Side effects: + * May Sync. May run AsyncCall callbacks. + * + *---------------------------------------------------------------------- + */ + +DMAPoolBuffer * +SVGA3DUtil_DMAPoolGetBuffer(DMAPool *self) // IN/OUT +{ + DMAPoolBuffer *buffer; + + if (!self->freeList) { + SVGA_SyncToFence(SVGA_InsertFence()); + SVGA3DUtil_AsyncCall(NULL, NULL); + } + + buffer = self->freeList; + if (!buffer) { + SVGA_Panic("No DMA buffers available from pool"); + } + + self->freeList = buffer->next; + return buffer; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_DMAPoolFreeBuffer -- + * + * Recycle an old DMAPool buffer. This function should be called + * only once the DMA transfer has been completed by the device. + * You must use the FIFO fence mechanism to guarantee this. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DUtil_DMAPoolFreeBuffer(DMAPoolBuffer *buffer) // IN +{ + buffer->next = buffer->pool->freeList; + buffer->pool->freeList = buffer; +} + + +/* + *---------------------------------------------------------------------- + * + * SVGA3DUtil_SetShaderConstMatrix -- + * + * This is a simple wrapper around SVGA3D_SetShaderConst which + * makes it easier to set a constant matrix. + * + * Each column of the matrix is stored separately, in four + * consecutive float4 vectors. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +SVGA3DUtil_SetShaderConstMatrix(uint32 cid, // IN + uint32 reg, // IN + SVGA3dShaderType type, // IN + const float *matrix) // IN +{ + int col; + + for (col = 0; col < 4; col++) { + float vector[4]; + + vector[0] = matrix[col + 0]; + vector[1] = matrix[col + 4]; + vector[2] = matrix[col + 8]; + vector[3] = matrix[col + 12]; + + SVGA3D_SetShaderConst(cid, reg + col, type, + SVGA3D_CONST_TYPE_FLOAT, vector); + } +} diff --git a/lib/util/svga3dutil.h b/lib/util/svga3dutil.h new file mode 100644 index 0000000..d87f697 --- /dev/null +++ b/lib/util/svga3dutil.h @@ -0,0 +1,141 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga3dutil.h -- + * + * Higher-level convenience functions built on top of the SVGA3D + * FIFO command layer. + */ + +#ifndef __SVGA3DUTIL_H__ +#define __SVGA3DUTIL_H__ + +#include "svga3d.h" +#include "vmbackdoor.h" +#include "datafile.h" + +/* + * Default cid for single-context example programs. This constant + * isn't used by svga3dutil itself, but it's provided as a convenience + * for example programs that don't need multiple contexts. + */ + +#define CID 1 + +#define MAX_ASYNC_CALLS 128 +#define MAX_DMA_POOL_BUFFERS 128 + +typedef struct DMAPool DMAPool; + +typedef struct DMAPoolBuffer { + DMAPool *pool; + struct DMAPoolBuffer *next; + void *buffer; + SVGAGuestPtr ptr; +} DMAPoolBuffer; + +struct DMAPool { + uint32 bufferSize; + uint32 numBuffers; + DMAPoolBuffer *freeList; + DMAPoolBuffer buffers[MAX_DMA_POOL_BUFFERS]; +}; + +typedef struct FPSCounterState { + VMTime now; + uint32 frame; + Bool initialized; + + char text[16]; + int hundredths; + + struct { + VMTime time; + uint32 frame; + } lastUpdate; +} FPSCounterState; + +/* + * Global data used by the "Fullscreen" utility functions. These + * utilities make extra assumptions: We're rendering from a single + * color buffer, and we're using the SVGA device's full resolution. + */ + +typedef struct FullscreenState { + SVGA3dSurfaceImageId colorImage; + SVGA3dSurfaceImageId depthImage; + uint32 lastPresentFence; + SVGA3dRect screen; +} FullscreenState; + +extern FullscreenState gFullscreen; + +typedef void (*AsyncCallFn)(void *); + + +/* + * Device-level Functionality + */ + +void SVGA3DUtil_InitFullscreen(uint32 cid, uint32 width, uint32 height); +void SVGA3DUtil_PresentFullscreen(void); +void SVGA3DUtil_AsyncCall(AsyncCallFn handler, void *arg); +Bool SVGA3DUtil_UpdateFPSCounter(FPSCounterState *self); + +/* + * Surface Management + */ + +uint32 SVGA3DUtil_AllocSurfaceID(void); +void *SVGA3DUtil_AllocDMABuffer(uint32 size, SVGAGuestPtr *ptr); + +uint32 SVGA3DUtil_DefineSurface2D(uint32 width, uint32 height, + SVGA3dSurfaceFormat format); +void SVGA3DUtil_SurfaceDMA2D(uint32 sid, SVGAGuestPtr *guestPtr, + SVGA3dTransferType transfer, uint32 width, uint32 height); + +uint32 SVGA3DUtil_DefineStaticBuffer(const void *data, uint32 size); +uint32 SVGA3DUtil_LoadCompressedBuffer(const DataFile *file, uint32 *pSize); + +void SVGA3DUtil_AllocDMAPool(DMAPool *self, uint32 bufferSize, uint32 numBuffers); +DMAPoolBuffer *SVGA3DUtil_DMAPoolGetBuffer(DMAPool *self); +void SVGA3DUtil_DMAPoolFreeBuffer(DMAPoolBuffer *buffer); + +/* + * Shaders + */ + +void SVGA3DUtil_SetShaderConstMatrix(uint32 cid, uint32 reg, + SVGA3dShaderType type, const float *matrix); + +/* + * Drawing Operations + */ + +void SVGA3DUtil_ClearFullscreen(uint32 cid, SVGA3dClearFlag flags, + uint32 color, float depth, uint32 stencil); + +#endif /* __SVGA3DUTIL_H__ */ diff --git a/lib/util/vmbackdoor.c b/lib/util/vmbackdoor.c new file mode 100644 index 0000000..b9a0604 --- /dev/null +++ b/lib/util/vmbackdoor.c @@ -0,0 +1,511 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * vmbackdoor.c -- + * + * This is a tiny and self-contained client implementation of + * VMware's backdoor protocols for VMMouse, logging, and time. + */ + +#include "vmbackdoor.h" +#include "backdoor_def.h" +#include "vmmouse_defs.h" +#include "intr.h" + +#define BACKDOOR_VARS() \ + uint32 eax = 0, ebx = 0, ecx = 0, edx = 0, esi = 0, edi = 0; \ + +#define BACKDOOR_ASM(op, port) \ + { \ + eax = BDOOR_MAGIC; \ + edx = (edx & 0xFFFF0000) | port; \ + asm volatile (op : "+a" (eax), "+b" (ebx), \ + "+c" (ecx), "+d" (edx), "+S" (esi), "+D" (edi)); \ + } + +#define BACKDOOR_ASM_IN() BACKDOOR_ASM("in %%dx, %0", BDOOR_PORT) +#define BACKDOOR_ASM_HB_OUT() BACKDOOR_ASM("cld; rep; outsb", BDOORHB_PORT) +#define BACKDOOR_ASM_HB_IN() BACKDOOR_ASM("cld; rep; insb", BDOORHB_PORT) + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_MouseInit -- + * + * Initialize the backdoor VMMouse device. This is the virtualized + * mouse device that all modern versions of VMware Tools use. + * + * Results: + * None. + * + * Side effects: + * Puts the mouse in absolute or relative mode. + * + *----------------------------------------------------------------------------- + */ + +void +VMBackdoor_MouseInit(Bool absolute) // IN +{ + BACKDOOR_VARS() + + ebx = VMMOUSE_CMD_READ_ID; + ecx = BDOOR_CMD_ABSPOINTER_COMMAND; + BACKDOOR_ASM_IN() + + ebx = 0; + ecx = BDOOR_CMD_ABSPOINTER_STATUS; + BACKDOOR_ASM_IN() + + ebx = 1; + ecx = BDOOR_CMD_ABSPOINTER_DATA; + BACKDOOR_ASM_IN() + + ebx = absolute ? VMMOUSE_CMD_REQUEST_ABSOLUTE : VMMOUSE_CMD_REQUEST_RELATIVE; + ecx = BDOOR_CMD_ABSPOINTER_COMMAND; + BACKDOOR_ASM_IN() +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_MouseGetPacket -- + * + * Poll for VMMouse packets. + * + * Results: + * If a packet is available, returns TRUE and copies it to 'packet'. + * Returns FALSE if no packet is available. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +Bool +VMBackdoor_MouseGetPacket(VMMousePacket *packet) // OUT +{ + const uint32 wordsToRead = 4; + BACKDOOR_VARS() + + ebx = 0; + ecx = BDOOR_CMD_ABSPOINTER_STATUS; + BACKDOOR_ASM_IN() + + /* Low word of 'status' is the number of DWORDs in the device's FIFO */ + if ((eax & 0x0000ffff) < wordsToRead) { + return FALSE; + } + + ebx = wordsToRead; + ecx = BDOOR_CMD_ABSPOINTER_DATA; + BACKDOOR_ASM_IN() + + packet->x = (int32)ebx; + packet->y = (int32)ecx; + packet->z = (int32)edx; + packet->flags = eax >> 16; + packet->buttons = eax & 0xFFFF; + + return TRUE; +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_GetTime -- + * + * Read the host's real-time clock, with microsecond precision. + * + * Results: + * None. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +void +VMBackdoor_GetTime(VMTime *time) // OUT +{ + BACKDOOR_VARS() + + ebx = 0; + ecx = BDOOR_CMD_GETTIMEFULL; + BACKDOOR_ASM_IN() + + time->usecs = ebx; + time->maxTimeLag = ecx; + time->secsLow = edx; + time->secsHigh = esi; +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_TimeDiffUS -- + * + * Compute the differene, in microseconds, of two time values in VMTime format. + * + * Results: + * Number of microseconds. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +int32 +VMBackdoor_TimeDiffUS(VMTime *first, // IN + VMTime *second) // IN +{ + int32 secs = second->secsLow - first->secsLow; + int32 usec = second->usecs - first->usecs; + + return (secs * 1000000) + usec; +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_MsgOpen -- + * + * Open a backdoor message channel. + * + * Results: + * Initializes 'channel'. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +void +VMBackdoor_MsgOpen(VMMessageChannel *channel, // OUT + uint32 proto) // IN +{ + BACKDOOR_VARS() + + ecx = BDOOR_CMD_MESSAGE | 0x00000000; /* Open */ + ebx = proto; + BACKDOOR_ASM_IN() + + if ((ecx & 0x00010000) == 0) { + Intr_Break(); + } + + channel->proto = proto; + channel->id = edx >> 16; +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_MsgClose -- + * + * Close a backdoor message channel. + * + * Results: + * void. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +void +VMBackdoor_MsgClose(VMMessageChannel *channel) // OUT +{ + BACKDOOR_VARS() + + ecx = BDOOR_CMD_MESSAGE | 0x00060000; /* Close */ + ebx = 0; + edx = channel->id << 16; + BACKDOOR_ASM_IN() +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_MsgSend -- + * + * Send a message over a VMMessageChannel. + * + * Results: + * void. + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +void +VMBackdoor_MsgSend(VMMessageChannel *channel, // IN + const void *buf, // IN + uint32 size) // IN +{ + BACKDOOR_VARS() + + ecx = BDOOR_CMD_MESSAGE | 0x00010000; /* Send size */ + ebx = size; + edx = channel->id << 16; + BACKDOOR_ASM_IN() + + /* We only support the high-bandwidth backdoor port. */ + if (((ecx >> 16) & 0x0081) != 0x0081) { + Intr_Break(); + } + + ebx = 0x00010000 | BDOORHB_CMD_MESSAGE; + ecx = size; + edx = channel->id << 16; + esi = (uint32)buf; + BACKDOOR_ASM_HB_OUT() + + /* Success? */ + if (!(ebx & 0x00010000)) { + Intr_Break(); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_MsgReceive -- + * + * Receive a message waiting on a VMMessageChannel. + * + * Results: + * Returns the number of bytes received. + * + * Side effects: + * Intr_Break on protocol error or buffer overflow. + * + *----------------------------------------------------------------------------- + */ + +uint32 +VMBackdoor_MsgReceive(VMMessageChannel *channel, // IN + void *buf, // IN + uint32 bufSize) // IN +{ + uint32 size; + BACKDOOR_VARS() + + ecx = BDOOR_CMD_MESSAGE | 0x00030000; /* Receive size */ + edx = channel->id << 16; + BACKDOOR_ASM_IN() + + /* + * Check for success, and make sure a message is waiting. + * The host must have just sent us a SENDSIZE request. + * Also make sure the host supports high-bandwidth transfers. + */ + if (((ecx >> 16) & 0x0083) != 0x0083 || + (edx >> 16) != 0x0001) { + Intr_Break(); + } + + size = ebx; + if (size > bufSize) { + Intr_Break(); + } + + /* Receive payload */ + ebx = BDOORHB_CMD_MESSAGE | 0x00010000; + ecx = size; + edx = channel->id << 16; + edi = (uint32)buf; + BACKDOOR_ASM_HB_IN() + + /* Success? */ + if (!(ebx & 0x00010000)) { + Intr_Break(); + } + + /* Acknowledge status */ + ecx = BDOOR_CMD_MESSAGE | 0x00050000; + ebx = 0x0001; + edx = channel->id << 16; + BACKDOOR_ASM_IN() + + return size; +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_GetRPCIChannel -- + * + * Return the channel to use for RPCI messages. + * + * Results: + * Always returns a VMMessageChannel. + * + * Side effects: + * Opens the channel if necessary. + * + *----------------------------------------------------------------------------- + */ + +VMMessageChannel * +VMBackdoor_GetRPCIChannel(void) +{ + static VMMessageChannel channel; + static Bool initialized; + + if (!initialized) { + VMBackdoor_MsgOpen(&channel, 0x49435052); /* 'RPCI' */ + initialized = TRUE; + } + + return &channel; +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_RPCI -- + * + * Synchronously deliver an RPCI message and collect its response. + * + * Results: + * Returns the number of response bytes. + * + * Side effects: + * Opens the channel if necessary. + * + *----------------------------------------------------------------------------- + */ + +uint32 +VMBackdoor_RPCI(const void *request, // IN + uint32 reqSize, // IN + void *replyBuffer, // OUT + uint32 replyBufferLen) // IN +{ + VMMessageChannel *channel = VMBackdoor_GetRPCIChannel(); + VMBackdoor_MsgSend(channel, request, reqSize); + return VMBackdoor_MsgReceive(channel, replyBuffer, replyBufferLen); +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_RPCIOut -- + * + * Synchronously deliver an RPCI message, and expect a status + * response ("1" on success). + * + * Results: + * None. + * + * Side effects: + * Opens the channel if necessary. + * Intr_Break on error. + * + *----------------------------------------------------------------------------- + */ + +void +VMBackdoor_RPCIOut(const void *request, // IN + uint32 reqSize) // IN +{ + uint8 replyBuf[16]; + uint32 replyLen = VMBackdoor_RPCI(request, reqSize, replyBuf, sizeof replyBuf); + if (replyLen < 1 || replyBuf[0] != '1') { + Intr_Break(); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * VMBackdoor_VGAScreenshot -- + * + * Log a screenshot of the VGA framebuffer over the backdoor. + * + * Results: + * None. + * + * Side effects: + * Opens the channel if necessary. + * Intr_Break on error. + * + *----------------------------------------------------------------------------- + */ + +void +VMBackdoor_VGAScreenshot(void) +{ + int x, y; + const uint8 *fb = (void*)0xB8000; + static const char prefix[] = "log VGA: [00] "; + char lineBuf[81 + sizeof prefix]; + char *linePtr; + uint32 lineLen; + + memcpy(lineBuf, prefix, sizeof prefix); + + for (y = 0; y < 25; y++) { + linePtr = lineBuf + sizeof prefix - 1; + lineLen = 0; + + lineBuf[10] = '0' + y / 10; + lineBuf[11] = '0' + y % 10; + + for (x = 0; x < 80; x++) { + *linePtr = *fb; + linePtr++; + if (*fb != ' ') { + lineLen = linePtr - lineBuf; + } + fb += 2; + } + + if (lineLen > 0) { + VMBackdoor_RPCIOut(lineBuf, lineLen); + } + } +} diff --git a/lib/util/vmbackdoor.h b/lib/util/vmbackdoor.h new file mode 100644 index 0000000..838b066 --- /dev/null +++ b/lib/util/vmbackdoor.h @@ -0,0 +1,84 @@ +/********************************************************** + * Copyright 2008-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * vmbackdoor.h -- + * + * This is a tiny and self-contained client implementation of + * VMware's backdoor protocols for VMMouse, logging, time, and + * HGFS. + */ + +#ifndef __VMBACKDOOR_H__ +#define __VMBACKDOOR_H__ + +#include "types.h" +#include "vmmouse_defs.h" + +typedef struct { + uint32 flags; + uint32 buttons; + int x, y, z; +} VMMousePacket; + +typedef struct { + union { + uint64 secs; + struct { + uint32 secsLow; + uint32 secsHigh; + }; + }; + uint32 usecs; + uint32 maxTimeLag; +} VMTime; + +typedef struct { + uint32 proto; + uint16 id; +} VMMessageChannel; + + +void VMBackdoor_MouseInit(Bool absolute); +Bool VMBackdoor_MouseGetPacket(VMMousePacket *packet); + +void VMBackdoor_GetTime(VMTime *time); +int32 VMBackdoor_TimeDiffUS(VMTime *first, VMTime *second); + +void VMBackdoor_MsgOpen(VMMessageChannel *channel, uint32 proto); +void VMBackdoor_MsgClose(VMMessageChannel *channel); +void VMBackdoor_MsgSend(VMMessageChannel *channel, const void *buf, uint32 size); +uint32 VMBackdoor_MsgReceive(VMMessageChannel *channel, void *buf, uint32 bufSize); + +VMMessageChannel *VMBackdoor_GetRPCIChannel(void); +uint32 VMBackdoor_RPCI(const void *request, uint32 reqSize, + void *replyBuffer, uint32 replyBufferLen); +void VMBackdoor_RPCIOut(const void *request, uint32 reqSize); + +void VMBackdoor_VGAScreenshot(void); + +#define VMBackdoor_Log(s) VMBackdoor_RPCIOut(("log " s), 4 + sizeof(s)) + +#endif /* __VMBACKDOOR_H__ */ diff --git a/lib/vmware/backdoor_def.h b/lib/vmware/backdoor_def.h new file mode 100644 index 0000000..8ac6160 --- /dev/null +++ b/lib/vmware/backdoor_def.h @@ -0,0 +1,126 @@ +/********************************************************** + * Copyright 1998-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * backdoor_def.h -- + * + * This contains constants that define the backdoor I/O port, a + * simple hypercall mechanism that is used by VMware Tools. + */ + + +#ifndef _BACKDOOR_DEF_H_ +#define _BACKDOOR_DEF_H_ + +#define BDOOR_MAGIC 0x564D5868 + +#define BDOOR_PORT 0x5658 + +#define BDOOR_CMD_GETMHZ 1 +#define BDOOR_CMD_APMFUNCTION 2 +#define BDOOR_CMD_GETDISKGEO 3 +#define BDOOR_CMD_GETPTRLOCATION 4 +#define BDOOR_CMD_SETPTRLOCATION 5 +#define BDOOR_CMD_GETSELLENGTH 6 +#define BDOOR_CMD_GETNEXTPIECE 7 +#define BDOOR_CMD_SETSELLENGTH 8 +#define BDOOR_CMD_SETNEXTPIECE 9 +#define BDOOR_CMD_GETVERSION 10 +#define BDOOR_CMD_GETDEVICELISTELEMENT 11 +#define BDOOR_CMD_TOGGLEDEVICE 12 +#define BDOOR_CMD_GETGUIOPTIONS 13 +#define BDOOR_CMD_SETGUIOPTIONS 14 +#define BDOOR_CMD_GETSCREENSIZE 15 +#define BDOOR_CMD_MONITOR_CONTROL 16 +#define BDOOR_CMD_GETHWVERSION 17 +#define BDOOR_CMD_OSNOTFOUND 18 +#define BDOOR_CMD_GETUUID 19 +#define BDOOR_CMD_GETMEMSIZE 20 +#define BDOOR_CMD_HOSTCOPY 21 /* Devel only */ +#define BDOOR_CMD_SERVICE_VM 22 /* prototype only */ +#define BDOOR_CMD_GETTIME 23 /* Deprecated. Use GETTIMEFULL. */ +#define BDOOR_CMD_STOPCATCHUP 24 +#define BDOOR_CMD_PUTCHR 25 /* Devel only */ +#define BDOOR_CMD_ENABLE_MSG 26 /* Devel only */ +#define BDOOR_CMD_GOTO_TCL 27 /* Devel only */ +#define BDOOR_CMD_INITPCIOPROM 28 +#define BDOOR_CMD_INT13 29 +#define BDOOR_CMD_MESSAGE 30 +#define BDOOR_CMD_RSVD0 31 +#define BDOOR_CMD_RSVD1 32 +#define BDOOR_CMD_RSVD2 33 +#define BDOOR_CMD_ISACPIDISABLED 34 +#define BDOOR_CMD_TOE 35 /* Not in use */ +#define BDOOR_CMD_ISMOUSEABSOLUTE 36 +#define BDOOR_CMD_PATCH_SMBIOS_STRUCTS 37 +#define BDOOR_CMD_MAPMEM 38 /* Devel only */ +#define BDOOR_CMD_ABSPOINTER_DATA 39 +#define BDOOR_CMD_ABSPOINTER_STATUS 40 +#define BDOOR_CMD_ABSPOINTER_COMMAND 41 +#define BDOOR_CMD_TIMER_SPONGE 42 +#define BDOOR_CMD_PATCH_ACPI_TABLES 43 +#define BDOOR_CMD_DEVEL_FAKEHARDWARE 44 /* Debug only - needed in beta */ +#define BDOOR_CMD_GETHZ 45 +#define BDOOR_CMD_GETTIMEFULL 46 +#define BDOOR_CMD_STATELOGGER 47 +#define BDOOR_CMD_CHECKFORCEBIOSSETUP 48 +#define BDOOR_CMD_LAZYTIMEREMULATION 49 +#define BDOOR_CMD_BIOSBBS 50 +#define BDOOR_CMD_VASSERT 51 +#define BDOOR_CMD_ISGOSDARWIN 52 +#define BDOOR_CMD_DEBUGEVENT 53 +#define BDOOR_CMD_OSNOTMACOSXSERVER 54 +#define BDOOR_CMD_GETTIMEFULL_WITH_LAG 55 +#define BDOOR_CMD_ACPI_HOTPLUG_DEVICE 56 +#define BDOOR_CMD_ACPI_HOTPLUG_MEMORY 57 +#define BDOOR_CMD_ACPI_HOTPLUG_CBRET 58 +#define BDOOR_CMD_GET_HOST_VIDEO_MODES 59 +#define BDOOR_CMD_ACPI_HOTPLUG_CPU 60 +#define BDOOR_CMD_MAX 61 + +/* + * High-bandwidth backdoor port. + */ + +#define BDOORHB_PORT 0x5659 + +#define BDOORHB_CMD_MESSAGE 0 +#define BDOORHB_CMD_VASSERT 1 +#define BDOORHB_CMD_MAX 2 + +/* + * There is another backdoor which allows access to certain TSC-related + * values using otherwise illegal PMC indices when the pseudo_perfctr + * control flag is set. + */ + +#define BDOOR_PMC_HW_TSC 0x10000 +#define BDOOR_PMC_REAL_NS 0x10001 +#define BDOOR_PMC_APPARENT_NS 0x10002 + +#define IS_BDOOR_PMC(index) (((index) | 3) == 0x10003) +#define BDOOR_CMD(ecx) ((ecx) & 0xffff) + +#endif /* _BACKDOOR_DEF_H_ */ diff --git a/lib/vmware/svga3d_reg.h b/lib/vmware/svga3d_reg.h new file mode 100644 index 0000000..4d05c56 --- /dev/null +++ b/lib/vmware/svga3d_reg.h @@ -0,0 +1,1721 @@ +/********************************************************** + * Copyright 1998-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga3d_reg.h -- + * + * SVGA 3D hardware definitions + */ + +#ifndef _SVGA3D_REG_H_ +#define _SVGA3D_REG_H_ + +#include "svga_reg.h" + + +/* + * 3D Hardware Version + * + * The hardware version is stored in the SVGA_FIFO_3D_HWVERSION fifo + * register. Is set by the host and read by the guest. This lets + * us make new guest drivers which are backwards-compatible with old + * SVGA hardware revisions. It does not let us support old guest + * drivers. Good enough for now. + * + */ + +#define SVGA3D_MAKE_HWVERSION(major, minor) (((major) << 16) | ((minor) & 0xFF)) +#define SVGA3D_MAJOR_HWVERSION(version) ((version) >> 16) +#define SVGA3D_MINOR_HWVERSION(version) ((version) & 0xFF) + +typedef enum { + SVGA3D_HWVERSION_WS5_RC1 = SVGA3D_MAKE_HWVERSION(0, 1), + SVGA3D_HWVERSION_WS5_RC2 = SVGA3D_MAKE_HWVERSION(0, 2), + SVGA3D_HWVERSION_WS51_RC1 = SVGA3D_MAKE_HWVERSION(0, 3), + SVGA3D_HWVERSION_WS6_B1 = SVGA3D_MAKE_HWVERSION(1, 1), + SVGA3D_HWVERSION_FUSION_11 = SVGA3D_MAKE_HWVERSION(1, 4), + SVGA3D_HWVERSION_WS65_B1 = SVGA3D_MAKE_HWVERSION(2, 0), + SVGA3D_HWVERSION_CURRENT = SVGA3D_HWVERSION_WS65_B1, +} SVGA3dHardwareVersion; + +/* + * Generic Types + */ + +typedef uint32 SVGA3dBool; /* 32-bit Bool definition */ +#define SVGA3D_NUM_CLIPPLANES 6 +#define SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS 8 + + +/* + * Surface formats. + * + * If you modify this list, be sure to keep GLUtil.c in sync. It + * includes the internal format definition of each surface in + * GLUtil_ConvertSurfaceFormat, and it contains a table of + * human-readable names in GLUtil_GetFormatName. + */ + +typedef enum { + SVGA3D_FORMAT_INVALID = 0, + + SVGA3D_X8R8G8B8 = 1, + SVGA3D_A8R8G8B8 = 2, + + SVGA3D_R5G6B5 = 3, + SVGA3D_X1R5G5B5 = 4, + SVGA3D_A1R5G5B5 = 5, + SVGA3D_A4R4G4B4 = 6, + + SVGA3D_Z_D32 = 7, + SVGA3D_Z_D16 = 8, + SVGA3D_Z_D24S8 = 9, + SVGA3D_Z_D15S1 = 10, + + SVGA3D_LUMINANCE8 = 11, + SVGA3D_LUMINANCE4_ALPHA4 = 12, + SVGA3D_LUMINANCE16 = 13, + SVGA3D_LUMINANCE8_ALPHA8 = 14, + + SVGA3D_DXT1 = 15, + SVGA3D_DXT2 = 16, + SVGA3D_DXT3 = 17, + SVGA3D_DXT4 = 18, + SVGA3D_DXT5 = 19, + + SVGA3D_BUMPU8V8 = 20, + SVGA3D_BUMPL6V5U5 = 21, + SVGA3D_BUMPX8L8V8U8 = 22, + SVGA3D_BUMPL8V8U8 = 23, + + SVGA3D_ARGB_S10E5 = 24, /* 16-bit floating-point ARGB */ + SVGA3D_ARGB_S23E8 = 25, /* 32-bit floating-point ARGB */ + + SVGA3D_A2R10G10B10 = 26, + + /* signed formats */ + SVGA3D_V8U8 = 27, + SVGA3D_Q8W8V8U8 = 28, + SVGA3D_CxV8U8 = 29, + + /* mixed formats */ + SVGA3D_X8L8V8U8 = 30, + SVGA3D_A2W10V10U10 = 31, + + SVGA3D_ALPHA8 = 32, + + /* Single- and dual-component floating point formats */ + SVGA3D_R_S10E5 = 33, + SVGA3D_R_S23E8 = 34, + SVGA3D_RG_S10E5 = 35, + SVGA3D_RG_S23E8 = 36, + + /* + * Any surface can be used as a buffer object, but SVGA3D_BUFFER is + * the most efficient format to use when creating new surfaces + * expressly for index or vertex data. + */ + SVGA3D_BUFFER = 37, + + SVGA3D_Z_D24X8 = 38, + + SVGA3D_FORMAT_MAX +} SVGA3dSurfaceFormat; + +typedef uint32 SVGA3dColor; /* a, r, g, b */ + +/* + * These match the D3DFORMAT_OP definitions used by Direct3D. We need + * them so that we can query the host for what the supported surface + * operations are (when we're using the D3D backend, in particular), + * and so we can send those operations to the guest. + */ +typedef enum { + SVGA3DFORMAT_OP_TEXTURE = 0x00000001, + SVGA3DFORMAT_OP_VOLUMETEXTURE = 0x00000002, + SVGA3DFORMAT_OP_CUBETEXTURE = 0x00000004, + SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET = 0x00000008, + SVGA3DFORMAT_OP_SAME_FORMAT_RENDERTARGET = 0x00000010, + SVGA3DFORMAT_OP_ZSTENCIL = 0x00000040, + SVGA3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH = 0x00000080, + +/* + * This format can be used as a render target if the current display mode + * is the same depth if the alpha channel is ignored. e.g. if the device + * can render to A8R8G8B8 when the display mode is X8R8G8B8, then the + * format op list entry for A8R8G8B8 should have this cap. + */ + SVGA3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET = 0x00000100, + +/* + * This format contains DirectDraw support (including Flip). This flag + * should not to be set on alpha formats. + */ + SVGA3DFORMAT_OP_DISPLAYMODE = 0x00000400, + +/* + * The rasterizer can support some level of Direct3D support in this format + * and implies that the driver can create a Context in this mode (for some + * render target format). When this flag is set, the SVGA3DFORMAT_OP_DISPLAYMODE + * flag must also be set. + */ + SVGA3DFORMAT_OP_3DACCELERATION = 0x00000800, + +/* + * This is set for a private format when the driver has put the bpp in + * the structure. + */ + SVGA3DFORMAT_OP_PIXELSIZE = 0x00001000, + +/* + * Indicates that this format can be converted to any RGB format for which + * SVGA3DFORMAT_OP_MEMBEROFGROUP_ARGB is specified + */ + SVGA3DFORMAT_OP_CONVERT_TO_ARGB = 0x00002000, + +/* + * Indicates that this format can be used to create offscreen plain surfaces. + */ + SVGA3DFORMAT_OP_OFFSCREENPLAIN = 0x00004000, + +/* + * Indicated that this format can be read as an SRGB texture (meaning that the + * sampler will linearize the looked up data) + */ + SVGA3DFORMAT_OP_SRGBREAD = 0x00008000, + +/* + * Indicates that this format can be used in the bumpmap instructions + */ + SVGA3DFORMAT_OP_BUMPMAP = 0x00010000, + +/* + * Indicates that this format can be sampled by the displacement map sampler + */ + SVGA3DFORMAT_OP_DMAP = 0x00020000, + +/* + * Indicates that this format cannot be used with texture filtering + */ + SVGA3DFORMAT_OP_NOFILTER = 0x00040000, + +/* + * Indicates that format conversions are supported to this RGB format if + * SVGA3DFORMAT_OP_CONVERT_TO_ARGB is specified in the source format. + */ + SVGA3DFORMAT_OP_MEMBEROFGROUP_ARGB = 0x00080000, + +/* + * Indicated that this format can be written as an SRGB target (meaning that the + * pixel pipe will DE-linearize data on output to format) + */ + SVGA3DFORMAT_OP_SRGBWRITE = 0x00100000, + +/* + * Indicates that this format cannot be used with alpha blending + */ + SVGA3DFORMAT_OP_NOALPHABLEND = 0x00200000, + +/* + * Indicates that the device can auto-generated sublevels for resources + * of this format + */ + SVGA3DFORMAT_OP_AUTOGENMIPMAP = 0x00400000, + +/* + * Indicates that this format can be used by vertex texture sampler + */ + SVGA3DFORMAT_OP_VERTEXTEXTURE = 0x00800000, + +/* + * Indicates that this format supports neither texture coordinate wrap + * modes, nor mipmapping + */ + SVGA3DFORMAT_OP_NOTEXCOORDWRAPNORMIP = 0x01000000 +} SVGA3dFormatOp; + +/* + * This structure is a conversion of SVGA3DFORMAT_OP_*. + * Entries must be located at the same position. + */ +typedef union { + uint32 value; + struct { + uint32 texture : 1; + uint32 volumeTexture : 1; + uint32 cubeTexture : 1; + uint32 offscreenRenderTarget : 1; + uint32 sameFormatRenderTarget : 1; + uint32 unknown1 : 1; + uint32 zStencil : 1; + uint32 zStencilArbitraryDepth : 1; + uint32 sameFormatUpToAlpha : 1; + uint32 unknown2 : 1; + uint32 displayMode : 1; + uint32 acceleration3d : 1; + uint32 pixelSize : 1; + uint32 convertToARGB : 1; + uint32 offscreenPlain : 1; + uint32 sRGBRead : 1; + uint32 bumpMap : 1; + uint32 dmap : 1; + uint32 noFilter : 1; + uint32 memberOfGroupARGB : 1; + uint32 sRGBWrite : 1; + uint32 noAlphaBlend : 1; + uint32 autoGenMipMap : 1; + uint32 vertexTexture : 1; + uint32 noTexCoordWrapNorMip : 1; + }; +} SVGA3dSurfaceFormatCaps; + +/* + * SVGA_3D_CMD_SETRENDERSTATE Types. All value types + * must fit in a uint32. + */ + +typedef enum { + SVGA3D_RS_INVALID = 0, + SVGA3D_RS_ZENABLE = 1, /* SVGA3dBool */ + SVGA3D_RS_ZWRITEENABLE = 2, /* SVGA3dBool */ + SVGA3D_RS_ALPHATESTENABLE = 3, /* SVGA3dBool */ + SVGA3D_RS_DITHERENABLE = 4, /* SVGA3dBool */ + SVGA3D_RS_BLENDENABLE = 5, /* SVGA3dBool */ + SVGA3D_RS_FOGENABLE = 6, /* SVGA3dBool */ + SVGA3D_RS_SPECULARENABLE = 7, /* SVGA3dBool */ + SVGA3D_RS_STENCILENABLE = 8, /* SVGA3dBool */ + SVGA3D_RS_LIGHTINGENABLE = 9, /* SVGA3dBool */ + SVGA3D_RS_NORMALIZENORMALS = 10, /* SVGA3dBool */ + SVGA3D_RS_POINTSPRITEENABLE = 11, /* SVGA3dBool */ + SVGA3D_RS_POINTSCALEENABLE = 12, /* SVGA3dBool */ + SVGA3D_RS_STENCILREF = 13, /* uint32 */ + SVGA3D_RS_STENCILMASK = 14, /* uint32 */ + SVGA3D_RS_STENCILWRITEMASK = 15, /* uint32 */ + SVGA3D_RS_FOGSTART = 16, /* float */ + SVGA3D_RS_FOGEND = 17, /* float */ + SVGA3D_RS_FOGDENSITY = 18, /* float */ + SVGA3D_RS_POINTSIZE = 19, /* float */ + SVGA3D_RS_POINTSIZEMIN = 20, /* float */ + SVGA3D_RS_POINTSIZEMAX = 21, /* float */ + SVGA3D_RS_POINTSCALE_A = 22, /* float */ + SVGA3D_RS_POINTSCALE_B = 23, /* float */ + SVGA3D_RS_POINTSCALE_C = 24, /* float */ + SVGA3D_RS_FOGCOLOR = 25, /* SVGA3dColor */ + SVGA3D_RS_AMBIENT = 26, /* SVGA3dColor */ + SVGA3D_RS_CLIPPLANEENABLE = 27, /* SVGA3dClipPlanes */ + SVGA3D_RS_FOGMODE = 28, /* SVGA3dFogMode */ + SVGA3D_RS_FILLMODE = 29, /* SVGA3dFillMode */ + SVGA3D_RS_SHADEMODE = 30, /* SVGA3dShadeMode */ + SVGA3D_RS_LINEPATTERN = 31, /* SVGA3dLinePattern */ + SVGA3D_RS_SRCBLEND = 32, /* SVGA3dBlendOp */ + SVGA3D_RS_DSTBLEND = 33, /* SVGA3dBlendOp */ + SVGA3D_RS_BLENDEQUATION = 34, /* SVGA3dBlendEquation */ + SVGA3D_RS_CULLMODE = 35, /* SVGA3dFace */ + SVGA3D_RS_ZFUNC = 36, /* SVGA3dCmpFunc */ + SVGA3D_RS_ALPHAFUNC = 37, /* SVGA3dCmpFunc */ + SVGA3D_RS_STENCILFUNC = 38, /* SVGA3dCmpFunc */ + SVGA3D_RS_STENCILFAIL = 39, /* SVGA3dStencilOp */ + SVGA3D_RS_STENCILZFAIL = 40, /* SVGA3dStencilOp */ + SVGA3D_RS_STENCILPASS = 41, /* SVGA3dStencilOp */ + SVGA3D_RS_ALPHAREF = 42, /* float (0.0 .. 1.0) */ + SVGA3D_RS_FRONTWINDING = 43, /* SVGA3dFrontWinding */ + SVGA3D_RS_COORDINATETYPE = 44, /* SVGA3dCoordinateType */ + SVGA3D_RS_ZBIAS = 45, /* float */ + SVGA3D_RS_RANGEFOGENABLE = 46, /* SVGA3dBool */ + SVGA3D_RS_COLORWRITEENABLE = 47, /* SVGA3dColorMask */ + SVGA3D_RS_VERTEXMATERIALENABLE = 48, /* SVGA3dBool */ + SVGA3D_RS_DIFFUSEMATERIALSOURCE = 49, /* SVGA3dVertexMaterial */ + SVGA3D_RS_SPECULARMATERIALSOURCE = 50, /* SVGA3dVertexMaterial */ + SVGA3D_RS_AMBIENTMATERIALSOURCE = 51, /* SVGA3dVertexMaterial */ + SVGA3D_RS_EMISSIVEMATERIALSOURCE = 52, /* SVGA3dVertexMaterial */ + SVGA3D_RS_TEXTUREFACTOR = 53, /* SVGA3dColor */ + SVGA3D_RS_LOCALVIEWER = 54, /* SVGA3dBool */ + SVGA3D_RS_SCISSORTESTENABLE = 55, /* SVGA3dBool */ + SVGA3D_RS_BLENDCOLOR = 56, /* SVGA3dColor */ + SVGA3D_RS_STENCILENABLE2SIDED = 57, /* SVGA3dBool */ + SVGA3D_RS_CCWSTENCILFUNC = 58, /* SVGA3dCmpFunc */ + SVGA3D_RS_CCWSTENCILFAIL = 59, /* SVGA3dStencilOp */ + SVGA3D_RS_CCWSTENCILZFAIL = 60, /* SVGA3dStencilOp */ + SVGA3D_RS_CCWSTENCILPASS = 61, /* SVGA3dStencilOp */ + SVGA3D_RS_VERTEXBLEND = 62, /* SVGA3dVertexBlendFlags */ + SVGA3D_RS_SLOPESCALEDEPTHBIAS = 63, /* float */ + SVGA3D_RS_DEPTHBIAS = 64, /* float */ + + + /* + * Output Gamma Level + * + * Output gamma effects the gamma curve of colors that are output from the + * rendering pipeline. A value of 1.0 specifies a linear color space. If the + * value is <= 0.0, gamma correction is ignored and linear color space is + * used. + */ + + SVGA3D_RS_OUTPUTGAMMA = 65, /* float */ + SVGA3D_RS_ZVISIBLE = 66, /* SVGA3dBool */ + SVGA3D_RS_LASTPIXEL = 67, /* SVGA3dBool */ + SVGA3D_RS_CLIPPING = 68, /* SVGA3dBool */ + SVGA3D_RS_WRAP0 = 69, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP1 = 70, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP2 = 71, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP3 = 72, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP4 = 73, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP5 = 74, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP6 = 75, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP7 = 76, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP8 = 77, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP9 = 78, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP10 = 79, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP11 = 80, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP12 = 81, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP13 = 82, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP14 = 83, /* SVGA3dWrapFlags */ + SVGA3D_RS_WRAP15 = 84, /* SVGA3dWrapFlags */ + SVGA3D_RS_MULTISAMPLEANTIALIAS = 85, /* SVGA3dBool */ + SVGA3D_RS_MULTISAMPLEMASK = 86, /* uint32 */ + SVGA3D_RS_INDEXEDVERTEXBLENDENABLE = 87, /* SVGA3dBool */ + SVGA3D_RS_TWEENFACTOR = 88, /* float */ + SVGA3D_RS_ANTIALIASEDLINEENABLE = 89, /* SVGA3dBool */ + SVGA3D_RS_COLORWRITEENABLE1 = 90, /* SVGA3dColorMask */ + SVGA3D_RS_COLORWRITEENABLE2 = 91, /* SVGA3dColorMask */ + SVGA3D_RS_COLORWRITEENABLE3 = 92, /* SVGA3dColorMask */ + SVGA3D_RS_SEPARATEALPHABLENDENABLE = 93, /* SVGA3dBool */ + SVGA3D_RS_SRCBLENDALPHA = 94, /* SVGA3dBlendOp */ + SVGA3D_RS_DSTBLENDALPHA = 95, /* SVGA3dBlendOp */ + SVGA3D_RS_BLENDEQUATIONALPHA = 96, /* SVGA3dBlendEquation */ + SVGA3D_RS_MAX +} SVGA3dRenderStateName; + +typedef enum { + SVGA3D_VERTEXMATERIAL_NONE = 0, /* Use the value in the current material */ + SVGA3D_VERTEXMATERIAL_DIFFUSE = 1, /* Use the value in the diffuse component */ + SVGA3D_VERTEXMATERIAL_SPECULAR = 2, /* Use the value in the specular component */ +} SVGA3dVertexMaterial; + +typedef enum { + SVGA3D_FILLMODE_INVALID = 0, + SVGA3D_FILLMODE_POINT = 1, + SVGA3D_FILLMODE_LINE = 2, + SVGA3D_FILLMODE_FILL = 3, + SVGA3D_FILLMODE_MAX +} SVGA3dFillModeType; + + +typedef +union { + struct { + uint16 mode; /* SVGA3dFillModeType */ + uint16 face; /* SVGA3dFace */ + }; + uint32 uintValue; +} PACKED +SVGA3dFillMode; + +typedef enum { + SVGA3D_SHADEMODE_INVALID = 0, + SVGA3D_SHADEMODE_FLAT = 1, + SVGA3D_SHADEMODE_SMOOTH = 2, + SVGA3D_SHADEMODE_PHONG = 3, /* Not supported */ + SVGA3D_SHADEMODE_MAX +} SVGA3dShadeMode; + +typedef +union { + struct { + uint16 repeat; + uint16 pattern; + }; + uint32 uintValue; +} PACKED +SVGA3dLinePattern; + +typedef enum { + SVGA3D_BLENDOP_INVALID = 0, + SVGA3D_BLENDOP_ZERO = 1, + SVGA3D_BLENDOP_ONE = 2, + SVGA3D_BLENDOP_SRCCOLOR = 3, + SVGA3D_BLENDOP_INVSRCCOLOR = 4, + SVGA3D_BLENDOP_SRCALPHA = 5, + SVGA3D_BLENDOP_INVSRCALPHA = 6, + SVGA3D_BLENDOP_DESTALPHA = 7, + SVGA3D_BLENDOP_INVDESTALPHA = 8, + SVGA3D_BLENDOP_DESTCOLOR = 9, + SVGA3D_BLENDOP_INVDESTCOLOR = 10, + SVGA3D_BLENDOP_SRCALPHASAT = 11, + SVGA3D_BLENDOP_BLENDFACTOR = 12, + SVGA3D_BLENDOP_INVBLENDFACTOR = 13, + SVGA3D_BLENDOP_MAX +} SVGA3dBlendOp; + +typedef enum { + SVGA3D_BLENDEQ_INVALID = 0, + SVGA3D_BLENDEQ_ADD = 1, + SVGA3D_BLENDEQ_SUBTRACT = 2, + SVGA3D_BLENDEQ_REVSUBTRACT = 3, + SVGA3D_BLENDEQ_MINIMUM = 4, + SVGA3D_BLENDEQ_MAXIMUM = 5, + SVGA3D_BLENDEQ_MAX +} SVGA3dBlendEquation; + +typedef enum { + SVGA3D_FRONTWINDING_INVALID = 0, + SVGA3D_FRONTWINDING_CW = 1, + SVGA3D_FRONTWINDING_CCW = 2, + SVGA3D_FRONTWINDING_MAX +} SVGA3dFrontWinding; + +typedef enum { + SVGA3D_FACE_INVALID = 0, + SVGA3D_FACE_NONE = 1, + SVGA3D_FACE_FRONT = 2, + SVGA3D_FACE_BACK = 3, + SVGA3D_FACE_FRONT_BACK = 4, + SVGA3D_FACE_MAX +} SVGA3dFace; + +/* + * The order and the values should not be changed + */ + +typedef enum { + SVGA3D_CMP_INVALID = 0, + SVGA3D_CMP_NEVER = 1, + SVGA3D_CMP_LESS = 2, + SVGA3D_CMP_EQUAL = 3, + SVGA3D_CMP_LESSEQUAL = 4, + SVGA3D_CMP_GREATER = 5, + SVGA3D_CMP_NOTEQUAL = 6, + SVGA3D_CMP_GREATEREQUAL = 7, + SVGA3D_CMP_ALWAYS = 8, + SVGA3D_CMP_MAX +} SVGA3dCmpFunc; + +/* + * SVGA3D_FOGFUNC_* specifies the fog equation, or PER_VERTEX which allows + * the fog factor to be specified in the alpha component of the specular + * (a.k.a. secondary) vertex color. + */ +typedef enum { + SVGA3D_FOGFUNC_INVALID = 0, + SVGA3D_FOGFUNC_EXP = 1, + SVGA3D_FOGFUNC_EXP2 = 2, + SVGA3D_FOGFUNC_LINEAR = 3, + SVGA3D_FOGFUNC_PER_VERTEX = 4 +} SVGA3dFogFunction; + +/* + * SVGA3D_FOGTYPE_* specifies if fog factors are computed on a per-vertex + * or per-pixel basis. + */ +typedef enum { + SVGA3D_FOGTYPE_INVALID = 0, + SVGA3D_FOGTYPE_VERTEX = 1, + SVGA3D_FOGTYPE_PIXEL = 2, + SVGA3D_FOGTYPE_MAX = 3 +} SVGA3dFogType; + +/* + * SVGA3D_FOGBASE_* selects depth or range-based fog. Depth-based fog is + * computed using the eye Z value of each pixel (or vertex), whereas range- + * based fog is computed using the actual distance (range) to the eye. + */ +typedef enum { + SVGA3D_FOGBASE_INVALID = 0, + SVGA3D_FOGBASE_DEPTHBASED = 1, + SVGA3D_FOGBASE_RANGEBASED = 2, + SVGA3D_FOGBASE_MAX = 3 +} SVGA3dFogBase; + +typedef enum { + SVGA3D_STENCILOP_INVALID = 0, + SVGA3D_STENCILOP_KEEP = 1, + SVGA3D_STENCILOP_ZERO = 2, + SVGA3D_STENCILOP_REPLACE = 3, + SVGA3D_STENCILOP_INCRSAT = 4, + SVGA3D_STENCILOP_DECRSAT = 5, + SVGA3D_STENCILOP_INVERT = 6, + SVGA3D_STENCILOP_INCR = 7, + SVGA3D_STENCILOP_DECR = 8, + SVGA3D_STENCILOP_MAX +} SVGA3dStencilOp; + +typedef enum { + SVGA3D_CLIPPLANE_0 = (1 << 0), + SVGA3D_CLIPPLANE_1 = (1 << 1), + SVGA3D_CLIPPLANE_2 = (1 << 2), + SVGA3D_CLIPPLANE_3 = (1 << 3), + SVGA3D_CLIPPLANE_4 = (1 << 4), + SVGA3D_CLIPPLANE_5 = (1 << 5), +} SVGA3dClipPlanes; + +typedef enum { + SVGA3D_CLEAR_COLOR = 0x1, + SVGA3D_CLEAR_DEPTH = 0x2, + SVGA3D_CLEAR_STENCIL = 0x4 +} SVGA3dClearFlag; + +typedef enum { + SVGA3D_RT_DEPTH = 0, + SVGA3D_RT_STENCIL = 1, + SVGA3D_RT_COLOR0 = 2, + SVGA3D_RT_COLOR1 = 3, + SVGA3D_RT_COLOR2 = 4, + SVGA3D_RT_COLOR3 = 5, + SVGA3D_RT_COLOR4 = 6, + SVGA3D_RT_COLOR5 = 7, + SVGA3D_RT_COLOR6 = 8, + SVGA3D_RT_COLOR7 = 9, + SVGA3D_RT_MAX, + SVGA3D_RT_INVALID = ((uint32)-1), +} SVGA3dRenderTargetType; + +typedef +union { + struct { + uint32 red : 1; + uint32 green : 1; + uint32 blue : 1; + uint32 alpha : 1; + }; + uint32 uintValue; +} PACKED +SVGA3dColorMask; + +typedef enum { + SVGA3D_VBLEND_DISABLE = 0, + SVGA3D_VBLEND_1WEIGHT = 1, + SVGA3D_VBLEND_2WEIGHT = 2, + SVGA3D_VBLEND_3WEIGHT = 3, +} SVGA3dVertexBlendFlags; + +typedef enum { + SVGA3D_WRAPCOORD_0 = 1 << 0, + SVGA3D_WRAPCOORD_1 = 1 << 1, + SVGA3D_WRAPCOORD_2 = 1 << 2, + SVGA3D_WRAPCOORD_3 = 1 << 3, + SVGA3D_WRAPCOORD_ALL = 0xF, +} SVGA3dWrapFlags; + +/* + * SVGA_3D_CMD_TEXTURESTATE Types. All value types + * must fit in a uint32. + */ + +typedef enum { + SVGA3D_TS_INVALID = 0, + SVGA3D_TS_BIND_TEXTURE = 1, /* SVGA3dSurfaceId */ + SVGA3D_TS_COLOROP = 2, /* SVGA3dTextureCombiner */ + SVGA3D_TS_COLORARG1 = 3, /* SVGA3dTextureArgData */ + SVGA3D_TS_COLORARG2 = 4, /* SVGA3dTextureArgData */ + SVGA3D_TS_ALPHAOP = 5, /* SVGA3dTextureCombiner */ + SVGA3D_TS_ALPHAARG1 = 6, /* SVGA3dTextureArgData */ + SVGA3D_TS_ALPHAARG2 = 7, /* SVGA3dTextureArgData */ + SVGA3D_TS_ADDRESSU = 8, /* SVGA3dTextureAddress */ + SVGA3D_TS_ADDRESSV = 9, /* SVGA3dTextureAddress */ + SVGA3D_TS_MIPFILTER = 10, /* SVGA3dTextureFilter */ + SVGA3D_TS_MAGFILTER = 11, /* SVGA3dTextureFilter */ + SVGA3D_TS_MINFILTER = 12, /* SVGA3dTextureFilter */ + SVGA3D_TS_BORDERCOLOR = 13, /* SVGA3dColor */ + SVGA3D_TS_TEXCOORDINDEX = 14, /* uint32 */ + SVGA3D_TS_TEXTURETRANSFORMFLAGS = 15, /* SVGA3dTexTransformFlags */ + SVGA3D_TS_TEXCOORDGEN = 16, /* SVGA3dTextureCoordGen */ + SVGA3D_TS_BUMPENVMAT00 = 17, /* float */ + SVGA3D_TS_BUMPENVMAT01 = 18, /* float */ + SVGA3D_TS_BUMPENVMAT10 = 19, /* float */ + SVGA3D_TS_BUMPENVMAT11 = 20, /* float */ + SVGA3D_TS_TEXTURE_MIPMAP_LEVEL = 21, /* uint32 */ + SVGA3D_TS_TEXTURE_LOD_BIAS = 22, /* float */ + SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL = 23, /* uint32 */ + SVGA3D_TS_ADDRESSW = 24, /* SVGA3dTextureAddress */ + + + /* + * Sampler Gamma Level + * + * Sampler gamma effects the color of samples taken from the sampler. A + * value of 1.0 will produce linear samples. If the value is <= 0.0 the + * gamma value is ignored and a linear space is used. + */ + + SVGA3D_TS_GAMMA = 25, /* float */ + SVGA3D_TS_BUMPENVLSCALE = 26, /* float */ + SVGA3D_TS_BUMPENVLOFFSET = 27, /* float */ + SVGA3D_TS_COLORARG0 = 28, /* SVGA3dTextureArgData */ + SVGA3D_TS_ALPHAARG0 = 29, /* SVGA3dTextureArgData */ + SVGA3D_TS_MAX +} SVGA3dTextureStateName; + +typedef enum { + SVGA3D_TC_INVALID = 0, + SVGA3D_TC_DISABLE = 1, + SVGA3D_TC_SELECTARG1 = 2, + SVGA3D_TC_SELECTARG2 = 3, + SVGA3D_TC_MODULATE = 4, + SVGA3D_TC_ADD = 5, + SVGA3D_TC_ADDSIGNED = 6, + SVGA3D_TC_SUBTRACT = 7, + SVGA3D_TC_BLENDTEXTUREALPHA = 8, + SVGA3D_TC_BLENDDIFFUSEALPHA = 9, + SVGA3D_TC_BLENDCURRENTALPHA = 10, + SVGA3D_TC_BLENDFACTORALPHA = 11, + SVGA3D_TC_MODULATE2X = 12, + SVGA3D_TC_MODULATE4X = 13, + SVGA3D_TC_DSDT = 14, + SVGA3D_TC_DOTPRODUCT3 = 15, + SVGA3D_TC_BLENDTEXTUREALPHAPM = 16, + SVGA3D_TC_ADDSIGNED2X = 17, + SVGA3D_TC_ADDSMOOTH = 18, + SVGA3D_TC_PREMODULATE = 19, + SVGA3D_TC_MODULATEALPHA_ADDCOLOR = 20, + SVGA3D_TC_MODULATECOLOR_ADDALPHA = 21, + SVGA3D_TC_MODULATEINVALPHA_ADDCOLOR = 22, + SVGA3D_TC_MODULATEINVCOLOR_ADDALPHA = 23, + SVGA3D_TC_BUMPENVMAPLUMINANCE = 24, + SVGA3D_TC_MULTIPLYADD = 25, + SVGA3D_TC_LERP = 26, + SVGA3D_TC_MAX +} SVGA3dTextureCombiner; + +#define SVGA3D_TC_CAP_BIT(svga3d_tc_op) (svga3d_tc_op ? (1 << (svga3d_tc_op - 1)) : 0) + +typedef enum { + SVGA3D_TEX_ADDRESS_INVALID = 0, + SVGA3D_TEX_ADDRESS_WRAP = 1, + SVGA3D_TEX_ADDRESS_MIRROR = 2, + SVGA3D_TEX_ADDRESS_CLAMP = 3, + SVGA3D_TEX_ADDRESS_BORDER = 4, + SVGA3D_TEX_ADDRESS_MIRRORONCE = 5, + SVGA3D_TEX_ADDRESS_EDGE = 6, + SVGA3D_TEX_ADDRESS_MAX +} SVGA3dTextureAddress; + +/* + * SVGA3D_TEX_FILTER_NONE as the minification filter means mipmapping is + * disabled, and the rasterizer should use the magnification filter instead. + */ +typedef enum { + SVGA3D_TEX_FILTER_NONE = 0, + SVGA3D_TEX_FILTER_NEAREST = 1, + SVGA3D_TEX_FILTER_LINEAR = 2, + SVGA3D_TEX_FILTER_ANISOTROPIC = 3, + SVGA3D_TEX_FILTER_FLATCUBIC = 4, // Deprecated, not implemented + SVGA3D_TEX_FILTER_GAUSSIANCUBIC = 5, // Deprecated, not implemented + SVGA3D_TEX_FILTER_PYRAMIDALQUAD = 6, // Not currently implemented + SVGA3D_TEX_FILTER_GAUSSIANQUAD = 7, // Not currently implemented + SVGA3D_TEX_FILTER_MAX +} SVGA3dTextureFilter; + +typedef enum { + SVGA3D_TEX_TRANSFORM_OFF = 0, + SVGA3D_TEX_TRANSFORM_S = (1 << 0), + SVGA3D_TEX_TRANSFORM_T = (1 << 1), + SVGA3D_TEX_TRANSFORM_R = (1 << 2), + SVGA3D_TEX_TRANSFORM_Q = (1 << 3), + SVGA3D_TEX_PROJECTED = (1 << 15), +} SVGA3dTexTransformFlags; + +typedef enum { + SVGA3D_TEXCOORD_GEN_OFF = 0, + SVGA3D_TEXCOORD_GEN_EYE_POSITION = 1, + SVGA3D_TEXCOORD_GEN_EYE_NORMAL = 2, + SVGA3D_TEXCOORD_GEN_REFLECTIONVECTOR = 3, + SVGA3D_TEXCOORD_GEN_SPHERE = 4, + SVGA3D_TEXCOORD_GEN_MAX +} SVGA3dTextureCoordGen; + +/* + * Texture argument constants for texture combiner + */ +typedef enum { + SVGA3D_TA_INVALID = 0, + SVGA3D_TA_CONSTANT = 1, + SVGA3D_TA_PREVIOUS = 2, + SVGA3D_TA_DIFFUSE = 3, + SVGA3D_TA_TEXTURE = 4, + SVGA3D_TA_SPECULAR = 5, + SVGA3D_TA_MAX +} SVGA3dTextureArgData; + +#define SVGA3D_TM_MASK_LEN 4 + +/* Modifiers for texture argument constants defined above. */ +typedef enum { + SVGA3D_TM_NONE = 0, + SVGA3D_TM_ALPHA = (1 << SVGA3D_TM_MASK_LEN), + SVGA3D_TM_ONE_MINUS = (2 << SVGA3D_TM_MASK_LEN), +} SVGA3dTextureArgModifier; + +#define SVGA3D_INVALID_ID ((uint32)-1) +#define SVGA3D_MAX_CLIP_PLANES 6 + +/* + * This is the limit to the number of fixed-function texture + * transforms and texture coordinates we can support. It does *not* + * correspond to the number of texture image units (samplers) we + * support! + */ +#define SVGA3D_MAX_TEXTURE_COORDS 8 + +/* + * Vertex declarations + * + * Notes: + * + * SVGA3D_DECLUSAGE_POSITIONT is for pre-transformed vertices. If you + * draw with any POSITIONT vertex arrays, the programmable vertex + * pipeline will be implicitly disabled. Drawing will take place as if + * no vertex shader was bound. + */ + +typedef enum { + SVGA3D_DECLUSAGE_POSITION = 0, + SVGA3D_DECLUSAGE_BLENDWEIGHT, // 1 + SVGA3D_DECLUSAGE_BLENDINDICES, // 2 + SVGA3D_DECLUSAGE_NORMAL, // 3 + SVGA3D_DECLUSAGE_PSIZE, // 4 + SVGA3D_DECLUSAGE_TEXCOORD, // 5 + SVGA3D_DECLUSAGE_TANGENT, // 6 + SVGA3D_DECLUSAGE_BINORMAL, // 7 + SVGA3D_DECLUSAGE_TESSFACTOR, // 8 + SVGA3D_DECLUSAGE_POSITIONT, // 9 + SVGA3D_DECLUSAGE_COLOR, // 10 + SVGA3D_DECLUSAGE_FOG, // 11 + SVGA3D_DECLUSAGE_DEPTH, // 12 + SVGA3D_DECLUSAGE_SAMPLE, // 13 + SVGA3D_DECLUSAGE_MAX +} SVGA3dDeclUsage; + +typedef enum { + SVGA3D_DECLMETHOD_DEFAULT = 0, + SVGA3D_DECLMETHOD_PARTIALU, + SVGA3D_DECLMETHOD_PARTIALV, + SVGA3D_DECLMETHOD_CROSSUV, // Normal + SVGA3D_DECLMETHOD_UV, + SVGA3D_DECLMETHOD_LOOKUP, // Lookup a displacement map + SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED, // Lookup a pre-sampled displacement map +} SVGA3dDeclMethod; + +typedef enum { + SVGA3D_DECLTYPE_FLOAT1 = 0, + SVGA3D_DECLTYPE_FLOAT2 = 1, + SVGA3D_DECLTYPE_FLOAT3 = 2, + SVGA3D_DECLTYPE_FLOAT4 = 3, + SVGA3D_DECLTYPE_D3DCOLOR = 4, + SVGA3D_DECLTYPE_UBYTE4 = 5, + SVGA3D_DECLTYPE_SHORT2 = 6, + SVGA3D_DECLTYPE_SHORT4 = 7, + SVGA3D_DECLTYPE_UBYTE4N = 8, + SVGA3D_DECLTYPE_SHORT2N = 9, + SVGA3D_DECLTYPE_SHORT4N = 10, + SVGA3D_DECLTYPE_USHORT2N = 11, + SVGA3D_DECLTYPE_USHORT4N = 12, + SVGA3D_DECLTYPE_UDEC3 = 13, + SVGA3D_DECLTYPE_DEC3N = 14, + SVGA3D_DECLTYPE_FLOAT16_2 = 15, + SVGA3D_DECLTYPE_FLOAT16_4 = 16, + SVGA3D_DECLTYPE_MAX, +} SVGA3dDeclType; + +/* + * This structure is used for the divisor for geometry instancing; + * it's a direct translation of the Direct3D equivalent. + */ +typedef union { + struct { + /* + * For index data, this number represents the number of instances to draw. + * For instance data, this number represents the number of + * instances/vertex in this stream + */ + uint32 count : 30; + + /* + * This is 1 if this is supposed to be the data that is repeated for + * every instance. + */ + uint32 indexedData : 1; + + /* + * This is 1 if this is supposed to be the per-instance data. + */ + uint32 instanceData : 1; + }; + + uint32 value; +} PACKED +SVGA3dVertexDivisor; + +typedef enum { + SVGA3D_PRIMITIVE_INVALID = 0, + SVGA3D_PRIMITIVE_TRIANGLELIST = 1, + SVGA3D_PRIMITIVE_POINTLIST = 2, + SVGA3D_PRIMITIVE_LINELIST = 3, + SVGA3D_PRIMITIVE_LINESTRIP = 4, + SVGA3D_PRIMITIVE_TRIANGLESTRIP = 5, + SVGA3D_PRIMITIVE_TRIANGLEFAN = 6, + SVGA3D_PRIMITIVE_MAX +} SVGA3dPrimitiveType; + +typedef enum { + SVGA3D_COORDINATE_INVALID = 0, + SVGA3D_COORDINATE_LEFTHANDED = 1, + SVGA3D_COORDINATE_RIGHTHANDED = 2, + SVGA3D_COORDINATE_MAX +} SVGA3dCoordinateType; + +typedef enum { + SVGA3D_TRANSFORM_INVALID = 0, + SVGA3D_TRANSFORM_WORLD = 1, + SVGA3D_TRANSFORM_VIEW = 2, + SVGA3D_TRANSFORM_PROJECTION = 3, + SVGA3D_TRANSFORM_TEXTURE0 = 4, + SVGA3D_TRANSFORM_TEXTURE1 = 5, + SVGA3D_TRANSFORM_TEXTURE2 = 6, + SVGA3D_TRANSFORM_TEXTURE3 = 7, + SVGA3D_TRANSFORM_TEXTURE4 = 8, + SVGA3D_TRANSFORM_TEXTURE5 = 9, + SVGA3D_TRANSFORM_TEXTURE6 = 10, + SVGA3D_TRANSFORM_TEXTURE7 = 11, + SVGA3D_TRANSFORM_WORLD1 = 12, + SVGA3D_TRANSFORM_WORLD2 = 13, + SVGA3D_TRANSFORM_WORLD3 = 14, + SVGA3D_TRANSFORM_MAX +} SVGA3dTransformType; + +typedef enum { + SVGA3D_LIGHTTYPE_INVALID = 0, + SVGA3D_LIGHTTYPE_POINT = 1, + SVGA3D_LIGHTTYPE_SPOT1 = 2, /* 1-cone, in degrees */ + SVGA3D_LIGHTTYPE_SPOT2 = 3, /* 2-cone, in radians */ + SVGA3D_LIGHTTYPE_DIRECTIONAL = 4, + SVGA3D_LIGHTTYPE_MAX +} SVGA3dLightType; + +typedef enum { + SVGA3D_CUBEFACE_POSX = 0, + SVGA3D_CUBEFACE_NEGX = 1, + SVGA3D_CUBEFACE_POSY = 2, + SVGA3D_CUBEFACE_NEGY = 3, + SVGA3D_CUBEFACE_POSZ = 4, + SVGA3D_CUBEFACE_NEGZ = 5, +} SVGA3dCubeFace; + +typedef enum { + SVGA3D_SHADERTYPE_COMPILED_DX8 = 0, + SVGA3D_SHADERTYPE_VS = 1, + SVGA3D_SHADERTYPE_PS = 2, + SVGA3D_SHADERTYPE_MAX +} SVGA3dShaderType; + +typedef enum { + SVGA3D_CONST_TYPE_FLOAT = 0, + SVGA3D_CONST_TYPE_INT = 1, + SVGA3D_CONST_TYPE_BOOL = 2, +} SVGA3dShaderConstType; + +#define SVGA3D_MAX_SURFACE_FACES 6 + +typedef enum { + SVGA3D_STRETCH_BLT_POINT = 0, + SVGA3D_STRETCH_BLT_LINEAR = 1, + SVGA3D_STRETCH_BLT_MAX +} SVGA3dStretchBltMode; + +typedef enum { + SVGA3D_QUERYTYPE_OCCLUSION = 0, + SVGA3D_QUERYTYPE_MAX +} SVGA3dQueryType; + +typedef enum { + SVGA3D_QUERYSTATE_PENDING = 0, /* Waiting on the host (set by guest) */ + SVGA3D_QUERYSTATE_SUCCEEDED = 1, /* Completed successfully (set by host) */ + SVGA3D_QUERYSTATE_FAILED = 2, /* Completed unsuccessfully (set by host) */ + SVGA3D_QUERYSTATE_NEW = 3, /* Never submitted (For guest use only) */ +} SVGA3dQueryState; + +typedef enum { + SVGA3D_WRITE_HOST_VRAM = 1, + SVGA3D_READ_HOST_VRAM = 2, +} SVGA3dTransferType; + +/* + * The maximum number vertex arrays we're guaranteed to support in + * SVGA_3D_CMD_DRAWPRIMITIVES. + */ +#define SVGA3D_MAX_VERTEX_ARRAYS 32 + +/* + * Identifiers for commands in the command FIFO. + * + * IDs between 1000 and 1039 (inclusive) were used by obsolete versions of + * the SVGA3D protocol and remain reserved; they should not be used in the + * future. + * + * IDs between 1040 and 1999 (inclusive) are available for use by the + * current SVGA3D protocol. + * + * FIFO clients other than SVGA3D should stay below 1000, or at 2000 + * and up. + */ + +#define SVGA_3D_CMD_LEGACY_BASE 1000 +#define SVGA_3D_CMD_BASE 1040 + +#define SVGA_3D_CMD_SURFACE_DEFINE SVGA_3D_CMD_BASE + 0 +#define SVGA_3D_CMD_SURFACE_DESTROY SVGA_3D_CMD_BASE + 1 +#define SVGA_3D_CMD_SURFACE_COPY SVGA_3D_CMD_BASE + 2 +#define SVGA_3D_CMD_SURFACE_STRETCHBLT SVGA_3D_CMD_BASE + 3 +#define SVGA_3D_CMD_SURFACE_DMA SVGA_3D_CMD_BASE + 4 +#define SVGA_3D_CMD_CONTEXT_DEFINE SVGA_3D_CMD_BASE + 5 +#define SVGA_3D_CMD_CONTEXT_DESTROY SVGA_3D_CMD_BASE + 6 +#define SVGA_3D_CMD_SETTRANSFORM SVGA_3D_CMD_BASE + 7 +#define SVGA_3D_CMD_SETZRANGE SVGA_3D_CMD_BASE + 8 +#define SVGA_3D_CMD_SETRENDERSTATE SVGA_3D_CMD_BASE + 9 +#define SVGA_3D_CMD_SETRENDERTARGET SVGA_3D_CMD_BASE + 10 +#define SVGA_3D_CMD_SETTEXTURESTATE SVGA_3D_CMD_BASE + 11 +#define SVGA_3D_CMD_SETMATERIAL SVGA_3D_CMD_BASE + 12 +#define SVGA_3D_CMD_SETLIGHTDATA SVGA_3D_CMD_BASE + 13 +#define SVGA_3D_CMD_SETLIGHTENABLED SVGA_3D_CMD_BASE + 14 +#define SVGA_3D_CMD_SETVIEWPORT SVGA_3D_CMD_BASE + 15 +#define SVGA_3D_CMD_SETCLIPPLANE SVGA_3D_CMD_BASE + 16 +#define SVGA_3D_CMD_CLEAR SVGA_3D_CMD_BASE + 17 +#define SVGA_3D_CMD_PRESENT SVGA_3D_CMD_BASE + 18 // Deprecated +#define SVGA_3D_CMD_SHADER_DEFINE SVGA_3D_CMD_BASE + 19 +#define SVGA_3D_CMD_SHADER_DESTROY SVGA_3D_CMD_BASE + 20 +#define SVGA_3D_CMD_SET_SHADER SVGA_3D_CMD_BASE + 21 +#define SVGA_3D_CMD_SET_SHADER_CONST SVGA_3D_CMD_BASE + 22 +#define SVGA_3D_CMD_DRAW_PRIMITIVES SVGA_3D_CMD_BASE + 23 +#define SVGA_3D_CMD_SETSCISSORRECT SVGA_3D_CMD_BASE + 24 +#define SVGA_3D_CMD_BEGIN_QUERY SVGA_3D_CMD_BASE + 25 +#define SVGA_3D_CMD_END_QUERY SVGA_3D_CMD_BASE + 26 +#define SVGA_3D_CMD_WAIT_FOR_QUERY SVGA_3D_CMD_BASE + 27 +#define SVGA_3D_CMD_PRESENT_READBACK SVGA_3D_CMD_BASE + 28 // Deprecated +#define SVGA_3D_CMD_MAX SVGA_3D_CMD_BASE + 29 + +#define SVGA_3D_CMD_FUTURE_MAX 2000 + +/* + * Common substructures used in multiple FIFO commands: + */ + +typedef struct { + union { + struct { + uint16 function; // SVGA3dFogFunction + uint8 type; // SVGA3dFogType + uint8 base; // SVGA3dFogBase + }; + uint32 uintValue; + }; +} PACKED +SVGA3dFogMode; + +/* + * Uniquely identify one image (a 1D/2D/3D array) from a surface. This + * is a surface ID as well as face/mipmap indices. + */ + +typedef +struct SVGA3dSurfaceImageId { + uint32 sid; + uint32 face; + uint32 mipmap; +} PACKED +SVGA3dSurfaceImageId; + +typedef +struct SVGA3dGuestImage { + SVGAGuestPtr ptr; + + /* + * A note on interpretation of pitch: This value of pitch is the + * number of bytes between vertically adjacent image + * blocks. Normally this is the number of bytes between the first + * pixel of two adjacent scanlines. With compressed textures, + * however, this may represent the number of bytes between + * compression blocks rather than between rows of pixels. + * + * XXX: Compressed textures currently must be tightly packed in guest memory. + * + * If the image is 1-dimensional, pitch is ignored. + * + * If 'pitch' is zero, the SVGA3D device calculates a pitch value + * assuming each row of blocks is tightly packed. + */ + uint32 pitch; +} PACKED +SVGA3dGuestImage; + + +/* + * FIFO command format definitions: + */ + +/* + * The data size header following cmdNum for every 3d command + */ +typedef +struct { + uint32 id; + uint32 size; +} PACKED +SVGA3dCmdHeader; + +/* + * A surface is a hierarchy of host VRAM surfaces: 1D, 2D, or 3D, with + * optional mipmaps and cube faces. + */ + +typedef +struct { + uint32 width; + uint32 height; + uint32 depth; +} PACKED +SVGA3dSize; + +typedef enum { + SVGA3D_SURFACE_CUBEMAP = (1 << 0), + SVGA3D_SURFACE_HINT_STATIC = (1 << 1), + SVGA3D_SURFACE_HINT_DYNAMIC = (1 << 2), + SVGA3D_SURFACE_HINT_INDEXBUFFER = (1 << 3), + SVGA3D_SURFACE_HINT_VERTEXBUFFER = (1 << 4), +} SVGA3dSurfaceFlags; + +typedef +struct { + uint32 numMipLevels; +} PACKED +SVGA3dSurfaceFace; + +typedef +struct { + uint32 sid; + SVGA3dSurfaceFlags surfaceFlags; + SVGA3dSurfaceFormat format; + SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES]; + /* + * Followed by an SVGA3dSize structure for each mip level in each face. + * + * A note on surface sizes: Sizes are always specified in pixels, + * even if the true surface size is not a multiple of the minimum + * block size of the surface's format. For example, a 3x3x1 DXT1 + * compressed texture would actually be stored as a 4x4x1 image in + * memory. + */ +} PACKED +SVGA3dCmdDefineSurface; /* SVGA_3D_CMD_SURFACE_DEFINE */ + +typedef +struct { + uint32 sid; +} PACKED +SVGA3dCmdDestroySurface; /* SVGA_3D_CMD_SURFACE_DESTROY */ + +typedef +struct { + uint32 cid; +} PACKED +SVGA3dCmdDefineContext; /* SVGA_3D_CMD_CONTEXT_DEFINE */ + +typedef +struct { + uint32 cid; +} PACKED +SVGA3dCmdDestroyContext; /* SVGA_3D_CMD_CONTEXT_DESTROY */ + +typedef +struct { + uint32 cid; + SVGA3dClearFlag clearFlag; + uint32 color; + float depth; + uint32 stencil; + /* Followed by variable number of SVGA3dRect structures */ +} PACKED +SVGA3dCmdClear; /* SVGA_3D_CMD_CLEAR */ + +typedef +struct SVGA3dCopyRect { + uint32 x; + uint32 y; + uint32 w; + uint32 h; + uint32 srcx; + uint32 srcy; +} PACKED +SVGA3dCopyRect; + +typedef +struct SVGA3dCopyBox { + uint32 x; + uint32 y; + uint32 z; + uint32 w; + uint32 h; + uint32 d; + uint32 srcx; + uint32 srcy; + uint32 srcz; +} PACKED +SVGA3dCopyBox; + +typedef +struct { + uint32 x; + uint32 y; + uint32 w; + uint32 h; +} PACKED +SVGA3dRect; + +typedef +struct { + uint32 x; + uint32 y; + uint32 z; + uint32 w; + uint32 h; + uint32 d; +} PACKED +SVGA3dBox; + +typedef +struct { + uint32 x; + uint32 y; + uint32 z; +} PACKED +SVGA3dPoint; + +typedef +struct { + SVGA3dLightType type; + SVGA3dBool inWorldSpace; + float diffuse[4]; + float specular[4]; + float ambient[4]; + float position[4]; + float direction[4]; + float range; + float falloff; + float attenuation0; + float attenuation1; + float attenuation2; + float theta; + float phi; +} PACKED +SVGA3dLightData; + +typedef +struct { + uint32 sid; + /* Followed by variable number of SVGA3dCopyRect structures */ +} PACKED +SVGA3dCmdPresent; /* SVGA_3D_CMD_PRESENT */ + +typedef +struct { + SVGA3dRenderStateName state; + union { + uint32 uintValue; + float floatValue; + }; +} PACKED +SVGA3dRenderState; + +typedef +struct { + uint32 cid; + /* Followed by variable number of SVGA3dRenderState structures */ +} PACKED +SVGA3dCmdSetRenderState; /* SVGA_3D_CMD_SETRENDERSTATE */ + +typedef +struct { + uint32 cid; + SVGA3dRenderTargetType type; + SVGA3dSurfaceImageId target; +} PACKED +SVGA3dCmdSetRenderTarget; /* SVGA_3D_CMD_SETRENDERTARGET */ + +typedef +struct { + SVGA3dSurfaceImageId src; + SVGA3dSurfaceImageId dest; + /* Followed by variable number of SVGA3dCopyBox structures */ +} PACKED +SVGA3dCmdSurfaceCopy; /* SVGA_3D_CMD_SURFACE_COPY */ + +typedef +struct { + SVGA3dSurfaceImageId src; + SVGA3dSurfaceImageId dest; + SVGA3dBox boxSrc; + SVGA3dBox boxDest; + SVGA3dStretchBltMode mode; +} PACKED +SVGA3dCmdSurfaceStretchBlt; /* SVGA_3D_CMD_SURFACE_STRETCHBLT */ + +typedef +struct { + SVGA3dGuestImage guest; + SVGA3dSurfaceImageId host; + SVGA3dTransferType transfer; + /* + * Followed by variable number of SVGA3dCopyBox structures. For consistency + * in all clipping logic and coordinate translation, we define the + * "source" in each copyBox as the guest image and the + * "destination" as the host image, regardless of transfer + * direction. + * + * For efficiency, the SVGA3D device is free to copy more data than + * specified. For example, it may round copy boxes outwards such + * that they lie on particular alignment boundaries. + */ +} PACKED +SVGA3dCmdSurfaceDMA; /* SVGA_3D_CMD_SURFACE_DMA */ + + +/* + * SVGA_3D_CMD_DRAW_PRIMITIVES -- + * + * This command is the SVGA3D device's generic drawing entry point. + * It can draw multiple ranges of primitives, optionally using an + * index buffer, using an arbitrary collection of vertex buffers. + * + * Each SVGA3dVertexDecl defines a distinct vertex array to bind + * during this draw call. The declarations specify which surface + * the vertex data lives in, what that vertex data is used for, + * and how to interpret it. + * + * Each SVGA3dPrimitiveRange defines a collection of primitives + * to render using the same vertex arrays. An index buffer is + * optional. + */ + +typedef +struct { + /* + * A range hint is an optional specification for the range of indices + * in an SVGA3dArray that will be used. If 'last' is zero, it is assumed + * that the entire array will be used. + * + * These are only hints. The SVGA3D device may use them for + * performance optimization if possible, but it's also allowed to + * ignore these values. + */ + uint32 first; + uint32 last; +} PACKED +SVGA3dArrayRangeHint; + +typedef +struct { + /* + * Define the origin and shape of a vertex or index array. Both + * 'offset' and 'stride' are in bytes. The provided surface will be + * reinterpreted as a flat array of bytes in the same format used + * by surface DMA operations. To avoid unnecessary conversions, the + * surface should be created with the SVGA3D_BUFFER format. + * + * Index 0 in the array starts 'offset' bytes into the surface. + * Index 1 begins at byte 'offset + stride', etc. Array indices may + * not be negative. + */ + uint32 surfaceId; + uint32 offset; + uint32 stride; +} PACKED +SVGA3dArray; + +typedef +struct { + /* + * Describe a vertex array's data type, and define how it is to be + * used by the fixed function pipeline or the vertex shader. It + * isn't useful to have two VertexDecls with the same + * VertexArrayIdentity in one draw call. + */ + SVGA3dDeclType type; + SVGA3dDeclMethod method; + SVGA3dDeclUsage usage; + uint32 usageIndex; +} PACKED +SVGA3dVertexArrayIdentity; + +typedef +struct { + SVGA3dVertexArrayIdentity identity; + SVGA3dArray array; + SVGA3dArrayRangeHint rangeHint; +} PACKED +SVGA3dVertexDecl; + +typedef +struct { + /* + * Define a group of primitives to render, from sequential indices. + * + * The value of 'primitiveType' and 'primitiveCount' imply the + * total number of vertices that will be rendered. + */ + SVGA3dPrimitiveType primType; + uint32 primitiveCount; + + /* + * Optional index buffer. If indexArray.surfaceId is + * SVGA3D_INVALID_ID, we render without an index buffer. Rendering + * without an index buffer is identical to rendering with an index + * buffer containing the sequence [0, 1, 2, 3, ...]. + * + * If an index buffer is in use, indexWidth specifies the width in + * bytes of each index value. It must be less than or equal to + * indexArray.stride. + * + * (Currently, the SVGA3D device requires index buffers to be tightly + * packed. In other words, indexWidth == indexArray.stride) + */ + SVGA3dArray indexArray; + uint32 indexWidth; + + /* + * Optional index bias. This number is added to all indices from + * indexArray before they are used as vertex array indices. This + * can be used in multiple ways: + * + * - When not using an indexArray, this bias can be used to + * specify where in the vertex arrays to begin rendering. + * + * - A positive number here is equivalent to increasing the + * offset in each vertex array. + * + * - A negative number can be used to render using a small + * vertex array and an index buffer that contains large + * values. This may be used by some applications that + * crop a vertex buffer without modifying their index + * buffer. + * + * Note that rendering with a negative bias value may be slower and + * use more memory than rendering with a positive or zero bias. + */ + int32 indexBias; +} PACKED +SVGA3dPrimitiveRange; + +typedef +struct { + uint32 cid; + uint32 numVertexDecls; + uint32 numRanges; + + /* + * There are two variable size arrays after the + * SVGA3dCmdDrawPrimitives structure. In order, + * they are: + * + * 1. SVGA3dVertexDecl, quantity 'numVertexDecls' + * 2. SVGA3dPrimitiveRange, quantity 'numRanges' + * 3. Optionally, SVGA3dVertexDivisor, quantity 'numVertexDecls' (contains + * the frequency divisor for this the corresponding vertex decl) + */ +} PACKED +SVGA3dCmdDrawPrimitives; /* SVGA_3D_CMD_DRAWPRIMITIVES */ + +typedef +struct { + uint32 stage; + SVGA3dTextureStateName name; + union { + uint32 value; + float floatValue; + }; +} PACKED +SVGA3dTextureState; + +typedef +struct { + uint32 cid; + /* Followed by variable number of SVGA3dTextureState structures */ +} PACKED +SVGA3dCmdSetTextureState; /* SVGA_3D_CMD_SETTEXTURESTATE */ + +typedef +struct { + uint32 cid; + SVGA3dTransformType type; + float matrix[16]; +} PACKED +SVGA3dCmdSetTransform; /* SVGA_3D_CMD_SETTRANSFORM */ + +typedef +struct { + float min; + float max; +} PACKED +SVGA3dZRange; + +typedef +struct { + uint32 cid; + SVGA3dZRange zRange; +} PACKED +SVGA3dCmdSetZRange; /* SVGA_3D_CMD_SETZRANGE */ + +typedef +struct { + float diffuse[4]; + float ambient[4]; + float specular[4]; + float emissive[4]; + float shininess; +} PACKED +SVGA3dMaterial; + +typedef +struct { + uint32 cid; + SVGA3dFace face; + SVGA3dMaterial material; +} PACKED +SVGA3dCmdSetMaterial; /* SVGA_3D_CMD_SETMATERIAL */ + +typedef +struct { + uint32 cid; + uint32 index; + SVGA3dLightData data; +} PACKED +SVGA3dCmdSetLightData; /* SVGA_3D_CMD_SETLIGHTDATA */ + +typedef +struct { + uint32 cid; + uint32 index; + uint32 enabled; +} PACKED +SVGA3dCmdSetLightEnabled; /* SVGA_3D_CMD_SETLIGHTENABLED */ + +typedef +struct { + uint32 cid; + SVGA3dRect rect; +} PACKED +SVGA3dCmdSetViewport; /* SVGA_3D_CMD_SETVIEWPORT */ + +typedef +struct { + uint32 cid; + SVGA3dRect rect; +} PACKED +SVGA3dCmdSetScissorRect; /* SVGA_3D_CMD_SETSCISSORRECT */ + +typedef +struct { + uint32 cid; + uint32 index; + float plane[4]; +} PACKED +SVGA3dCmdSetClipPlane; /* SVGA_3D_CMD_SETCLIPPLANE */ + +typedef +struct { + uint32 cid; + uint32 shid; + SVGA3dShaderType type; + /* Followed by variable number of DWORDs for shader bycode */ +} PACKED +SVGA3dCmdDefineShader; /* SVGA_3D_CMD_SHADER_DEFINE */ + +typedef +struct { + uint32 cid; + uint32 shid; + SVGA3dShaderType type; +} PACKED +SVGA3dCmdDestroyShader; /* SVGA_3D_CMD_SHADER_DESTROY */ + +typedef +struct { + uint32 cid; + uint32 reg; /* register number */ + SVGA3dShaderType type; + SVGA3dShaderConstType ctype; + uint32 values[4]; +} PACKED +SVGA3dCmdSetShaderConst; /* SVGA_3D_CMD_SET_SHADER_CONST */ + +typedef +struct { + uint32 cid; + SVGA3dShaderType type; + uint32 shid; +} PACKED +SVGA3dCmdSetShader; /* SVGA_3D_CMD_SET_SHADER */ + +typedef +struct { + uint32 cid; + SVGA3dQueryType type; +} PACKED +SVGA3dCmdBeginQuery; /* SVGA_3D_CMD_BEGIN_QUERY */ + +typedef +struct { + uint32 cid; + SVGA3dQueryType type; + SVGAGuestPtr guestResult; /* Points to an SVGA3dQueryResult structure */ +} PACKED +SVGA3dCmdEndQuery; /* SVGA_3D_CMD_END_QUERY */ + +typedef +struct { + uint32 cid; /* Same parameters passed to END_QUERY */ + SVGA3dQueryType type; + SVGAGuestPtr guestResult; +} PACKED +SVGA3dCmdWaitForQuery; /* SVGA_3D_CMD_WAIT_FOR_QUERY */ + +typedef +struct { + uint32 totalSize; /* Set by guest before query is ended. */ + SVGA3dQueryState state; /* Set by host or guest. See SVGA3dQueryState. */ + union { /* Set by host on exit from PENDING state */ + uint32 result32; + }; +} PACKED +SVGA3dQueryResult; + + +/* + * Capability query index. + * + * Notes: + * + * 1. SVGA3D_DEVCAP_MAX_TEXTURES reflects the maximum number of + * fixed-function texture units available. Each of these units + * work in both FFP and Shader modes, and they support texture + * transforms and texture coordinates. The host may have additional + * texture image units that are only usable with shaders. + * + * 2. The BUFFER_FORMAT capabilities are deprecated, and they always + * return TRUE. Even on physical hardware that does not support + * these formats natively, the SVGA3D device will provide an emulation + * which should be invisible to the guest OS. + * + * In general, the SVGA3D device should support any operation on + * any surface format, it just may perform some of these + * operations in software depending on the capabilities of the + * available physical hardware. + * + * XXX: In the future, we will add capabilities that describe in + * detail what formats are supported in hardware for what kinds + * of operations. + */ + +typedef enum { + SVGA3D_DEVCAP_3D = 0, + SVGA3D_DEVCAP_MAX_LIGHTS, + SVGA3D_DEVCAP_MAX_TEXTURES, /* See note (1) */ + SVGA3D_DEVCAP_MAX_CLIP_PLANES, + SVGA3D_DEVCAP_VERTEX_SHADER_VERSION, + SVGA3D_DEVCAP_VERTEX_SHADER, + SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION, + SVGA3D_DEVCAP_FRAGMENT_SHADER, + SVGA3D_DEVCAP_MAX_RENDER_TARGETS, + SVGA3D_DEVCAP_S23E8_TEXTURES, + SVGA3D_DEVCAP_S10E5_TEXTURES, + SVGA3D_DEVCAP_MAX_FIXED_VERTEXBLEND, + SVGA3D_DEVCAP_D16_BUFFER_FORMAT, /* See note (2) */ + SVGA3D_DEVCAP_D24S8_BUFFER_FORMAT, /* See note (2) */ + SVGA3D_DEVCAP_D24X8_BUFFER_FORMAT, /* See note (2) */ + SVGA3D_DEVCAP_QUERY_TYPES, + SVGA3D_DEVCAP_TEXTURE_GRADIENT_SAMPLING, + SVGA3D_DEVCAP_MAX_POINT_SIZE, + SVGA3D_DEVCAP_MAX_SHADER_TEXTURES, + SVGA3D_DEVCAP_MAX_TEXTURE_WIDTH, + SVGA3D_DEVCAP_MAX_TEXTURE_HEIGHT, + SVGA3D_DEVCAP_MAX_VOLUME_EXTENT, + SVGA3D_DEVCAP_MAX_TEXTURE_REPEAT, + SVGA3D_DEVCAP_MAX_TEXTURE_ASPECT_RATIO, + SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY, + SVGA3D_DEVCAP_MAX_PRIMITIVE_COUNT, + SVGA3D_DEVCAP_MAX_VERTEX_INDEX, + SVGA3D_DEVCAP_MAX_VERTEX_SHADER_INSTRUCTIONS, + SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS, + SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS, + SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS, + SVGA3D_DEVCAP_TEXTURE_OPS, + SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8, + SVGA3D_DEVCAP_SURFACEFMT_MIN=SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8, + SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8, + SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10, + SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5, + SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5, + SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4, + SVGA3D_DEVCAP_SURFACEFMT_R5G6B5, + SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16, + SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8, + SVGA3D_DEVCAP_SURFACEFMT_ALPHA8, + SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8, + SVGA3D_DEVCAP_SURFACEFMT_Z_D16, + SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8, + SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8, + SVGA3D_DEVCAP_SURFACEFMT_DXT1, + SVGA3D_DEVCAP_SURFACEFMT_DXT2, + SVGA3D_DEVCAP_SURFACEFMT_DXT3, + SVGA3D_DEVCAP_SURFACEFMT_DXT4, + SVGA3D_DEVCAP_SURFACEFMT_DXT5, + SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8, + SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10, + SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8, + SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8, + SVGA3D_DEVCAP_SURFACEFMT_CxV8U8, + SVGA3D_DEVCAP_SURFACEFMT_R_S10E5, + SVGA3D_DEVCAP_SURFACEFMT_R_S23E8, + SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5, + SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8, + SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5, + SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8, + SVGA3D_DEVCAP_SURFACEFMT_MAX=SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8 + 1, + SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEXTURES, + + + /* + * Note that MAX_SIMULTANEOUS_RENDER_TARGETS is a maximum count of color + * render targets. This does no include the depth or stencil targets. + */ + SVGA3D_DEVCAP_MAX_SIMULTANEOUS_RENDER_TARGETS, + SVGA3D_DEVCAP_MAX /* This must be the last index. */ +} SVGA3dDevCapIndex; + +typedef union { + Bool b; + uint32 u; + int32 i; + float f; +} PACKED SVGA3dDevCapResult; + +#endif /* _SVGA3D_REG_H_ */ diff --git a/lib/vmware/svga3d_shaderdefs.h b/lib/vmware/svga3d_shaderdefs.h new file mode 100644 index 0000000..01a4c24 --- /dev/null +++ b/lib/vmware/svga3d_shaderdefs.h @@ -0,0 +1,510 @@ +/********************************************************** + * Copyright 2007-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga3d_shaderdefs.h -- + * + * SVGA3D byte code format and limit definitions. + * + * The format of the byte code directly corresponds to that defined + * by Microsoft DirectX SDK 9.0c (file d3d9types.h). The format can + * also be extended so that different shader formats can be supported + * for example GLSL, ARB vp/fp, NV/ATI shader formats, etc. + * + */ + +#ifndef __SVGA3D_SHADER_DEFS__ +#define __SVGA3D_SHADER_DEFS__ + +/* SVGA3D shader hardware limits. */ + +#define SVGA3D_INPUTREG_MAX 16 +#define SVGA3D_OUTPUTREG_MAX 12 +#define SVGA3D_VERTEX_SAMPLERREG_MAX 4 +#define SVGA3D_PIXEL_SAMPLERREG_MAX 16 +#define SVGA3D_SAMPLERREG_MAX (SVGA3D_PIXEL_SAMPLERREG_MAX+\ + SVGA3D_VERTEX_SAMPLERREG_MAX) +#define SVGA3D_TEMPREG_MAX 32 +#define SVGA3D_CONSTREG_MAX 256 +#define SVGA3D_CONSTINTREG_MAX 16 +#define SVGA3D_CONSTBOOLREG_MAX 16 +#define SVGA3D_ADDRREG_MAX 1 +#define SVGA3D_PREDREG_MAX 1 + +/* SVGA3D byte code specific limits */ + +#define SVGA3D_MAX_SRC_REGS 4 +#define SVGA3D_MAX_NESTING_LEVEL 32 + +/* SVGA3D version information. */ + +#define SVGA3D_VS_TYPE 0xFFFE +#define SVGA3D_PS_TYPE 0xFFFF + +typedef struct { + union { + struct { + uint32 minor : 8; + uint32 major : 8; + uint32 type : 16; + }; + + uint32 value; + }; +} SVGA3dShaderVersion; + +#define SVGA3D_VS_10 ((SVGA3D_VS_TYPE << 16) | 1 << 8) +#define SVGA3D_VS_11 (SVGA3D_VS_10 | 1) +#define SVGA3D_VS_20 ((SVGA3D_VS_TYPE << 16) | 2 << 8) +#define SVGA3D_VS_30 ((SVGA3D_VS_TYPE << 16) | 3 << 8) + +#define SVGA3D_PS_10 ((SVGA3D_PS_TYPE << 16) | 1 << 8) +#define SVGA3D_PS_11 (SVGA3D_PS_10 | 1) +#define SVGA3D_PS_12 (SVGA3D_PS_10 | 2) +#define SVGA3D_PS_13 (SVGA3D_PS_10 | 3) +#define SVGA3D_PS_14 (SVGA3D_PS_10 | 4) +#define SVGA3D_PS_20 ((SVGA3D_PS_TYPE << 16) | 2 << 8) +#define SVGA3D_PS_30 ((SVGA3D_PS_TYPE << 16) | 3 << 8) + +/* The *_ENABLED are for backwards compatibility with old drivers */ +typedef enum { + SVGA3DPSVERSION_NONE = 0, + SVGA3DPSVERSION_ENABLED = 1, + SVGA3DPSVERSION_11 = 3, + SVGA3DPSVERSION_12 = 5, + SVGA3DPSVERSION_13 = 7, + SVGA3DPSVERSION_14 = 9, + SVGA3DPSVERSION_20 = 11, + SVGA3DPSVERSION_30 = 13, + SVGA3DPSVERSION_40 = 15, + SVGA3DPSVERSION_MAX +} SVGA3dPixelShaderVersion; + +typedef enum { + SVGA3DVSVERSION_NONE = 0, + SVGA3DVSVERSION_ENABLED = 1, + SVGA3DVSVERSION_11 = 3, + SVGA3DVSVERSION_20 = 5, + SVGA3DVSVERSION_30 = 7, + SVGA3DVSVERSION_40 = 9, + SVGA3DVSVERSION_MAX +} SVGA3dVertexShaderVersion; + +/* SVGA3D instruction op codes. */ + +typedef enum { + SVGA3DOP_NOP = 0, + SVGA3DOP_MOV, + SVGA3DOP_ADD, + SVGA3DOP_SUB, + SVGA3DOP_MAD, + SVGA3DOP_MUL, + SVGA3DOP_RCP, + SVGA3DOP_RSQ, + SVGA3DOP_DP3, + SVGA3DOP_DP4, + SVGA3DOP_MIN, + SVGA3DOP_MAX, + SVGA3DOP_SLT, + SVGA3DOP_SGE, + SVGA3DOP_EXP, + SVGA3DOP_LOG, + SVGA3DOP_LIT, + SVGA3DOP_DST, + SVGA3DOP_LRP, + SVGA3DOP_FRC, + SVGA3DOP_M4x4, + SVGA3DOP_M4x3, + SVGA3DOP_M3x4, + SVGA3DOP_M3x3, + SVGA3DOP_M3x2, + SVGA3DOP_CALL, + SVGA3DOP_CALLNZ, + SVGA3DOP_LOOP, + SVGA3DOP_RET, + SVGA3DOP_ENDLOOP, + SVGA3DOP_LABEL, + SVGA3DOP_DCL, + SVGA3DOP_POW, + SVGA3DOP_CRS, + SVGA3DOP_SGN, + SVGA3DOP_ABS, + SVGA3DOP_NRM, + SVGA3DOP_SINCOS, + SVGA3DOP_REP, + SVGA3DOP_ENDREP, + SVGA3DOP_IF, + SVGA3DOP_IFC, + SVGA3DOP_ELSE, + SVGA3DOP_ENDIF, + SVGA3DOP_BREAK, + SVGA3DOP_BREAKC, + SVGA3DOP_MOVA, + SVGA3DOP_DEFB, + SVGA3DOP_DEFI, + SVGA3DOP_TEXCOORD = 64, + SVGA3DOP_TEXKILL, + SVGA3DOP_TEX, + SVGA3DOP_TEXBEM, + SVGA3DOP_TEXBEML, + SVGA3DOP_TEXREG2AR, + SVGA3DOP_TEXREG2GB = 70, + SVGA3DOP_TEXM3x2PAD, + SVGA3DOP_TEXM3x2TEX, + SVGA3DOP_TEXM3x3PAD, + SVGA3DOP_TEXM3x3TEX, + SVGA3DOP_RESERVED0, + SVGA3DOP_TEXM3x3SPEC, + SVGA3DOP_TEXM3x3VSPEC, + SVGA3DOP_EXPP, + SVGA3DOP_LOGP, + SVGA3DOP_CND = 80, + SVGA3DOP_DEF, + SVGA3DOP_TEXREG2RGB, + SVGA3DOP_TEXDP3TEX, + SVGA3DOP_TEXM3x2DEPTH, + SVGA3DOP_TEXDP3, + SVGA3DOP_TEXM3x3, + SVGA3DOP_TEXDEPTH, + SVGA3DOP_CMP, + SVGA3DOP_BEM, + SVGA3DOP_DP2ADD = 90, + SVGA3DOP_DSX, + SVGA3DOP_DSY, + SVGA3DOP_TEXLDD, + SVGA3DOP_SETP, + SVGA3DOP_TEXLDL, + SVGA3DOP_BREAKP = 96, + SVGA3DOP_LAST_INST, + SVGA3DOP_PHASE = 0xFFFD, + SVGA3DOP_COMMENT = 0xFFFE, + SVGA3DOP_END = 0xFFFF, +} SVGA3dShaderOpCodeType; + +/* SVGA3D operation control/comparison function types */ + +typedef enum { + SVGA3DOPCONT_NONE, + SVGA3DOPCONT_PROJECT, /* Projective texturing */ + SVGA3DOPCONT_BIAS, /* Texturing with a LOD bias */ +} SVGA3dShaderOpCodeControlFnType; + +typedef enum { + SVGA3DOPCOMP_RESERVED0 = 0, + SVGA3DOPCOMP_GT, + SVGA3DOPCOMP_EQ, + SVGA3DOPCOMP_GE, + SVGA3DOPCOMP_LT, + SVGA3DOPCOMPC_NE, + SVGA3DOPCOMP_LE, + SVGA3DOPCOMP_RESERVED1 +} SVGA3dShaderOpCodeCompFnType; + +/* SVGA3D register types */ + +typedef enum { + SVGA3DREG_TEMP = 0, /* Temporary register file */ + SVGA3DREG_INPUT, /* Input register file */ + SVGA3DREG_CONST, /* Constant register file */ + SVGA3DREG_ADDR, /* Address register for VS */ + SVGA3DREG_TEXTURE = 3, /* Texture register file for PS */ + SVGA3DREG_RASTOUT, /* Rasterizer register file */ + SVGA3DREG_ATTROUT, /* Attribute output register file */ + SVGA3DREG_TEXCRDOUT, /* Texture coordinate output register file */ + SVGA3DREG_OUTPUT = 6, /* Output register file for VS 3.0+ */ + SVGA3DREG_CONSTINT, /* Constant integer vector register file */ + SVGA3DREG_COLOROUT, /* Color output register file */ + SVGA3DREG_DEPTHOUT, /* Depth output register file */ + SVGA3DREG_SAMPLER, /* Sampler state register file */ + SVGA3DREG_CONST2, /* Constant register file 2048 - 4095 */ + SVGA3DREG_CONST3, /* Constant register file 4096 - 6143 */ + SVGA3DREG_CONST4, /* Constant register file 6144 - 8191 */ + SVGA3DREG_CONSTBOOL, /* Constant boolean register file */ + SVGA3DREG_LOOP, /* Loop counter register file */ + SVGA3DREG_TEMPFLOAT16, /* 16-bit float temp register file */ + SVGA3DREG_MISCTYPE, /* Miscellaneous (single) registers */ + SVGA3DREG_LABEL, /* Label */ + SVGA3DREG_PREDICATE, /* Predicate register */ +} SVGA3dShaderRegType; + +/* SVGA3D rasterizer output register types */ + +typedef enum { + SVGA3DRASTOUT_POSITION = 0, + SVGA3DRASTOUT_FOG, + SVGA3DRASTOUT_PSIZE +} SVGA3dShaderRastOutRegType; + +/* SVGA3D miscellaneous register types */ + +typedef enum { + SVGA3DMISCREG_POSITION = 0, /* Input position x,y,z,rhw (PS) */ + SVGA3DMISCREG_FACE /* Floating point primitive area (PS) */ +} SVGA3DShaderMiscRegType; + +/* SVGA3D sampler types */ + +typedef enum { + SVGA3DSAMP_UNKNOWN = 0, /* Uninitialized value */ + SVGA3DSAMP_2D = 2, /* dcl_2d s# (for declaring a 2-D texture) */ + SVGA3DSAMP_CUBE, /* dcl_cube s# (for declaring a cube texture) */ + SVGA3DSAMP_VOLUME, /* dcl_volume s# (for declaring a volume texture) */ +} SVGA3dShaderSamplerType; + +/* SVGA3D sampler format classes */ + +typedef enum { + SVGA3DSAMPFORMAT_ARGB, /* ARGB formats */ + SVGA3DSAMPFORMAT_V8U8, /* Sign and normalize (SNORM) V & U */ + SVGA3DSAMPFORMAT_Q8W8V8U8, /* SNORM all */ + SVGA3DSAMPFORMAT_CxV8U8, /* SNORM V & U, C=SQRT(1-U^2-V^2) */ + SVGA3DSAMPFORMAT_X8L8V8U8, /* SNORM V & U */ + SVGA3DSAMPFORMAT_A2W10V10U10, /* SNORM W, V & U */ + SVGA3DSAMPFORMAT_DXT_PMA, /* DXT pre-multiplied alpha */ + SVGA3DSAMPFORMAT_YUV, /* YUV video format */ + SVGA3DSAMPFORMAT_UYVY, /* UYVY video format */ + SVGA3DSAMPFORMAT_Rx, /* R16F/32F */ + SVGA3DSAMPFORMAT_RxGx, /* R16FG16F, R32FG32F */ +} SVGA3DShaderSamplerFormatClass; + +/* SVGA3D write mask */ + +#define SVGA3DWRITEMASK_0 1 /* Component 0 (X;Red) */ +#define SVGA3DWRITEMASK_1 2 /* Component 1 (Y;Green) */ +#define SVGA3DWRITEMASK_2 4 /* Component 2 (Z;Blue) */ +#define SVGA3DWRITEMASK_3 8 /* Component 3 (W;Alpha) */ +#define SVGA3DWRITEMASK_ALL 15 /* All components */ + +/* SVGA3D destination modifiers */ + +#define SVGA3DDSTMOD_NONE 0 /* nop */ +#define SVGA3DDSTMOD_SATURATE 1 /* clamp to [0, 1] */ +#define SVGA3DDSTMOD_PARTIALPRECISION 2 /* Partial precision hint */ + +/* + * Relevant to multisampling only: + * When the pixel center is not covered, sample + * attribute or compute gradients/LOD + * using multisample "centroid" location. + * "Centroid" is some location within the covered + * region of the pixel. + */ + +#define SVGA3DDSTMOD_MSAMPCENTROID 4 + +/* SVGA3D source swizzle */ + +#define SVGA3DSWIZZLE_NONE 0xE4 +#define SVGA3DSWIZZLE_REPLICATEX 0x00 +#define SVGA3DSWIZZLE_REPLICATEY 0x55 +#define SVGA3DSWIZZLE_REPLICATEZ 0xAA +#define SVGA3DSWIZZLE_REPLICATEW 0xFF + +/* SVGA3D source modifiers */ + +typedef enum { + SVGA3DSRCMOD_NONE = 0, /* nop */ + SVGA3DSRCMOD_NEG, /* negate */ + SVGA3DSRCMOD_BIAS, /* bias */ + SVGA3DSRCMOD_BIASNEG, /* bias and negate */ + SVGA3DSRCMOD_SIGN, /* sign */ + SVGA3DSRCMOD_SIGNNEG, /* sign and negate */ + SVGA3DSRCMOD_COMP, /* complement */ + SVGA3DSRCMOD_X2, /* x2 */ + SVGA3DSRCMOD_X2NEG, /* x2 and negate */ + SVGA3DSRCMOD_DZ, /* divide through by z component */ + SVGA3DSRCMOD_DW, /* divide through by w component */ + SVGA3DSRCMOD_ABS, /* abs() */ + SVGA3DSRCMOD_ABSNEG, /* -abs() */ + SVGA3DSRCMOD_NOT, /* ! (for predicate register) */ +} SVGA3dShaderSrcModType; + +/* SVGA3D instruction token */ + +typedef struct { + union { + struct { + uint32 op : 16; + uint32 control : 3; + uint32 reserved2 : 5; + uint32 size : 4; + uint32 predicated : 1; + uint32 reserved1 : 1; + uint32 coissue : 1; + uint32 reserved0 : 1; + }; + + uint32 value; + }; +} SVGA3dShaderInstToken; + +/* SVGA3D destination parameter token */ + +typedef struct { + union { + struct { + uint32 num : 11; + uint32 type_upper : 2; + uint32 relAddr : 1; + uint32 reserved1 : 2; + uint32 mask : 4; + uint32 dstMod : 4; + uint32 shfScale : 4; + uint32 type_lower : 3; + uint32 reserved0 : 1; + }; + + uint32 value; + }; +} SVGA3dShaderDestToken; + +/* SVGA3D source parameter token */ + +typedef struct { + union { + struct { + uint32 num : 11; + uint32 type_upper : 2; + uint32 relAddr : 1; + uint32 reserved1 : 2; + uint32 swizzle : 8; + uint32 srcMod : 4; + uint32 type_lower : 3; + uint32 reserved0 : 1; + }; + + uint32 value; + }; +} SVGA3dShaderSrcToken; + +/* SVGA3DOP_DCL parameter tokens */ + +typedef struct { + union { + struct { + union { + struct { + uint32 usage : 5; + uint32 reserved1 : 11; + uint32 index : 4; + uint32 reserved0 : 12; + }; /* input / output declaration */ + + struct { + uint32 reserved3 : 27; + uint32 type : 4; + uint32 reserved2 : 1; + }; /* sampler declaration */ + }; + + SVGA3dShaderDestToken dst; + }; + + uint32 values[2]; + }; +} SVGA3DOpDclArgs; + +/* SVGA3DOP_DEF parameter tokens */ + +typedef struct { + union { + struct { + SVGA3dShaderDestToken dst; + + union { + float constValues[4]; + int constIValues[4]; + Bool constBValue; + }; + }; + + uint32 values[5]; + }; +} SVGA3DOpDefArgs; + +/* SVGA3D shader token */ + +typedef union { + uint32 value; + SVGA3dShaderInstToken inst; + SVGA3dShaderDestToken dest; + SVGA3dShaderSrcToken src; +} SVGA3dShaderToken; + +/* SVGA3D shader program */ + +typedef struct { + SVGA3dShaderVersion version; + /* SVGA3dShaderToken stream */ +} SVGA3dShaderProgram; + +/* SVGA3D version specific register assignments */ + +static const uint32 SVGA3D_INPUT_REG_POSITION_VS11 = 0; +static const uint32 SVGA3D_INPUT_REG_PSIZE_VS11 = 1; +static const uint32 SVGA3D_INPUT_REG_FOG_VS11 = 3; +static const uint32 SVGA3D_INPUT_REG_FOG_MASK_VS11 = SVGA3DWRITEMASK_3; +static const uint32 SVGA3D_INPUT_REG_COLOR_BASE_VS11 = 2; +static const uint32 SVGA3D_INPUT_REG_TEXCOORD_BASE_VS11 = 4; + +static const uint32 SVGA3D_INPUT_REG_COLOR_BASE_PS11 = 0; +static const uint32 SVGA3D_INPUT_REG_TEXCOORD_BASE_PS11 = 2; +static const uint32 SVGA3D_OUTPUT_REG_DEPTH_PS11 = 0; +static const uint32 SVGA3D_OUTPUT_REG_COLOR_PS11 = 1; + +static const uint32 SVGA3D_INPUT_REG_COLOR_BASE_PS20 = 0; +static const uint32 SVGA3D_INPUT_REG_COLOR_NUM_PS20 = 2; +static const uint32 SVGA3D_INPUT_REG_TEXCOORD_BASE_PS20 = 2; +static const uint32 SVGA3D_INPUT_REG_TEXCOORD_NUM_PS20 = 8; +static const uint32 SVGA3D_OUTPUT_REG_COLOR_BASE_PS20 = 1; +static const uint32 SVGA3D_OUTPUT_REG_COLOR_NUM_PS20 = 4; +static const uint32 SVGA3D_OUTPUT_REG_DEPTH_BASE_PS20 = 0; +static const uint32 SVGA3D_OUTPUT_REG_DEPTH_NUM_PS20 = 1; + +/* + *---------------------------------------------------------------------- + * + * SVGA3dShaderGetRegType -- + * + * As the register type is split into two non sequential fields, + * this function provides an useful way of accessing the actual + * register type without having to manually concatenate the + * type_upper and type_lower fields. + * + * Results: + * Returns the register type. + * + *---------------------------------------------------------------------- + */ + +static INLINE SVGA3dShaderRegType +SVGA3dShaderGetRegType(uint32 token) +{ + SVGA3dShaderSrcToken src; + src.value = token; + return (SVGA3dShaderRegType)(src.type_upper << 3 | src.type_lower); +} + +#endif /* __SVGA3D_SHADER_DEFS__ */ diff --git a/lib/vmware/svga_escape.h b/lib/vmware/svga_escape.h new file mode 100644 index 0000000..ee5272b --- /dev/null +++ b/lib/vmware/svga_escape.h @@ -0,0 +1,83 @@ +/********************************************************** + * Copyright 2007-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga_escape.h -- + * + * Definitions for our own (vendor-specific) SVGA Escape commands. + */ + +#ifndef _SVGA_ESCAPE_H_ +#define _SVGA_ESCAPE_H_ + + +/* + * Namespace IDs for the escape command + */ + +#define SVGA_ESCAPE_NSID_VMWARE 0x00000000 +#define SVGA_ESCAPE_NSID_DEVEL 0xFFFFFFFF + + +/* + * Within SVGA_ESCAPE_NSID_VMWARE, we multiplex commands according to + * the first DWORD of escape data (after the nsID and size). As a + * guideline we're using the high word and low word as a major and + * minor command number, respectively. + * + * Major command number allocation: + * + * 0000: Reserved + * 0001: SVGA_ESCAPE_VMWARE_LOG (svga_binary_logger.h) + * 0002: SVGA_ESCAPE_VMWARE_VIDEO (svga_overlay.h) + * 0003: SVGA_ESCAPE_VMWARE_HINT (svga_escape.h) + */ + +#define SVGA_ESCAPE_VMWARE_MAJOR_MASK 0xFFFF0000 + + +/* + * SVGA Hint commands. + * + * These escapes let the SVGA driver provide optional information to + * he host about the state of the guest or guest applications. The + * host can use these hints to make user interface or performance + * decisions. + */ + +#define SVGA_ESCAPE_VMWARE_HINT 0x00030000 +#define SVGA_ESCAPE_VMWARE_HINT_FULLSCREEN 0x00030001 + +typedef +struct { + uint32 command; + uint32 fullscreen; + struct { + int32 x, y; + } monitorPosition; +} PACKED +SVGAEscapeHintFullscreen; + +#endif /* _SVGA_ESCAPE_H_ */ diff --git a/lib/vmware/svga_overlay.h b/lib/vmware/svga_overlay.h new file mode 100644 index 0000000..43460d4 --- /dev/null +++ b/lib/vmware/svga_overlay.h @@ -0,0 +1,77 @@ +/********************************************************** + * Copyright 2007-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga_overlay.h -- + * + * Definitions for video-overlay support. + */ + +#ifndef _SVGA_OVERLAY_H_ +#define _SVGA_OVERLAY_H_ + +/* + * Video formats we support + */ + +#define VMWARE_FOURCC_YV12 0x32315659 // 'Y' 'V' '1' '2' +#define VMWARE_FOURCC_YUY2 0x32595559 // 'Y' 'U' 'Y' '2' +#define VMWARE_FOURCC_UYVY 0x59565955 // 'U' 'Y' 'V' 'Y' + +#define SVGA_VIDEO_COLORKEY_MASK 0x00ffffff + +#define SVGA_ESCAPE_VMWARE_VIDEO 0x00020000 + +#define SVGA_ESCAPE_VMWARE_VIDEO_SET_REGS 0x00020001 + /* FIFO escape layout: + * Type, Stream Id, (Register Id, Value) pairs */ + +#define SVGA_ESCAPE_VMWARE_VIDEO_FLUSH 0x00020002 + /* FIFO escape layout: + * Type, Stream Id */ + +typedef +struct SVGAEscapeVideoSetRegs { + struct { + uint32 cmdType; + uint32 streamId; + } header; + + // May include zero or more items. + struct { + uint32 registerId; + uint32 value; + } items[1]; +} PACKED +SVGAEscapeVideoSetRegs; + +typedef +struct SVGAEscapeVideoFlush { + uint32 cmdType; + uint32 streamId; +} PACKED +SVGAEscapeVideoFlush; + +#endif // _SVGA_OVERLAY_H_ diff --git a/lib/vmware/svga_reg.h b/lib/vmware/svga_reg.h new file mode 100644 index 0000000..5c5f94d --- /dev/null +++ b/lib/vmware/svga_reg.h @@ -0,0 +1,896 @@ +/********************************************************** + * Copyright 1998-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * svga_reg.h -- + * + * Virtual hardware definitions for the VMware SVGA II device. + */ + +#ifndef _SVGA_REG_H_ +#define _SVGA_REG_H_ + +/* + * PCI device IDs. + */ +#define PCI_VENDOR_ID_VMWARE 0x15AD +#define PCI_DEVICE_ID_VMWARE_SVGA2 0x0405 + +/* + * Legal values for the SVGA_REG_CURSOR_ON register in old-fashioned + * cursor bypass mode. This is still supported, but no new guest + * drivers should use it. + */ +#define SVGA_CURSOR_ON_HIDE 0x0 /* Must be 0 to maintain backward compatibility */ +#define SVGA_CURSOR_ON_SHOW 0x1 /* Must be 1 to maintain backward compatibility */ +#define SVGA_CURSOR_ON_REMOVE_FROM_FB 0x2 /* Remove the cursor from the framebuffer because we need to see what's under it */ +#define SVGA_CURSOR_ON_RESTORE_TO_FB 0x3 /* Put the cursor back in the framebuffer so the user can see it */ + +/* + * The maximum framebuffer size that can traced for e.g. guests in VESA mode. + * The changeMap in the monitor is proportional to this number. Therefore, we'd + * like to keep it as small as possible to reduce monitor overhead (using + * SVGA_VRAM_MAX_SIZE for this increases the size of the shared area by over + * 4k!). + * + * NB: For compatibility reasons, this value must be greater than 0xff0000. + * See bug 335072. + */ +#define SVGA_FB_MAX_TRACEABLE_SIZE 0x1000000 + +#define SVGA_MAX_PSEUDOCOLOR_DEPTH 8 +#define SVGA_MAX_PSEUDOCOLORS (1 << SVGA_MAX_PSEUDOCOLOR_DEPTH) +#define SVGA_NUM_PALETTE_REGS (3 * SVGA_MAX_PSEUDOCOLORS) + +#define SVGA_MAGIC 0x900000UL +#define SVGA_MAKE_ID(ver) (SVGA_MAGIC << 8 | (ver)) + +/* Version 2 let the address of the frame buffer be unsigned on Win32 */ +#define SVGA_VERSION_2 2 +#define SVGA_ID_2 SVGA_MAKE_ID(SVGA_VERSION_2) + +/* Version 1 has new registers starting with SVGA_REG_CAPABILITIES so + PALETTE_BASE has moved */ +#define SVGA_VERSION_1 1 +#define SVGA_ID_1 SVGA_MAKE_ID(SVGA_VERSION_1) + +/* Version 0 is the initial version */ +#define SVGA_VERSION_0 0 +#define SVGA_ID_0 SVGA_MAKE_ID(SVGA_VERSION_0) + +/* "Invalid" value for all SVGA IDs. (Version ID, screen object ID, surface ID...) */ +#define SVGA_ID_INVALID 0xFFFFFFFF + +/* Port offsets, relative to BAR0 */ +#define SVGA_INDEX_PORT 0x0 +#define SVGA_VALUE_PORT 0x1 +#define SVGA_BIOS_PORT 0x2 +#define SVGA_IRQSTATUS_PORT 0x8 + +/* + * Interrupt source flags for IRQSTATUS_PORT and IRQMASK. + * + * Interrupts are only supported when the + * SVGA_CAP_IRQMASK capability is present. + */ +#define SVGA_IRQFLAG_ANY_FENCE 0x1 /* Any fence was passed */ +#define SVGA_IRQFLAG_FIFO_PROGRESS 0x2 /* Made forward progress in the FIFO */ +#define SVGA_IRQFLAG_FENCE_GOAL 0x4 /* SVGA_FIFO_FENCE_GOAL reached */ + +/* + * Registers + */ + +enum { + SVGA_REG_ID = 0, + SVGA_REG_ENABLE = 1, + SVGA_REG_WIDTH = 2, + SVGA_REG_HEIGHT = 3, + SVGA_REG_MAX_WIDTH = 4, + SVGA_REG_MAX_HEIGHT = 5, + SVGA_REG_DEPTH = 6, + SVGA_REG_BITS_PER_PIXEL = 7, /* Current bpp in the guest */ + SVGA_REG_PSEUDOCOLOR = 8, + SVGA_REG_RED_MASK = 9, + SVGA_REG_GREEN_MASK = 10, + SVGA_REG_BLUE_MASK = 11, + SVGA_REG_BYTES_PER_LINE = 12, + SVGA_REG_FB_START = 13, /* (Deprecated) */ + SVGA_REG_FB_OFFSET = 14, + SVGA_REG_VRAM_SIZE = 15, + SVGA_REG_FB_SIZE = 16, + + /* ID 0 implementation only had the above registers, then the palette */ + + SVGA_REG_CAPABILITIES = 17, + SVGA_REG_MEM_START = 18, /* (Deprecated) */ + SVGA_REG_MEM_SIZE = 19, + SVGA_REG_CONFIG_DONE = 20, /* Set when memory area configured */ + SVGA_REG_SYNC = 21, /* See "FIFO Synchronization Registers" */ + SVGA_REG_BUSY = 22, /* See "FIFO Synchronization Registers" */ + SVGA_REG_GUEST_ID = 23, /* Set guest OS identifier */ + SVGA_REG_CURSOR_ID = 24, /* (Deprecated) */ + SVGA_REG_CURSOR_X = 25, /* (Deprecated) */ + SVGA_REG_CURSOR_Y = 26, /* (Deprecated) */ + SVGA_REG_CURSOR_ON = 27, /* (Deprecated) */ + SVGA_REG_HOST_BITS_PER_PIXEL = 28, /* (Deprecated) */ + SVGA_REG_SCRATCH_SIZE = 29, /* Number of scratch registers */ + SVGA_REG_MEM_REGS = 30, /* Number of FIFO registers */ + SVGA_REG_NUM_DISPLAYS = 31, /* (Deprecated) */ + SVGA_REG_PITCHLOCK = 32, /* Fixed pitch for all modes */ + SVGA_REG_IRQMASK = 33, /* Interrupt mask */ + + /* Legacy multi-monitor support */ + SVGA_REG_NUM_GUEST_DISPLAYS = 34,/* Number of guest displays in X/Y direction */ + SVGA_REG_DISPLAY_ID = 35, /* Display ID for the following display attributes */ + SVGA_REG_DISPLAY_IS_PRIMARY = 36,/* Whether this is a primary display */ + SVGA_REG_DISPLAY_POSITION_X = 37,/* The display position x */ + SVGA_REG_DISPLAY_POSITION_Y = 38,/* The display position y */ + SVGA_REG_DISPLAY_WIDTH = 39, /* The display's width */ + SVGA_REG_DISPLAY_HEIGHT = 40, /* The display's height */ + + /* See "Guest memory regions" below. */ + SVGA_REG_GMR_ID = 41, + SVGA_REG_GMR_DESCRIPTOR = 42, + SVGA_REG_GMR_MAX_IDS = 43, + SVGA_REG_GMR_MAX_DESCRIPTOR_LENGTH = 44, + + SVGA_REG_TRACES = 45, /* Enable trace-based updates even when FIFO is on */ + SVGA_REG_TOP = 46, /* Must be 1 more than the last register */ + + SVGA_PALETTE_BASE = 1024, /* Base of SVGA color map */ + /* Next 768 (== 256*3) registers exist for colormap */ + + SVGA_SCRATCH_BASE = SVGA_PALETTE_BASE + SVGA_NUM_PALETTE_REGS + /* Base of scratch registers */ + /* Next reg[SVGA_REG_SCRATCH_SIZE] registers exist for scratch usage: + First 4 are reserved for VESA BIOS Extension; any remaining are for + the use of the current SVGA driver. */ +}; + +/* + * Guest memory regions (GMRs): + * + * This is a new memory mapping feature available in SVGA devices + * which have the SVGA_CAP_GMR bit set. Previously, there were two + * fixed memory regions available with which to share data between the + * device and the driver: the FIFO ('MEM') and the framebuffer. GMRs + * are our name for an extensible way of providing arbitrary DMA + * buffers for use between the driver and the SVGA device. They are a + * new alternative to framebuffer memory, usable for both 2D and 3D + * graphics operations. + * + * Since GMR mapping must be done synchronously with guest CPU + * execution, we use a new pair of SVGA registers: + * + * SVGA_REG_GMR_ID -- + * + * Read/write. + * This register holds the 32-bit ID (a small positive integer) + * of a GMR to create, delete, or redefine. Writing this register + * has no side-effects. + * + * SVGA_REG_GMR_DESCRIPTOR -- + * + * Write-only. + * Writing this register will create, delete, or redefine the GMR + * specified by the above ID register. If this register is zero, + * the GMR is deleted. Any pointers into this GMR (including those + * currently being processed by FIFO commands) will be + * synchronously invalidated. + * + * If this register is nonzero, it must be the physical page + * number (PPN) of a data structure which describes the physical + * layout of the memory region this GMR should describe. The + * descriptor structure will be read synchronously by the SVGA + * device when this register is written. The descriptor need not + * remain allocated for the lifetime of the GMR. + * + * The guest driver should write SVGA_REG_GMR_ID first, then + * SVGA_REG_GMR_DESCRIPTOR. + * + * SVGA_REG_GMR_MAX_IDS -- + * + * Read-only. + * The SVGA device may choose to support a maximum number of + * user-defined GMR IDs. This register holds the number of supported + * IDs. (The maximum supported ID plus 1) + * + * SVGA_REG_GMR_MAX_DESCRIPTOR_LENGTH -- + * + * Read-only. + * The SVGA device may choose to put a limit on the total number + * of SVGAGuestMemDescriptor structures it will read when defining + * a single GMR. + * + * The descriptor structure is an array of SVGAGuestMemDescriptor + * structures. Each structure may do one of three things: + * + * - Terminate the GMR descriptor list. + * (ppn==0, numPages==0) + * + * - Add a PPN or range of PPNs to the GMR's virtual address space. + * (ppn != 0, numPages != 0) + * + * - Provide the PPN of the next SVGAGuestMemDescriptor, in order to + * support multi-page GMR descriptor tables without forcing the + * driver to allocate physically contiguous memory. + * (ppn != 0, numPages == 0) + * + * Note that each physical page of SVGAGuestMemDescriptor structures + * can describe at least 2MB of guest memory. If the driver needs to + * use more than one page of descriptor structures, it must use one of + * its SVGAGuestMemDescriptors to point to an additional page. The + * device will never automatically cross a page boundary. + * + * Once the driver has described a GMR, it is immediately available + * for use via any FIFO command that uses an SVGAGuestPtr structure. + * These pointers include a GMR identifier plus an offset into that + * GMR. + * + * The driver must check the SVGA_CAP_GMR bit before using the GMR + * registers. + */ + +/* + * Special GMR IDs, allowing SVGAGuestPtrs to point to framebuffer + * memory as well. In the future, these IDs could even be used to + * allow legacy memory regions to be redefined by the guest as GMRs. + * + * Using the guest framebuffer (GFB) at BAR1 for general purpose DMA + * is being phased out. Please try to use user-defined GMRs whenever + * possible. + */ +#define SVGA_GMR_NULL ((uint32) -1) +#define SVGA_GMR_FRAMEBUFFER ((uint32) -2) // Guest Framebuffer (GFB) + +typedef +struct SVGAGuestMemDescriptor { + uint32 ppn; + uint32 numPages; +} PACKED +SVGAGuestMemDescriptor; + +typedef +struct SVGAGuestPtr { + uint32 gmrId; + uint32 offset; +} PACKED +SVGAGuestPtr; + + +/* + * Capabilities + * + * Note the holes in the bitfield. Missing bits have been deprecated, + * and must not be reused. Those capabilities will never be reported + * by new versions of the SVGA device. + */ + +#define SVGA_CAP_NONE 0x00000000 +#define SVGA_CAP_RECT_COPY 0x00000002 +#define SVGA_CAP_CURSOR 0x00000020 +#define SVGA_CAP_CURSOR_BYPASS 0x00000040 // Legacy (Use Cursor Bypass 3 instead) +#define SVGA_CAP_CURSOR_BYPASS_2 0x00000080 // Legacy (Use Cursor Bypass 3 instead) +#define SVGA_CAP_8BIT_EMULATION 0x00000100 +#define SVGA_CAP_ALPHA_CURSOR 0x00000200 +#define SVGA_CAP_3D 0x00004000 +#define SVGA_CAP_EXTENDED_FIFO 0x00008000 +#define SVGA_CAP_MULTIMON 0x00010000 // Legacy multi-monitor support +#define SVGA_CAP_PITCHLOCK 0x00020000 +#define SVGA_CAP_IRQMASK 0x00040000 +#define SVGA_CAP_DISPLAY_TOPOLOGY 0x00080000 // Legacy multi-monitor support +#define SVGA_CAP_GMR 0x00100000 +#define SVGA_CAP_TRACES 0x00200000 + + +/* + * FIFO register indices. + * + * The FIFO is a chunk of device memory mapped into guest physmem. It + * is always treated as 32-bit words. + * + * The guest driver gets to decide how to partition it between + * - FIFO registers (there are always at least 4, specifying where the + * following data area is and how much data it contains; there may be + * more registers following these, depending on the FIFO protocol + * version in use) + * - FIFO data, written by the guest and slurped out by the VMX. + * These indices are 32-bit word offsets into the FIFO. + */ + +enum { + /* + * Block 1 (basic registers): The originally defined FIFO registers. + * These exist and are valid for all versions of the FIFO protocol. + */ + + SVGA_FIFO_MIN = 0, + SVGA_FIFO_MAX, /* The distance from MIN to MAX must be at least 10K */ + SVGA_FIFO_NEXT_CMD, + SVGA_FIFO_STOP, + + /* + * Block 2 (extended registers): Mandatory registers for the extended + * FIFO. These exist if the SVGA caps register includes + * SVGA_CAP_EXTENDED_FIFO; some of them are valid only if their + * associated capability bit is enabled. + * + * Note that when originally defined, SVGA_CAP_EXTENDED_FIFO implied + * support only for (FIFO registers) CAPABILITIES, FLAGS, and FENCE. + * This means that the guest has to test individually (in most cases + * using FIFO caps) for the presence of registers after this; the VMX + * can define "extended FIFO" to mean whatever it wants, and currently + * won't enable it unless there's room for that set and much more. + */ + + SVGA_FIFO_CAPABILITIES = 4, + SVGA_FIFO_FLAGS, + // Valid with SVGA_FIFO_CAP_FENCE: + SVGA_FIFO_FENCE, + + /* + * Block 3a (optional extended registers): Additional registers for the + * extended FIFO, whose presence isn't actually implied by + * SVGA_CAP_EXTENDED_FIFO; these exist if SVGA_FIFO_MIN is high enough to + * leave room for them. + * + * These in block 3a, the VMX currently considers mandatory for the + * extended FIFO. + */ + + // Valid if exists (i.e. if extended FIFO enabled): + SVGA_FIFO_3D_HWVERSION, /* See SVGA3dHardwareVersion in svga3d_reg.h */ + // Valid with SVGA_FIFO_CAP_PITCHLOCK: + SVGA_FIFO_PITCHLOCK, + + // Valid with SVGA_FIFO_CAP_CURSOR_BYPASS_3: + SVGA_FIFO_CURSOR_ON, /* Cursor bypass 3 show/hide register */ + SVGA_FIFO_CURSOR_X, /* Cursor bypass 3 x register */ + SVGA_FIFO_CURSOR_Y, /* Cursor bypass 3 y register */ + SVGA_FIFO_CURSOR_COUNT, /* Incremented when any of the other 3 change */ + SVGA_FIFO_CURSOR_LAST_UPDATED,/* Last time the host updated the cursor */ + + // Valid with SVGA_FIFO_CAP_RESERVE: + SVGA_FIFO_RESERVED, /* Bytes past NEXT_CMD with real contents */ + + /* + * XXX: The gap here, up until SVGA_FIFO_3D_CAPS, can be used for new + * registers, but this must be done carefully and with judicious use of + * capability bits, since comparisons based on SVGA_FIFO_MIN aren't + * enough to tell you whether the register exists: we've shipped drivers + * and products that used SVGA_FIFO_3D_CAPS but didn't know about some of + * the earlier ones. The actual order of introduction was: + * - PITCHLOCK + * - 3D_CAPS + * - CURSOR_* (cursor bypass 3) + * - RESERVED + * So, code that wants to know whether it can use any of the + * aforementioned registers, or anything else added after PITCHLOCK and + * before 3D_CAPS, needs to reason about something other than + * SVGA_FIFO_MIN. + */ + + /* + * 3D caps block space; valid with 3D hardware version >= + * SVGA3D_HWVERSION_WS6_B1. + */ + SVGA_FIFO_3D_CAPS = 32, + SVGA_FIFO_3D_CAPS_LAST = 32 + 255, + + /* + * End of VMX's current definition of "extended-FIFO registers". + * Registers before here are always enabled/disabled as a block; either + * the extended FIFO is enabled and includes all preceding registers, or + * it's disabled entirely. + * + * Block 3b (truly optional extended registers): Additional registers for + * the extended FIFO, which the VMX already knows how to enable and + * disable with correct granularity. + * + * Registers after here exist if and only if the guest SVGA driver + * sets SVGA_FIFO_MIN high enough to leave room for them. + */ + + // Valid if register exists: + SVGA_FIFO_GUEST_3D_HWVERSION, /* Guest driver's 3D version */ + SVGA_FIFO_FENCE_GOAL, /* Matching target for SVGA_IRQFLAG_FENCE_GOAL */ + SVGA_FIFO_BUSY, /* See "FIFO Synchronization Registers" */ + + /* + * Always keep this last. This defines the maximum number of + * registers we know about. At power-on, this value is placed in + * the SVGA_REG_MEM_REGS register, and we expect the guest driver + * to allocate this much space in FIFO memory for registers. + */ + SVGA_FIFO_NUM_REGS +}; + + +/* + * Definition of registers included in extended FIFO support. + * + * The guest SVGA driver gets to allocate the FIFO between registers + * and data. It must always allocate at least 4 registers, but old + * drivers stopped there. + * + * The VMX will enable extended FIFO support if and only if the guest + * left enough room for all registers defined as part of the mandatory + * set for the extended FIFO. + * + * Note that the guest drivers typically allocate the FIFO only at + * initialization time, not at mode switches, so it's likely that the + * number of FIFO registers won't change without a reboot. + * + * All registers less than this value are guaranteed to be present if + * svgaUser->fifo.extended is set. Any later registers must be tested + * individually for compatibility at each use (in the VMX). + * + * This value is used only by the VMX, so it can change without + * affecting driver compatibility; keep it that way? + */ +#define SVGA_FIFO_EXTENDED_MANDATORY_REGS (SVGA_FIFO_3D_CAPS_LAST + 1) + + +/* + * FIFO Synchronization Registers + * + * This explains the relationship between the various FIFO + * sync-related registers in IOSpace and in FIFO space. + * + * SVGA_REG_SYNC -- + * + * The SYNC register can be used in two different ways by the guest: + * + * 1. If the guest wishes to fully sync (drain) the FIFO, + * it will write once to SYNC then poll on the BUSY + * register. The FIFO is sync'ed once BUSY is zero. + * + * 2. If the guest wants to asynchronously wake up the host, + * it will write once to SYNC without polling on BUSY. + * Ideally it will do this after some new commands have + * been placed in the FIFO, and after reading a zero + * from SVGA_FIFO_BUSY. + * + * (1) is the original behaviour that SYNC was designed to + * support. Originally, a write to SYNC would implicitly + * trigger a read from BUSY. This causes us to synchronously + * process the FIFO. + * + * This behaviour has since been changed so that writing SYNC + * will *not* implicitly cause a read from BUSY. Instead, it + * makes a channel call which asynchronously wakes up the MKS + * thread. + * + * New guests can use this new behaviour to implement (2) + * efficiently. This lets guests get the host's attention + * without waiting for the MKS to poll, which gives us much + * better CPU utilization on SMP hosts and on UP hosts while + * we're blocked on the host GPU. + * + * Old guests shouldn't notice the behaviour change. SYNC was + * never guaranteed to process the entire FIFO, since it was + * bounded to a particular number of CPU cycles. Old guests will + * still loop on the BUSY register until the FIFO is empty. + * + * Writing to SYNC currently has the following side-effects: + * + * - Sets SVGA_REG_BUSY to TRUE (in the monitor) + * - Asynchronously wakes up the MKS thread for FIFO processing + * - The value written to SYNC is recorded as a "reason", for + * stats purposes. + * + * If SVGA_FIFO_BUSY is available, drivers are advised to only + * write to SYNC if SVGA_FIFO_BUSY is FALSE. Drivers should set + * SVGA_FIFO_BUSY to TRUE after writing to SYNC. The MKS will + * eventually set SVGA_FIFO_BUSY on its own, but this approach + * lets the driver avoid sending multiple asynchronous wakeup + * messages to the MKS thread. + * + * SVGA_REG_BUSY -- + * + * This register is set to TRUE when SVGA_REG_SYNC is written, + * and it reads as FALSE when the FIFO has been completely + * drained. + * + * Every read from this register causes us to synchronously + * process FIFO commands. There is no guarantee as to how many + * commands each read will process. + * + * CPU time spent processing FIFO commands will be billed to + * the guest. + * + * New drivers should avoid using this register unless they + * need to guarantee that the FIFO is completely drained. It + * is overkill for performing a sync-to-fence. Older drivers + * will use this register for any type of synchronization. + * + * SVGA_FIFO_BUSY -- + * + * This register is a fast way for the guest driver to check + * whether the FIFO is already being processed. It reads and + * writes at normal RAM speeds, with no monitor intervention. + * + * If this register reads as TRUE, the host is guaranteeing that + * any new commands written into the FIFO will be noticed before + * the MKS goes back to sleep. + * + * If this register reads as FALSE, no such guarantee can be + * made. + * + * The guest should use this register to quickly determine + * whether or not it needs to wake up the host. If the guest + * just wrote a command or group of commands that it would like + * the host to begin processing, it should: + * + * 1. Read SVGA_FIFO_BUSY. If it reads as TRUE, no further + * action is necessary. + * + * 2. Write TRUE to SVGA_FIFO_BUSY. This informs future guest + * code that we've already sent a SYNC to the host and we + * don't need to send a duplicate. + * + * 3. Write a reason to SVGA_REG_SYNC. This will send an + * asynchronous wakeup to the MKS thread. + */ + + +/* + * FIFO Capabilities + * + * Fence -- Fence register and command are supported + * Accel Front -- Front buffer only commands are supported + * Pitch Lock -- Pitch lock register is supported + * Video -- SVGA Video overlay units are supported + * Escape -- Escape command is supported + */ + +#define SVGA_FIFO_CAP_NONE 0 +#define SVGA_FIFO_CAP_FENCE (1<<0) +#define SVGA_FIFO_CAP_ACCELFRONT (1<<1) +#define SVGA_FIFO_CAP_PITCHLOCK (1<<2) +#define SVGA_FIFO_CAP_VIDEO (1<<3) +#define SVGA_FIFO_CAP_CURSOR_BYPASS_3 (1<<4) +#define SVGA_FIFO_CAP_ESCAPE (1<<5) +#define SVGA_FIFO_CAP_RESERVE (1<<6) + + +/* + * FIFO Flags + * + * Accel Front -- Driver should use front buffer only commands + */ + +#define SVGA_FIFO_FLAG_NONE 0 +#define SVGA_FIFO_FLAG_ACCELFRONT (1<<0) +#define SVGA_FIFO_FLAG_RESERVED (1<<31) // Internal use only + +/* + * FIFO reservation sentinel value + */ + +#define SVGA_FIFO_RESERVED_UNKNOWN 0xffffffff + + +/* + * Video overlay support + */ + +#define SVGA_NUM_OVERLAY_UNITS 32 + + +/* + * Video capabilities that the guest is currently using + */ + +#define SVGA_VIDEO_FLAG_COLORKEY 0x0001 + + +/* + * Offsets for the video overlay registers + */ + +enum { + SVGA_VIDEO_ENABLED = 0, + SVGA_VIDEO_FLAGS, + SVGA_VIDEO_DATA_OFFSET, + SVGA_VIDEO_FORMAT, + SVGA_VIDEO_COLORKEY, + SVGA_VIDEO_SIZE, // Deprecated + SVGA_VIDEO_WIDTH, + SVGA_VIDEO_HEIGHT, + SVGA_VIDEO_SRC_X, + SVGA_VIDEO_SRC_Y, + SVGA_VIDEO_SRC_WIDTH, + SVGA_VIDEO_SRC_HEIGHT, + SVGA_VIDEO_DST_X, // Signed int32 + SVGA_VIDEO_DST_Y, // Signed int32 + SVGA_VIDEO_DST_WIDTH, + SVGA_VIDEO_DST_HEIGHT, + SVGA_VIDEO_PITCH_1, + SVGA_VIDEO_PITCH_2, + SVGA_VIDEO_PITCH_3, + SVGA_VIDEO_NUM_REGS +}; + + +/* + * SVGA Overlay Units + * + * width and height relate to the entire source video frame. + * srcX, srcY, srcWidth and srcHeight represent subset of the source + * video frame to be displayed. + */ + +typedef struct SVGAOverlayUnit { + uint32 enabled; + uint32 flags; + uint32 dataOffset; + uint32 format; + uint32 colorKey; + uint32 size; + uint32 width; + uint32 height; + uint32 srcX; + uint32 srcY; + uint32 srcWidth; + uint32 srcHeight; + int32 dstX; + int32 dstY; + uint32 dstWidth; + uint32 dstHeight; + uint32 pitches[3]; +} SVGAOverlayUnit; + + +/* + * Commands in the command FIFO: + * + * Command IDs defined below are used for the traditional 2D FIFO + * communication (not all commands are available for all versions of the + * SVGA FIFO protocol). + * + * Note the holes in the command ID numbers: These commands have been + * deprecated, and the old IDs must not be reused. + * + * Command IDs from 1000 to 1999 are reserved for use by the SVGA3D + * protocol. + * + * Each command's parameters are described by the comments and + * structs below. + */ + +typedef enum { + SVGA_CMD_INVALID_CMD = 0, + SVGA_CMD_UPDATE = 1, + SVGA_CMD_RECT_COPY = 3, + SVGA_CMD_DEFINE_CURSOR = 19, + SVGA_CMD_DEFINE_ALPHA_CURSOR = 22, + SVGA_CMD_UPDATE_VERBOSE = 25, + SVGA_CMD_FRONT_ROP_FILL = 29, + SVGA_CMD_FENCE = 30, + SVGA_CMD_ESCAPE = 33, + SVGA_CMD_MAX +} SVGAFifoCmdId; + +#define SVGA_CMD_MAX_ARGS 64 + + +/* + * SVGA_CMD_UPDATE -- + * + * This is a DMA transfer which copies from the Guest Framebuffer + * (GFB) at BAR1 + SVGA_REG_FB_OFFSET to any screens which + * intersect with the provided virtual rectangle. + * + * This command is not necessary when using framebuffer + * traces. Traces are automatically enabled if the SVGA FIFO is + * disabled, and you may explicitly enable/disable traces using + * SVGA_REG_TRACES. With traces enabled, any write to the GFB will + * automatically act as if a subsequent SVGA_CMD_UPDATE was issued. + * + * Availability: + * Always available. + */ + +typedef +struct { + uint32 x; + uint32 y; + uint32 width; + uint32 height; +} PACKED +SVGAFifoCmdUpdate; + + +/* + * SVGA_CMD_RECT_COPY -- + * + * Perform a rectangular DMA transfer from one area of the GFB to + * another, and copy the result to any screens which intersect it. + * + * Availability: + * SVGA_CAP_RECT_COPY + */ + +typedef +struct { + uint32 srcX; + uint32 srcY; + uint32 destX; + uint32 destY; + uint32 width; + uint32 height; +} PACKED +SVGAFifoCmdRectCopy; + + +/* + * SVGA_CMD_DEFINE_CURSOR -- + * + * Provide a new cursor image, as an AND/XOR mask. + * + * The recommended way to position the cursor overlay is by using + * the SVGA_FIFO_CURSOR_* registers, supported by the + * SVGA_FIFO_CAP_CURSOR_BYPASS_3 capability. + * + * Availability: + * SVGA_CAP_CURSOR + */ + +typedef +struct { + uint32 id; // Reserved, must be zero. + uint32 hotspotX; + uint32 hotspotY; + uint32 width; + uint32 height; + uint32 andMaskDepth; // Value must be 1 or equal to BITS_PER_PIXEL + uint32 xorMaskDepth; // Value must be 1 or equal to BITS_PER_PIXEL + /* + * Followed by scanline data for AND mask, then XOR mask. + * Each scanline is padded to a 32-bit boundary. + */ +} PACKED +SVGAFifoCmdDefineCursor; + + +/* + * SVGA_CMD_DEFINE_ALPHA_CURSOR -- + * + * Provide a new cursor image, in 32-bit BGRA format. + * + * The recommended way to position the cursor overlay is by using + * the SVGA_FIFO_CURSOR_* registers, supported by the + * SVGA_FIFO_CAP_CURSOR_BYPASS_3 capability. + * + * Availability: + * SVGA_CAP_ALPHA_CURSOR + */ + +typedef +struct { + uint32 id; // Reserved, must be zero. + uint32 hotspotX; + uint32 hotspotY; + uint32 width; + uint32 height; + /* Followed by scanline data */ +} PACKED +SVGAFifoCmdDefineAlphaCursor; + + +/* + * SVGA_CMD_UPDATE_VERBOSE -- + * + * Just like SVGA_CMD_UPDATE, but also provide a per-rectangle + * 'reason' value, an opaque cookie which is used by internal + * debugging tools. Third party drivers should not use this + * command. + * + * Availability: + * SVGA_CAP_EXTENDED_FIFO + */ + +typedef +struct { + uint32 x; + uint32 y; + uint32 width; + uint32 height; + uint32 reason; +} PACKED +SVGAFifoCmdUpdateVerbose; + + +/* + * SVGA_CMD_FRONT_ROP_FILL -- + * + * This is a hint which tells the SVGA device that the driver has + * just filled a rectangular region of the GFB with a solid + * color. Instead of reading these pixels from the GFB, the device + * can assume that they all equal 'color'. This is primarily used + * for remote desktop protocols. + * + * Availability: + * SVGA_FIFO_CAP_ACCELFRONT + */ + +#define SVGA_ROP_COPY 0x03 + +typedef +struct { + uint32 color; // In the same format as the GFB + uint32 x; + uint32 y; + uint32 width; + uint32 height; + uint32 rop; // Must be SVGA_ROP_COPY +} PACKED +SVGAFifoCmdFrontRopFill; + + +/* + * SVGA_CMD_FENCE -- + * + * Insert a synchronization fence. When the SVGA device reaches + * this command, it will copy the 'fence' value into the + * SVGA_FIFO_FENCE register. It will also compare the fence against + * SVGA_FIFO_FENCE_GOAL. If the fence matches the goal and the + * SVGA_IRQFLAG_FENCE_GOAL interrupt is enabled, the device will + * raise this interrupt. + * + * Availability: + * SVGA_FIFO_FENCE for this command, + * SVGA_CAP_IRQMASK for SVGA_FIFO_FENCE_GOAL. + */ + +typedef +struct { + uint32 fence; +} PACKED +SVGAFifoCmdFence; + + +/* + * SVGA_CMD_ESCAPE -- + * + * Send an extended or vendor-specific variable length command. + * This is used for video overlay, third party plugins, and + * internal debugging tools. See svga_escape.h + * + * Availability: + * SVGA_FIFO_CAP_ESCAPE + */ + +typedef +struct { + uint32 nsid; + uint32 size; + /* followed by 'size' bytes of data */ +} PACKED +SVGAFifoCmdEscape; + +#endif diff --git a/lib/vmware/vmmouse_defs.h b/lib/vmware/vmmouse_defs.h new file mode 100644 index 0000000..19ed959 --- /dev/null +++ b/lib/vmware/vmmouse_defs.h @@ -0,0 +1,71 @@ +/********************************************************** + * Copyright 2002-2009 VMware, Inc. All rights reserved. + * + * 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. + * + **********************************************************/ + +/* + * vmmouse_defs.h -- + * + * VMware Virtual Mouse Protocol definitions. + * + */ + +#ifndef _VMMOUSE_DEFS_H_ +#define _VMMOUSE_DEFS_H_ + +/* + * Command related defines + */ +#define VMMOUSE_CMD_READ_ID 0x45414552 +#define VMMOUSE_CMD_DISABLE 0x000000f5 +#define VMMOUSE_CMD_REQUEST_RELATIVE 0x4c455252 +#define VMMOUSE_CMD_REQUEST_ABSOLUTE 0x53424152 + +/* + * Data related defines + */ +#define VMMOUSE_VERSION_ID_STR "JUB4" +#define VMMOUSE_VERSION_ID 0x3442554a + +/* + * Device related defines + */ +#define VMMOUSE_DATAPORT 96 +#define VMMOUSE_STATUSPORT 100 +#define VMMOUSE_IRQ 12 +#define VMMOUSE_ERROR 0xffff0000 + +/* + * VMMouse Input packet flags + */ +#define VMMOUSE_MOVE_RELATIVE 1 +#define VMMOUSE_MOVE_ABSOLUTE 0 + +/* + * VMMouse Input button flags + */ +#define VMMOUSE_LEFT_BUTTON 0x20 +#define VMMOUSE_RIGHT_BUTTON 0x10 +#define VMMOUSE_MIDDLE_BUTTON 0x08 + +#endif